CMesh.h

Go to the documentation of this file.

//==============================================================================
/*
    Software License Agreement (BSD License)
    Copyright (c) 2003-2016, CHAI3D.
    (www.chai3d.org)

    All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:

    * Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above
    copyright notice, this list of conditions and the following
    disclaimer in the documentation and/or other materials provided
    with the distribution.

    * Neither the name of CHAI3D nor the names of its contributors may
    be used to endorse or promote products derived from this software
    without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    POSSIBILITY OF SUCH DAMAGE. 

    \author    <http://www.chai3d.org>
    \author    Francois Conti
    \author    Dan Morris
    \author    Chris Sewell
    \version   3.2.0 $Rev: 2161 $
*/
//==============================================================================

//------------------------------------------------------------------------------
#ifdef _MSVC
#pragma warning (disable : 4786)
#endif
//------------------------------------------------------------------------------
#ifndef CMeshH
#define CMeshH
//------------------------------------------------------------------------------
#include "world/CGenericObject.h"
#include "materials/CMaterial.h"
#include "materials/CTexture2d.h"
#include "graphics/CColor.h"
//------------------------------------------------------------------------------
#include <vector>
#include <list>
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
namespace chai3d {
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
class cWorld;
//------------------------------------------------------------------------------

//==============================================================================
//==============================================================================
//------------------------------------------------------------------------------

// Array of vertices.
class cVertexArray;
typedef std::shared_ptr<cVertexArray> cVertexArrayPtr;

// Array of triangles.
class cTriangleArray;
typedef std::shared_ptr<cTriangleArray> cTriangleArrayPtr;

// Edges
struct cEdge;

//------------------------------------------------------------------------------

//==============================================================================
//==============================================================================
class cMesh : public cGenericObject
{
    //--------------------------------------------------------------------------
    // CONSTRUCTOR & DESTRUCTOR:
    //--------------------------------------------------------------------------
    
public:

    cMesh(cMaterialPtr a_material = cMaterialPtr());

    virtual ~cMesh();


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - GENERAL
    //--------------------------------------------------------------------------

public:

    virtual cMesh* copy(const bool a_duplicateMaterialData = false,
                        const bool a_duplicateTextureData = false, 
                        const bool a_duplicateMeshData = false,
                        const bool a_buildCollisionDetector = false);


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - GRAPHIC PROPERTIES:
    //-----------------------------------------------------------------------

public:

    virtual void setTransparencyLevel(const float a_level,
        const bool a_applyToVertices = false,
        const bool a_applyToTextures = false,
        const bool a_affectChildren = false);


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - DISPLAY LISTS:
    //-----------------------------------------------------------------------

public:

    virtual void markForUpdate(const bool a_affectChildren = false);


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - VERTICES
    //--------------------------------------------------------------------------

public:

    unsigned int newVertex(const double a_x = 0.0, 
                           const double a_y = 0.0, 
                           const double a_z = 0.0,
                           const double a_normalX = 1.0, 
                           const double a_normalY = 0.0, 
                           const double a_normalZ = 0.0,
                           const double a_textureCoordX = 0.0,
                           const double a_textureCoordY = 0.0,
                           const double a_textureCoordZ = 0.0);

    unsigned int newVertex(const cVector3d& a_pos, 
                           const cVector3d& a_normal = cVector3d(1,0,0),
                           const cVector3d& a_textureCoord = cVector3d(0,0,0),
                           const cColorf& a_color = cColorf(0,0,0,1));

    inline unsigned int getNumVertices() const { return (unsigned int)(m_vertices->getNumElements()); }

    void setVertexColor(const cColorf& a_color);


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - TRIANGLES
    //--------------------------------------------------------------------------

public:

    unsigned int newTriangle(const unsigned int a_indexVertex0,
                             const unsigned int a_indexVertex1, 
                             const unsigned int a_indexVertex2);

