D:/CHAI3D/build-2-0-0/2.0.0/win32/src/scenegraph/CMesh.h

Go to the documentation of this file.

//===========================================================================
/*
    This file is part of the CHAI 3D visualization and haptics libraries.
    Copyright (C) 2003-2009 by CHAI 3D. All rights reserved.

    This library is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License("GPL") version 2
    as published by the Free Software Foundation.

    For using the CHAI 3D libraries with software that can not be combined
    with the GNU GPL, and for taking advantage of the additional benefits
    of our support services, please contact CHAI 3D about acquiring a
    Professional Edition License.

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

//---------------------------------------------------------------------------
#ifdef _MSVC
#pragma warning (disable : 4786)
#endif
//---------------------------------------------------------------------------
#ifndef CMeshH
#define CMeshH
//---------------------------------------------------------------------------
#include "scenegraph/CGenericObject.h"
#include "graphics/CMaterial.h"
#include "graphics/CTexture2D.h"
#include "graphics/CColor.h"
#include <vector>
#include <list>
//---------------------------------------------------------------------------
using std::list;
using std::vector;
//---------------------------------------------------------------------------
class cWorld;
class cTriangle;
class cVertex;
//---------------------------------------------------------------------------

//===========================================================================
//===========================================================================

//===========================================================================
//===========================================================================
class cMesh : public cGenericObject
{

  public:

    //-----------------------------------------------------------------------
    // CONSTRUCTOR & DESTRUCTOR:
    //-----------------------------------------------------------------------

    cMesh(cWorld* a_world);

    virtual ~cMesh();


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

    cWorld* getParentWorld() const { return (m_parentWorld); }

    void setParentWorld(cWorld* a_world) { m_parentWorld = a_world; }

    virtual bool loadFromFile(const string& a_fileName);


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

    unsigned int newVertex(const double a_x, const double a_y, const double a_z);

    unsigned int newVertex(const cVector3d& a_pos) { return( newVertex(a_pos.x, a_pos.y, a_pos.z) ); }

    void addVertices(const cVector3d* a_vertexPositions, const unsigned int& a_numVertices);

    bool removeVertex(const unsigned int a_index);

    cVertex* getVertex(unsigned int a_index, bool a_includeChildren = false);

        inline const cVertex* getVertex(unsigned int a_index, bool a_includeChildren = false) const
    {
        return (const cVertex*)(getVertex(a_index,a_includeChildren));
    }

    unsigned int getNumVertices(bool a_includeChildren = false) const;

    inline virtual vector<cVertex>* pVertices() { return (&m_vertices); }

        inline virtual const vector<cVertex>* pVertices() const { return (&m_vertices); }

    virtual vector<cVertex>* pVerticesNonEmpty();


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

    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, const cVector3d& a_vertex1,
                             const cVector3d& a_vertex2);

    bool removeTriangle(const unsigned int a_index);

    cTriangle* getTriangle(unsigned int a_index, bool a_includeChildren = false);

    unsigned int getNumTriangles(bool a_includeChildren = false) const;

    void clear();

    inline vector<cTriangle>* pTriangles() { return (&m_triangles); }


    //-----------------------------------------------------------------------
    // METHODS - GRAPHIC RENDERING
    //-----------------------------------------------------------------------

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

    void setVertexColor(const cColorf& a_color, const bool a_affectChildren=true);

    void useDisplayList(const bool a_useDisplayList, const bool a_affectChildren=true);

    void useVertexArrays(const bool a_useVertexArrays, const bool a_affectChildren=true);

    bool getDisplayListEnabled() const { return m_useDisplayList; }

    void invalidateDisplayList(const bool a_affectChildren=true);

    void setShowNormals(const bool& a_showNormals, const bool a_affectChildren=true, const bool a_trianglesOnly = false);

    bool getShowNormals() const { return m_showNormals; }

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

    bool getColorsEnabled() const { return m_useVertexColors; }

    virtual void onDisplayReset(const bool a_affectChildren = true);


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

    virtual void createBruteForceCollisionDetector(bool a_affectChildren, bool a_useNeighbors);

    virtual void createAABBCollisionDetector(double a_radius, bool a_affectChildren, bool a_useNeighbors);

    virtual void createSphereTreeCollisionDetector(double a_radius, bool a_affectChildren, bool a_useNeighbors);

    void createTriangleNeighborList(bool a_affectChildren);

    void findNeighbors(std::vector<cTriangle*>* search1,
                             std::vector<cTriangle*>* search2, const int& v1, const int& v2);


    //-----------------------------------------------------------------------
    // METHODS - MESH MANIPULATION:
    //-----------------------------------------------------------------------

    void computeAllNormals(const bool a_affectChildren=false);

    void extrude(const double a_extrudeDistance, const bool a_affectChildren=false,
      const bool a_updateCollisionDetector=false);

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

    virtual void scaleObject(const cVector3d& a_scaleFactors);

    inline virtual cMesh* createMesh() const { return new cMesh(m_parentWorld); }

    virtual void renderMesh(const int a_renderMode=0);

    virtual cVector3d getCenterOfMass(const bool a_includeChildren=0);

    virtual void reverseAllNormals(const bool a_affectChildren=0);

    virtual void removeRedundantTriangles(const bool a_affectChildren=0);


  protected:

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

    virtual void render(const int a_renderMode=0);

    virtual void renderNormals(const bool a_trianglesOnly=true);

    virtual void updateGlobalPositions(const bool a_frameOnly);

    virtual void updateBoundaryBox();


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

    cWorld *m_parentWorld;

    bool m_showNormals;

    bool m_showNormalsForTriangleVerticesOnly;

    cColorf m_showNormalsColor;

    double m_showNormalsLength;

    bool m_useDisplayList;

    bool m_useVertexArrays;

    int m_displayList;


    //-----------------------------------------------------------------------
    // MEMBERS - ARRAYS:
    //-----------------------------------------------------------------------

    vector<cVertex> m_vertices;

    list<unsigned int> m_freeVertices;

    vector<cTriangle> m_triangles;

    list<unsigned int> m_freeTriangles;
};

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

---

CHAI3D 2.0.0 documentation
Please address any questions to support@chai3d.org
(C) 2003-2009 - CHAI 3D
All Rights Reserved.