Program Listing for File StaticMesh.hpp

↰ Return to documentation for file (include/lvr2/display/StaticMesh.hpp)

 /*
 * 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"


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(std::string filename);
    virtual void setName(std::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(std::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_ */