Geometry.h

Go to the documentation of this file.

#ifndef B_GEOMETRY_H
#define B_GEOMETRY_H

#include <string>
#include <fstream>
#include <memory>
#include "GeometryData.h"
#include "Material.h"
#include "Texture.h"
#include "Properties.h"
#include "Renderer_GL.h"
#include "IDrawable.h"
#include "Geometry.h"
#include "vmmlib/aabb.hpp"

class Geometry : public IDrawable
{
public:
    /* Typedefs */
    typedef std::shared_ptr< Vertex >   VertexDataPtr;
    typedef std::shared_ptr< GLushort > IndexDataPtr;
    typedef std::unordered_map< std::string, PropertiesPtr >    PropertiesMap;

    /* Functions */

    Geometry(){ _initialized = false; }

    virtual ~Geometry() {
        deleteGeometry();
    }

    virtual void initialize(GeometryDataPtr geometryData);

    virtual void draw(GLenum mode = GL_TRIANGLES) override;

    virtual void drawInstance(const std::string &instanceName, GLenum mode = GL_TRIANGLES) override;

    PropertiesPtr   addInstance(const std::string &instanceName);

    virtual void addInstance(const std::string &instanceName, PropertiesPtr instanceProperties);

    virtual PropertiesPtr   getInstanceProperties(const std::string &instanceName);

    virtual void            removeInstance(const std::string &instanceName);

    virtual void            clearInstances();

    VertexDataPtr   getVertexData()                 { return _vertexData;   }

    IndexDataPtr    getIndexData()                  { return _indexData; }

    size_t          getNumVertices()                { return _nVertices; }

    size_t          getNumIndices()                 { return _nIndices; }
    
    void            setVertexData(VertexDataPtr arg)    { _vertexData   = arg;  }

    void            setIndexData(IndexDataPtr arg)      { _indexData    = arg;  }
    
    MaterialPtr     getMaterial()                   { return _material; }

    void            setMaterial(MaterialPtr arg)        { _material     = arg;  }

    PropertiesPtr     getProperties()                   { return _properties; }

    void            setProperties(PropertiesPtr arg)    { _properties = arg; }

    vmml::AABBf     &getBoundingBoxObjectSpace()                    { return _boundingBox; }

    void            setBoundingBoxObjectSpace(vmml::AABBf arg)                      { _boundingBox = arg; }

    virtual void deleteGeometry()
    {
        if (_vertexBuffer)
            glDeleteBuffers(1, &_vertexBuffer);
        _initialized = false;
    }

protected:

    /* Functions */

    virtual void initializeVertexBuffer();

    virtual VertexDataPtr   allocVertexData(size_t nVertices);

    virtual IndexDataPtr    allocIndexData(size_t nIndices);

    virtual VertexDataPtr   copyVertexData(const GeometryData::VboVertices &arg);

    virtual IndexDataPtr    copyIndexData(const GeometryData::VboIndices &arg);

    virtual vmml::AABBf createBoundingBoxObjectSpace(const GeometryData::VboVertices &arg);

private:

    /* Variables */

    bool _initialized = false;
    GLuint _indexBuffer = 0, _vertexBuffer = 0;
    size_t _nIndices = 0, _nVertices = 0;
    
    VertexDataPtr   _vertexData = nullptr;
    IndexDataPtr    _indexData = nullptr;
    
    MaterialPtr _material = nullptr;
    PropertiesPtr _properties = nullptr;

    vmml::AABBf _boundingBox;

    PropertiesMap _instances;
};

typedef std::shared_ptr<Geometry> GeometryPtr;

#endif /* defined(B_GEOMETRY_H) */