    unsigned int newTriangle(const cVector3d& a_vertex0 = cVector3d(0,0,0), 
                             const cVector3d& a_vertex1 = cVector3d(0,0,0),
                             const cVector3d& a_vertex2 = cVector3d(0,0,0),
                             const cVector3d& a_normal0 = cVector3d(1,0,0), 
                             const cVector3d& a_normal1 = cVector3d(1,0,0),
                             const cVector3d& a_normal2 = cVector3d(1,0,0),
                             const cVector3d& a_textureCoord0 = cVector3d(0,0,0), 
                             const cVector3d& a_textureCoord1 = cVector3d(0,0,0),
                             const cVector3d& a_textureCoord2 = cVector3d(0,0,0),
                             const cColorf& a_colorVertex0 = cColorf(0,0,0,1),
                             const cColorf& a_colorVertex1 = cColorf(0,0,0,1),
                             const cColorf& a_colorVertex2 = cColorf(0,0,0,1));

    bool removeTriangle(const unsigned int a_index);

    unsigned int getNumTriangles();

    void clear();

    void setShowTriangles(const bool a_showTriangles) { m_showTriangles = a_showTriangles; }

    bool getShowTriangles() const { return (m_showTriangles); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - EDGES
    //--------------------------------------------------------------------------

public:

    void computeAllEdges(double a_angleThresholdDeg = 40.0);

    void clearAllEdges();

    void setShowEdges(const bool a_showEdges) { m_showEdges = a_showEdges; }

    bool getShowEdges() const { return (m_showEdges); }

    void setEdgeProperties(const double a_width, 
        const cColorf& a_color);

    void setEdgeLineWidth(const double a_width) { setEdgeProperties(a_width, m_edgeLineColor); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - SURFACE NORMALS, TANGENTS, BITANGENTS
    //--------------------------------------------------------------------------

public:

    void setShowNormals(const bool a_showNormals) { m_showNormals = a_showNormals; }

    bool getShowNormals() const { return (m_showNormals); }

    void setNormalsProperties(const double a_length, const cColorf& a_color);

    void setNormalsLength(const double a_length) { setNormalsProperties(a_length, m_normalsColor); }

    void computeAllNormals();

    virtual void reverseAllNormals();

    void computeBTN();

    void setShowTangents(const bool a_showTangents) { m_showTangents = a_showTangents; }

    bool getShowTangents() const { return (m_showTangents); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - COLLISION DETECTION:
    //--------------------------------------------------------------------------

public:

    virtual void createBruteForceCollisionDetector();

    virtual void createAABBCollisionDetector(const double a_radius);


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - GEOMETRY:
    //--------------------------------------------------------------------------

public:

    void scaleXYZ(const double a_scaleX, const double a_scaleY, const double a_scaleZ);

    virtual void offsetVertices(const cVector3d& a_offset, 
                                const bool a_updateCollisionDetector = true);

    virtual cVector3d getCenterOfMass();


    //--------------------------------------------------------------------------
    // PROTECTED METHODS - INTERNAL
    //--------------------------------------------------------------------------

protected:

    virtual void render(cRenderOptions& a_options);

    virtual void renderNormals(cRenderOptions& a_options);

    virtual void renderTangents(cRenderOptions& a_options);

    virtual void renderEdges(cRenderOptions& a_options);

    virtual void renderMesh(cRenderOptions& a_options);

    virtual void updateGlobalPositions(const bool a_frameOnly);

    virtual void updateBoundaryBox();

    void copyMeshProperties(cMesh* a_obj,
        const bool a_duplicateMaterialData,
        const bool a_duplicateTextureData, 
        const bool a_duplicateMeshData,
        const bool a_buildCollisionDetector);

    virtual void scaleObject(const double& a_scaleFactor) { scaleXYZ(a_scaleFactor, a_scaleFactor, a_scaleFactor); }

    void computeLocalInteraction(const cVector3d& a_toolPos,
        const cVector3d& a_toolVel,
        const unsigned int a_IDN);


    //--------------------------------------------------------------------------
    // PROTECTED MEMBERS - DISPLAY PROPERTIES:
    //--------------------------------------------------------------------------

protected:

    bool m_showTriangles;

    bool m_showNormals;

    bool m_showTangents;

    double m_normalsLength;

    bool m_showEdges;

    double m_edgeLineWidth;

    cDisplayList m_displayListEdges;


    //--------------------------------------------------------------------------
    // PUBLIC MEMBERS - DISPLAY PROPERTIES:
    //--------------------------------------------------------------------------

public:

    cColorf m_normalsColor;

    cColorf m_edgeLineColor;


    //--------------------------------------------------------------------------
    // PUBLIC MEMBERS - TRIANGLE AND VERTEX DATA:
    //--------------------------------------------------------------------------

public:

    cVertexArrayPtr m_vertices;

    cTriangleArrayPtr m_triangles;

    std::vector<cEdge> m_edges;
};


//------------------------------------------------------------------------------
#ifndef DOXYGEN_SHOULD_SKIP_THIS
//------------------------------------------------------------------------------

//==============================================================================
//==============================================================================
struct cEdge
{
    //--------------------------------------------------------------------------
    // CONSTRUCTOR & DESTRUCTOR:
    //--------------------------------------------------------------------------

public:

    cEdge() { m_parent = NULL; m_triangle = 0; m_vertex0 = 0; m_vertex1 = 0; }

    cEdge(cMesh* a_parent, 
          int a_vertex0, 
          int a_vertex1);
   
    ~cEdge() {};


    //--------------------------------------------------------------------------
    // PUBLIC METHODS:
    //--------------------------------------------------------------------------

public:

    void set(cMesh* a_parent, 
             int a_vertex0, 
             int a_vertex1);


    //--------------------------------------------------------------------------
    // PUBLIC METHODS:
    //--------------------------------------------------------------------------

public:
    int m_vertex0;

    int m_vertex1;

    int m_triangle;

    cMesh* m_parent;
};


//------------------------------------------------------------------------------
// OPERTAOR - (IMPLEMENTED FOR EDGE SORTING PURPOSES)
//------------------------------------------------------------------------------
inline bool operator<(const cEdge& a_edge0, const cEdge& a_edge1)
{
    double tol = 0.0;

    cVector3d edge0Vertex0 = a_edge0.m_parent->m_vertices->getLocalPos(a_edge0.m_vertex0);
    cVector3d edge0Vertex1 = a_edge0.m_parent->m_vertices->getLocalPos(a_edge0.m_vertex1);
    cVector3d edge1Vertex0 = a_edge1.m_parent->m_vertices->getLocalPos(a_edge1.m_vertex0);
    cVector3d edge1Vertex1 = a_edge1.m_parent->m_vertices->getLocalPos(a_edge1.m_vertex1);


    if (cAbs(edge0Vertex0.x() - edge1Vertex0.x()) <= tol)
    {
        if (cAbs(edge0Vertex0.y() - edge1Vertex0.y()) <= tol)
        {
            if (cAbs(edge0Vertex0.z() - edge1Vertex0.z()) <= tol)
            {
                if (cAbs(edge0Vertex1.x() - edge1Vertex1.x()) <= tol)
                {
                    if (cAbs(edge0Vertex1.y() - edge1Vertex1.y()) <= tol)
                    {
                        return (edge0Vertex1.z() < edge1Vertex1.z());
                    }
                    else
                    {
                        return (edge0Vertex1.y() < edge1Vertex1.y());
                    }
                }
                else
                {
                    return (edge0Vertex1.x() < edge1Vertex1.x());
                }
            }
            else
            {
                return (edge0Vertex0.z() < edge1Vertex0.z());
            }
        }
        else
        {
            return (edge0Vertex0.y() < edge1Vertex0.y());
        }
    }
    else
    {
        return (edge0Vertex0.x() < edge1Vertex0.x());
    }
}

//------------------------------------------------------------------------------
#endif  // DOXYGEN_SHOULD_SKIP_THIS
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
} // namespace chai3d
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
#endif
//------------------------------------------------------------------------------