Properties.h

Go to the documentation of this file.

#ifndef B_PROPERTIES_H
#define B_PROPERTIES_H

#include <memory>
#include <map>
#include "vmmlib/matrix.hpp"

#include "Shader.h"

class Properties
{
public:
    /* Typedefs */
    // Since properties are likely to change every frame (transformation matrices) maps are used over unordered maps
    typedef std::map<std::string, vmml::Matrix4f>       Matrix4x4Map;
    typedef std::map<std::string, vmml::Matrix3f>       Matrix3x3Map;
    typedef std::map<std::string, vmml::Vector4f>       Vector4Map;
    typedef std::map<std::string, vmml::Vector3f>       Vector3Map;
    typedef std::map<std::string, GLfloat>              ScalarMap;

    /* Functions */

    virtual ~Properties() {}

    const Matrix4x4Map  &getMatrices4x4()                                               { return _matrices4x4; }

    vmml::Matrix4f          getMatrix4x4(const std::string &name)                           { return _matrices4x4[name]; }

    const Matrix3x3Map  &getMatrices3x3()                                               { return _matrices3x3; }

    vmml::Matrix3f          getMatrix3x3(const std::string &name)                           { return _matrices3x3[name]; }

    const Vector4Map    &getVectors4()                                                  { return _vectors4; }

    vmml::Vector4f          getVector4(const std::string &name)                             { return _vectors4[name]; }

    const Vector3Map    &getVectors3()                                                  { return _vectors3; }

    vmml::Vector3f          getVector3(const std::string &name)                             { return _vectors3[name]; }

    const ScalarMap     &getScalars()                                                   { return _scalars; }

    GLfloat             getScalar(const std::string &name)                              { return _scalars[name]; }

    void                setMatrices4x4(const Matrix4x4Map& arg)                         { _matrices4x4 = arg; }

    void                setMatrix(const std::string &name, const vmml::Matrix4f &arg)       { _matrices4x4[name] = arg; }

    void                setMatrices3x3(const Matrix3x3Map& arg)                         { _matrices3x3 = arg; }

    void                setMatrix(const std::string &name, const vmml::Matrix3f &arg)       { _matrices3x3[name] = arg; }

    void                setVectors4(const Vector4Map& arg)                              { _vectors4 = arg; }

    void                setVector(const std::string &name, const vmml::Vector4f &arg)       { _vectors4[name] = arg; }

    void                setVectors3(const Vector3Map& arg)                              { _vectors3 = arg; }

    void                setVector(const std::string &name, const vmml::Vector3f &arg)       { _vectors3[name] = arg; }

    void                setScalars(const ScalarMap &arg)                                    { _scalars = arg; }

    void                setScalar(const std::string &name, GLfloat arg)                 { _scalars[name] = arg; }

    const std::string &getName()                       { return _name; }

    void        setName(const std::string &arg) { _name = arg; }

    void                passToShader(ShaderPtr shader)              
    { 
        shader->setUniforms(_matrices4x4);
        shader->setUniforms(_matrices3x3);
        shader->setUniforms(_vectors4);
        shader->setUniforms(_vectors3);
        shader->setUniforms(_scalars);
    }

    void                clear()
    {
        _matrices4x4.clear();
        _matrices3x3.clear();
        _vectors4.clear();
        _vectors3.clear();
        _scalars.clear();
    }


private:

    /* Variables */
    Matrix4x4Map    _matrices4x4;
    Matrix3x3Map    _matrices3x3;
    Vector4Map      _vectors4;
    Vector3Map      _vectors3;
    ScalarMap       _scalars;

    std::string _name;
};

typedef std::shared_ptr< Properties > PropertiesPtr;

#endif /* defined(B_PROPERTIES_H) */