StaticMesh.hpp

Go to the documentation of this file.

 /*
 * StaticMesh.h
 *
 *  Created on: 12.11.2008
 *      Author: Thomas Wiemann
 */

#ifndef STATICMESH_H_
#define STATICMESH_H_

#ifdef WIN32
#pragma warning(disable: 4996)
#endif

#include <stdlib.h>
#include <string>
#include <string.h>
#include <sstream>

#ifdef _MSC_VER
#include <Windows.h>
#endif

#ifndef __APPLE__
#include <GL/gl.h>
#else
#include <OpenGL/gl.h>
#endif

#include "lvr2/display/Renderable.hpp"
#include "lvr2/geometry/BoundingBox.hpp"

using namespace std;


namespace lvr2
{

enum
{
    RenderSurfaces            = 0x01,
    RenderTriangles           = 0x02,
    RenderSurfaceNormals      = 0x04,
    RenderVertexNormals       = 0x08,
    RenderColors              = 0x10,
};

class StaticMesh : public Renderable
{
public:
        StaticMesh();
        StaticMesh( ModelPtr model, string name=""); // <unnamed static mesh>" );
        StaticMesh( MeshBufferPtr buffer, string name=""); //<unnamed static mesh>" );

        StaticMesh(const StaticMesh &o);
        ~StaticMesh();
        inline void render();

        virtual void finalize();
        virtual void savePLY(string filename);
        virtual void setName(string name);

        floatArr                getVertices();
        uintArr                 getIndices();
        float*          getNormals();

        size_t                  getNumberOfVertices();
        size_t                  getNumberOfFaces();

        void setRenderMode(int mode) { m_renderMode = mode;}
        int  getRenderMode() { return m_renderMode;}

private:

        void init( MeshBufferPtr mesh );

        void interpolateNormals();
        void setDefaultColors();
        void calcBoundingBox();

protected:

        //void compileDisplayLists();
        void compileColoredMeshList();
        void compileWireframeList();
        void compileNameList();

        void setColorMaterial(float r, float g, float b);


        void readPly(string filename);

        floatArr        m_normals;
        float*          m_faceNormals;
        floatArr        m_vertices;
        ucharArr        m_colors;
        unsigned char*  m_blackColors;

        indexArray      m_faces;

        bool            m_finalized;
        bool                    m_haveMaterials;

        size_t          m_numVertices;
        size_t          m_numFaces;
        size_t          m_numMaterials;

        int             m_renderMode;


        int             m_coloredMeshList;
        int             m_wireframeList;
        int                             m_nameList;

};

void StaticMesh::render(){

        if(m_active)
        {
                if(m_finalized){
                    glPushMatrix();
                    glMultMatrixf(m_transformation.getData());
                    if(m_renderMode & RenderSurfaces)
                    {
                        glEnable(GL_LIGHTING);
                        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
                        glCallList(m_coloredMeshList);
                        glCallList(m_nameList);
                    }

                    if(m_renderMode & RenderTriangles)
                    {
                        glDisable(GL_LIGHTING);
                        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
                        glLineWidth(m_lineWidth);
                        glColor3f(0.0, 0.0, 0.0);
                        glCallList(m_wireframeList);
                        glEnable(GL_LIGHTING);
                    }
                    glPopMatrix();

                }
        }
}

} // namespace lvr2

#endif /* STATICMESH_H_ */