Model.h

Go to the documentation of this file.

#ifndef B_MODEL_H
#define B_MODEL_H

#include <memory>
#include <string>
#include <unordered_map>

#include "IDrawable.h"
#include "Geometry.h"
#include "Material.h"
#include "Renderer_GL.h"

class ObjectManager;
class ModelData;

class Model : public IDrawable
{
public:
    /* Typedefs */
    typedef std::unordered_map< std::string, GeometryPtr > GroupMap;
    typedef  std::shared_ptr< std::unordered_map< ShaderPtr, PropertiesPtr > >  InstanceMapPtr;
    typedef std::unordered_map< std::string, InstanceMapPtr >   InstancesMap;

    /* Functions */

    Model() {}

    Model(ObjectManager *o, const ModelData &modelData, GLuint shaderMaxLights, bool variableNumberOfLights, bool shaderFromFile, bool ambientLighting, PropertiesPtr properties = nullptr);

    Model(ObjectManager *o, const ModelData &modelData, ShaderPtr shader, PropertiesPtr properties = nullptr);

    Model(const ModelData &modelData, MaterialPtr material, PropertiesPtr   properties = nullptr);

    virtual ~Model() { deleteModelGeometry(); }
    
    virtual void draw(GLenum mode = GL_TRIANGLES) override;

    virtual void draw(const std::string &geometryName, GLenum mode = GL_TRIANGLES);

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

    virtual InstanceMapPtr  addInstance(const std::string &instanceName);

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

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

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

    virtual void            clearInstances();
    
    MaterialPtr getMaterial()   { return _material; }
    
    void setMaterial(MaterialPtr arg)
    {
        _material = arg;
        
        for (auto i = _groups.begin(); i != _groups.end(); ++i)
        {
            i->second->setMaterial(_material);
        }
    }

    PropertiesPtr getProperties()   { return _properties; }

    void setProperties(PropertiesPtr arg)
    {
        _properties = arg;

        for (auto i = _groups.begin(); i != _groups.end(); ++i)
        {
            i->second->setProperties(_properties);
        }
    }
    
    GroupMap &getGroups()   { return _groups; }

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

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

    virtual void            addGeometry(const std::string &name, GeometryPtr geometry);

    virtual void            removeGeometry(const std::string &name)                             { _groups.erase(name); }

    virtual void deleteModelGeometry()
    {
        for (auto i = _groups.begin(); i != _groups.end(); ++i)
        {
            i->second->deleteGeometry();
        }
        _groups.clear();
    }

private:

    /* Variables */

    GroupMap        _groups;
    MaterialPtr     _material = nullptr;
    PropertiesPtr   _properties = nullptr;
    vmml::AABBf     _boundingBox;
    InstancesMap    _instances;
};

typedef std::shared_ptr<Model> ModelPtr;

#endif /* defined(B_MODEL_H) */