Mesh.h

// ===========================================================================
// Imagine++ Libraries
// Copyright (C) Imagine
// For detailed information: http://imagine.enpc.fr/software
// ===========================================================================

#ifndef IMAGINE_GRAPHICS_MESH_H
#define IMAGINE_GRAPHICS_MESH_H

#include "Types.h"
#include <vector>
#include <cstdlib>

#ifdef IMAGINE_OPENGL

class QOpenGLShaderProgram;

namespace Imagine {

    enum MeshColorMode
    {
        CONSTANT_COLOR,
        FACE_COLOR,
        VERTEX_COLOR,
        FACE_VALUE,
        VERTEX_VALUE
    };

    enum MeshShadingMode
    {
        FLAT_SHADING,
        SMOOTH_SHADING
    };

    enum MeshFaceMode
    {
        POINT,
        LINE,
        FILL
    };

    enum MeshData
    {
        VERTEX,
        TRIANGLE,
        QUAD
    };

    // ====================================================================== //
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    class MeshInternal;         // Private
#endif

    class Mesh;
    void showMesh(const Mesh& M, bool reinitCam=true);
    void hideMesh(const Mesh& M, bool reinitCam=true);

    class Mesh
    {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
        MeshInternal* priv;
        int *count;
        void kill();
    public:
        bool operator<(const Mesh& mesh) const; // To put them in a std::set
        void drawMesh(MeshFaceMode faceMode, QOpenGLShaderProgram* prog,
                      const FVector<float,4>& light) const;
        FloatPoint3 sum(int& nvertices) const;
        float spread(const FloatPoint3& center) const;
#endif
    public: /* constructor & destructor */
        Mesh();
        Mesh(const FloatPoint3* vertices, int nvertices,
             const Triangle* triangles=0, int ntriangles=0,
             const Quad* quads=0, int nquads=0,
             MeshColorMode colorMode=CONSTANT_COLOR,
             MeshShadingMode shadingMode=SMOOTH_SHADING,
             const FloatVector3* normals=0);
        Mesh(const DoublePoint3 *vertices, int nvertices,
             const Triangle* triangles=0, int ntriangles=0,
             const Quad *quads=0, int nquads=0,
             MeshColorMode colorMode=CONSTANT_COLOR,
             MeshShadingMode shadingMode=SMOOTH_SHADING,
             const DoubleVector3* normals=0);
        Mesh(const std::vector<FloatPoint3>& vertices,
             const std::vector<Triangle>& triangles=std::vector<Triangle>(),
             const std::vector<Quad>& quads=std::vector<Quad>(),
             MeshColorMode colorMode=CONSTANT_COLOR,
             MeshShadingMode shadingMode=SMOOTH_SHADING,
             const std::vector<FloatVector3>& normals=std::vector<FloatVector3>());
        Mesh(const Mesh&);
        ~Mesh();
        
        friend bool readMeshFromObjFile(Mesh& mesh,const std::string& fileName);

        Mesh& operator=(const Mesh&);

        bool operator==(const Mesh& mesh) const { return (count==mesh.count); }
        bool operator!=(const Mesh& mesh) const { return !operator==(mesh); }

        friend void showMesh(const Mesh& M, bool reinitCam);
        friend void hideMesh(const Mesh& M, bool reinitCam);

    public: /* Accessors */
        void setVertices(const FloatPoint3 *vertices,
                         const FloatVector3 *normals=0);
        void setVertices(const DoublePoint3 *vertices,
                         const DoubleVector3 *normals=0);
        const std::vector<FloatPoint3>& vertices() const;
        void setGeometry(const FloatPoint3 *vertices, int nvertices,
                         const Triangle *triangles=0, int ntriangles=0,
                         const Quad *quads=0, int nquads=0,
                         const FloatVector3 *normals=0);
        void setGeometry(const DoublePoint3 *vertices, int nvertices,
                         const Triangle *triangles=0, int ntriangles=0,
                         const Quad *quads=0, int nquads=0,
                         const DoubleVector3 *normals=0);


        void setColor(Color col);
        void setColors(MeshData data, const Color *col);
        void setRange(float v0, float v1);
        void setValues(MeshData data, const float *val);
        void setDefaultLookupTable();
        void setLookupTable(Color col0, Color col1);
 
        void setOpacity(float opacity);
        float getOpacity() const;

        /* Static Convenience Functions*/

        static Mesh Arrow(const DoublePoint3 &base, const DoubleVector3 &shaft,
                          double r, int resolution=32);
        static Mesh Cone(const DoublePoint3 &base, const DoubleVector3 &axis,
                         double r, int resolution=32);
        static Mesh Cube(const DoublePoint3&center, const DoubleVector3&axis1,
                         const DoubleVector3&axis2, const DoubleVector3&axis3);
        static Mesh Cylinder(const DoublePoint3 &center,
                             const DoubleVector3&axis, double r, int res=32);
        static Mesh Plane(const DoublePoint3&center,
                          const DoubleVector3&axis1, const DoubleVector3&axis2);
        static Mesh PointCloud(const DoublePoint3 *points, int n);
        static Mesh PolyLine(DoublePoint3 *points, int n, bool closed);
        static Mesh Sphere(const DoublePoint3 &center, double r, int res=24);
    };

} /* namespace Imagine */

#endif /* IMAGINE_GRAPHICS_MESH_H */

#endif