VrmlLoader.hh

Go to the documentation of this file.

 
#ifdef OPEN_GL
 
 
#ifndef _VRML_LOADER_HH_
#define _VRML_LOADER_HH_
 
 
#ifndef deg2rad
    #define deg2rad(x) x*(3.141592f/180.0f)
#endif
 
#ifndef GLM_FORCE_RADIANS
    #define GLM_FORCE_RADIANS
#endif
 
#include <glm.hpp>
#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
 
 
#include <vector>
 
 
namespace OpenGLMbs{
 
 
class VrmlNode{
    public:
        virtual ~VrmlNode();
 
        void SetName(std::string n){}
 
        virtual std::ostream& ToString(std::ostream& str) const;
 
        virtual void PushVertices(std::vector<glm::vec3> &vert,
                                  std::vector<glm::vec3> &col,
                                  glm::mat4& abs_transform){}
 
    private:
        std::string name;
};
 
class VrmlSFNode : public VrmlNode{
 
};
 
 
class VrmlGroup : public VrmlSFNode{
 
    public:
 
        virtual ~VrmlGroup();
 
        void AddChild(VrmlNode* newChild){
            children.push_back(newChild);
        }
        std::vector<VrmlNode*> GetChildren() const{  return children; }
 
        int GetNbChildren(){
            return (int) children.size();
        }
 
        virtual std::ostream& ToString(std::ostream& str) const;
 
        virtual void PushVertices(std::vector<glm::vec3> &vert,
                                  std::vector<glm::vec3> &col,
                                  glm::mat4& abs_transform);
 
    protected:
        std::vector<VrmlNode*> children;
 
};
 
 
class VrmlTransform : public VrmlGroup{
 
    public:
 
        VrmlTransform();
 
        void SetTranslation(glm::vec3 const& vec){ translation=vec; }
        glm::vec3 GetTranslation() const { return translation; }
 
        void SetRotationAxis(glm::vec3 const& vec){ rotation_axis=vec; }
        glm::vec3 GetRotationAxis() const { return rotation_axis; }
 
        void SetRotationAngle(float const& v){ rotation_angle=v; }
        float GetRotationAngle() const { return rotation_angle; }
 
        void SetScale(glm::vec3 const& vec){ scale=vec; }
        glm::vec3 GetScale() const { return scale; }
 
        virtual std::ostream& ToString(std::ostream& str) const;
 
        virtual void PushVertices(std::vector<glm::vec3> &vert,
                                  std::vector<glm::vec3> &col,
                                  glm::mat4& abs_transform);
 
 
    private:
        glm::vec3 translation;
        glm::vec3 rotation_axis;
        float rotation_angle;
        glm::vec3 scale;
};
 
 
class VrmlMaterial: public VrmlSFNode{
    public:
        VrmlMaterial();
 
        void SetDiffuseColor(glm::vec3 const& vec){ diffuseColor=vec; }
        glm::vec3 GetDiffuseColor() const { return diffuseColor; }
 
        void SetEmissiveColor(glm::vec3 const& vec){ emissiveColor=vec; }
        glm::vec3 GetEmissiveColor() const { return emissiveColor; }
 
        void SetSpecularColor(glm::vec3 const& vec){ specularColor=vec; }
        glm::vec3 GetSpecularColor() const { return specularColor; }
 
        void SetShininess(float v){shininess = v;    }
        float GetShininess() const{ return shininess;}
        void SetTransparency(float v){ transparency = v;}
        float GetTransparency() const{ return transparency;}
        void SetAmbientIntensity(float v){ ambientIntensity = v;}
        float GetAmbientIntensity() const{ return ambientIntensity;}
 
    private:
        glm::vec3 diffuseColor;
        glm::vec3 emissiveColor;
        glm::vec3 specularColor;
        float shininess;
        float transparency;
        float ambientIntensity;
};
 
 
class VrmlAppearance: public VrmlSFNode{
    public:
 
        VrmlAppearance();
        ~VrmlAppearance();
 
        void SetMaterial(VrmlMaterial* mat) { material = mat;        }
        VrmlMaterial& GetMaterial() const{ return (*material);        }
 
    private:
        VrmlMaterial *material;
 
};
 
class VrmlGeometry{
    public:
        virtual ~VrmlGeometry(){}
 
        virtual void PushVertices(std::vector<glm::vec3> &vert,
                                  std::vector<glm::vec3> &col,
                                  glm::mat4& abs_transform,
                                  glm::vec3 curColor) = 0;
 
        virtual std::ostream& ToString(std::ostream& str) const =0;
};
 
class VrmlSphere : public VrmlGeometry{
    public:
        VrmlSphere();
        virtual ~VrmlSphere(){}
 
        virtual void PushVertices(std::vector<glm::vec3> &vert,
                                  std::vector<glm::vec3> &col,
                                  glm::mat4& abs_transform,
                                  glm::vec3 curColor);
 
        virtual std::ostream& ToString(std::ostream& str) const;
 
        void SetRadius(float r){radius = r;}
 
    private:
        float radius;
};
 
 
class VrmlCone : public VrmlGeometry{
    public:
        VrmlCone();
        virtual ~VrmlCone(){}
 
        virtual void PushVertices(std::vector<glm::vec3> &vert,
                                  std::vector<glm::vec3> &col,
                                  glm::mat4& abs_transform,
                                  glm::vec3 curColor);
 
        virtual std::ostream& ToString(std::ostream& str) const;
 
        void SetBottomRadius(float r){bottomRadius = r;}
        void SetHeight(float h){height = h;}
 
