meshobject.h

Go to the documentation of this file.

#ifndef VART_MESHOBJECT_H
#define VART_MESHOBJECT_H

#include "vart/mesh.h"
#include "vart/point4d.h"
#include "vart/graphicobj.h"
#include "vart/transform.h"
#include <vector>
#include <list>
#include <map>

namespace VART {
    class MeshObject : public GraphicObj {
        friend std::ostream& operator<<(std::ostream& output, const MeshObject& m);

        public:
        // PUBLIC METHODS
            MeshObject();
            MeshObject(const MeshObject& obj);
            MeshObject& operator=(const MeshObject& obj);

            virtual VART::SceneNode * Copy();

            void SetMaterial(const Material& mat);

            void MakeBox(double minX, double maxX, double minY, double maxY, double minZ, double maxZ);

            void GetYProjection(std::list<Point4D>* resultPtr, double height=0) const;

            void Optimize();

            void Clear();

            void SetVertices(const std::vector<Point4D>& vertexVec);

            void SetNormals(const std::vector<Point4D>& normalVec);

            void SetVertices(const char* vertexStr);

            void SetVertex(unsigned int index, const Point4D& newValue);

            const std::vector<double>& GetVerticesCoordinates() { return vertCoordVec; }

            void AddFace(const char* indexStr);

            void AddMesh(const Mesh& m);

            virtual void ComputeBoundingBox();
            void ComputeBoundingBox(const Transform& trans, BoundingBox* bbPtr);

            void ComputeSubBBoxes( const Transform& trans, int subdivisions );
            
            std::vector<VART::BoundingBox> GetSubBBoxes() { return subBBoxes; };

            virtual TypeID GetID() const { return MESH_OBJECT; }

            void MergeWith(const MeshObject& obj);

            void ApplyTransform(const Transform& trans);

            //~ /// \brief Splits the object along some plane parallel to XZ.
            //~ /// \param y [in] Position of the cutting plane.
            //~ /// \param ptObjAbove [out] Parts that lie below the cutting plane.
            //~ /// \param ptObjBelow [out] Parts that lie above the cutting plane.
            //~ ///
            //~ /// Splits an object into two, along a cutting plane. The two resulting objects
            //~ /// are returned by filling the objects pointed by ptObjAbove and ptObjBelow, which
            //~ /// must not contain previous geometry (use Clear()). If the cutting plane does not
            //~ /// intersect the object, one of the resulting objects will be empty (check with
            //~ /// IsEmpty()).
            //~ void YSplit(double y, MeshObject* ptObjBelow, MeshObject* ptObjAbove) const;

            bool IsEmpty() { return meshList.empty(); }

            Point4D GetVertex(unsigned int pos);

            void SmallerVertex(Point4D* resultPtr);

            Point4D GetVertexMedia();

            void ComputeVertexNormals();

        // STATIC PUBLIC METHODS
            static void ComputeTriangleNormal(const Point4D& v1, const Point4D& v2,
                                              const Point4D& v3, Point4D* resultPtr);

            static bool ReadFromOBJ(const std::string& filename, std::list<MeshObject*>* resultPtr);

            unsigned int NumFaces();

        // STATIC PUBLIC ATTRIBUTES
            static float sizeOfNormals;

        protected:
        // PROTECTED NESTED CLASSES
            class VertexTriplet {
                public:
                    VertexTriplet(unsigned int vi, unsigned int ti, unsigned int ni)
                        :vertexIndex(vi), textIndex(ti), normIndex(ni) {}
                    bool operator < (VertexTriplet indexes) const {
                        if (vertexIndex != indexes.vertexIndex)
                            return vertexIndex < indexes.vertexIndex;
                        if (textIndex != indexes.textIndex)
                            return textIndex < indexes.textIndex;
                        else
                            return normIndex < indexes.normIndex;
                    }
                    unsigned int vertexIndex;
                    unsigned int textIndex;
                    unsigned int normIndex;
            };

        // PROTECTED METHODS
            virtual bool DrawInstanceOGL() const;

            void AddNormal(unsigned int idx, const Point4D& vec);

            Point4D Vertex(unsigned int i) const {
                return Point4D(vertCoordVec[i*3], vertCoordVec[i*3+1], vertCoordVec[i*3+2]); }

            void NormalizeAllNormals();

        // PROTECTED ATTRIBUTES
            std::vector<Point4D> vertVec;

            std::vector<double> vertCoordVec;

            std::vector<Point4D> normVec;

            std::vector<double> normCoordVec;

            std::vector<float> textCoordVec;

            std::list<Mesh> meshList;

        // PROTECTED STATIC METHODS
            static void ReadVertex(std::istringstream& iss, unsigned int* vi, unsigned int* ti, unsigned int* ni);

            static void ReadMaterialTable(const std::string& filename,
                                          std::map<std::string,Material>* matMapPtr);

            static void ReadVerticesLine(std::istringstream& input,
                                         std::list<VertexTriplet>* resultPtr);


        private:
        // PRIVATE METHODS
            void subDivideBBox( VART::BoundingBox motherBox, int subdivisions, std::vector<VART::Point4D> pointList );

            void computeNewSubBBox( VART::BoundingBox oldBox, int subdivisions, std::vector<VART::Point4D> pointList);

        // PRIVATE ATRIBUTES
            std::vector<VART::BoundingBox> subBBoxes;

    }; // end class declaration
} // end namespace

#endif