    private:
        float bottomRadius;
        float height;
};
 
class VrmlCylinder : public VrmlGeometry{
    public:
        VrmlCylinder();
        virtual ~VrmlCylinder(){}
 
        virtual void PushVertices(std::vector<glm::vec3> &vert,
                                  std::vector<glm::vec3> &col,
                                  glm::mat4& abs_transform,
                                  glm::vec3 curColor);
 
        virtual std::ostream& ToString(std::ostream& str) const;
 
        void SetRadius(float r){radius = r;}
        void SetHeight(float h){height = h;}
 
    private:
        float radius;
        float height;
};
 
class VrmlBox : public VrmlGeometry{
    public:
        VrmlBox();
        virtual ~VrmlBox(){}
 
        virtual void PushVertices(std::vector<glm::vec3> &vert,
                                  std::vector<glm::vec3> &col,
                                  glm::mat4& abs_transform,
                                  glm::vec3 curColor);
 
        virtual std::ostream& ToString(std::ostream& str) const;
 
        void SetSize(glm::vec3 const& s){size = s;}
 
    private:
        glm::vec3 size;
};
 
 
 class VrmlIndexedFaceSet: public VrmlGeometry{
    public:
 
        VrmlIndexedFaceSet();
        virtual ~VrmlIndexedFaceSet();
 
        virtual std::ostream& ToString(std::ostream& str) const;
 
        virtual void PushVertices(std::vector<glm::vec3> &vert,
                                  std::vector<glm::vec3> &col,
                                  glm::mat4& abs_transform,
                                  glm::vec3 curColor);
 
        void SetSolid(bool b){ solid = b;}
        bool GetSolid()      { return solid;}
 
        void SetNormalPerVertex(bool b){ normalPerVertex = b;}
        bool GetNormalPerVertex()      { return normalPerVertex;}
 
        void SetColorPerVertex(bool b){ colorPerVertex = b;}
        bool GetColorPerVertex()      { return colorPerVertex;}
 
        void SetCreaseAngle(float v){ creaseAngle = v;}
        float GetCreaseAngle()      { return creaseAngle;}
 
        void SetVertexCoordInds(std::vector<std::vector<int> >& vec){  face_indices = vec;}
        void SetNormalInds(std::vector<std::vector<int> >& vec){          normal_indices=vec;    }
        void SetColorInds(std::vector<int>& vec){           color_indices=vec;     }
 
        void SetVertexCoords(std::vector<glm::vec3>& vec){  vert_coords=vec;}
        void SetNormals(std::vector<glm::vec3>& vec){       normals=vec;    }
        void SetColors(std::vector<glm::vec3> const& vec){        colors=vec;     }
 
    private:
        bool solid;
        bool normalPerVertex;
        bool colorPerVertex;
        float creaseAngle;
        std::vector<glm::vec3> vert_coords;
        std::vector<glm::vec3> normals;
        std::vector<glm::vec3> colors;
        std::vector<std::vector<int> > face_indices;
        std::vector<std::vector<int> > normal_indices;
        std::vector<int> color_indices;
};
 
 
class VrmlShape: public VrmlSFNode{
    public:
        virtual ~VrmlShape();
 
        void SetGeometry(VrmlGeometry* geom){ geometry = geom; }
        void SetAppearance(VrmlAppearance* app){ appearance = app; }
 
        virtual void PushVertices(std::vector<glm::vec3> &vert,
                                  std::vector<glm::vec3> &col,
                                  glm::mat4& abs_transform);
 
        virtual std::ostream& ToString(std::ostream& str) const;
 
 
    private:
        VrmlGeometry* geometry;
        VrmlAppearance* appearance;
};
 
 
class VrmlLoader
{
    public:
        VrmlLoader();
        ~VrmlLoader();
        int ParseVRML(std::string vrml_file);
 
        int PushVertices(std::vector<glm::vec3> &vert, std::vector<glm::vec3> &col);
 
    private:
        VrmlGroup*      ParseGroup();
        VrmlTransform*  ParseTransform();
        VrmlShape*      ParseShape();
        VrmlAppearance* ParseAppearance();
        VrmlMaterial*   ParseMaterial();
        VrmlSphere*     ParseSphere();
        VrmlCone*       ParseCone();
        VrmlCylinder*   ParseCylinder();
        VrmlBox*        ParseBox();
        VrmlIndexedFaceSet* ParseIndexedFaceSet();
        void ParseChildren(VrmlGroup* group);
        void GetNextToken();
        void SearchClosingBracket();
        void ParseNode(VrmlGroup* group);
 
        std::vector<glm::vec3>* ParseCoordinates();
        std::vector<std::vector<int> >* ParseIndexListForFace();
        std::vector<int>* ParseIndexListForPt();
 
 
        void ParseIgnoredToken();
        bool ParseBoolToken();
        float ParseFloatToken();
        int ParseIntToken();
        glm::vec3  ParseFloatVec3();
 
        void SkipToClosingBrac(char openBrac, char closingBrac);
 
        void CheckSaveName();
        void CheckOpeningBracket(char brac);
 
        void Error(const char* message);
        void Warning(const char* message);
        void EndParseElemMsg(const char* node_type, const char* add_msg);
        void StartParseElemMsg(const char* node_type, const char* add_msg);
 
        int current_line_nb; 
 
        std::string vrml_file;
        std::string cur_line;
        char *pch; 
        char* cur_line_char; 
        std::ifstream* file;
 
        VrmlGroup* group;
 
};
 
 
} // end of namespace OpenGLMbs{
 
 
#endif //_VRML_LOADER_HH_
#endif // OPEN_GL