Geometry.h

#pragma once
#include "MyShader.hpp"
#include "ShaderObj.h"
#include "Texture.h"
#include "Material.h"

#include <glm\glm.hpp>
#include <map>
#include <vector>

class Geometry
{
public:
        enum GeometryType{
                GT_VertexGeometry,
                GT_ParticleGeometry
        };

        enum TextureType
        {
                TT_Diffuse,
                TT_Ambient,
                TT_Bumpmap,
                TT_Normalmap,
                TT_Emissive
        };

        enum RenderType
        {
                RT_TRIANGLE,
                RT_POINT
        };

public:
        Geometry(void);
        Geometry(unsigned int type);
        virtual ~Geometry(void);

public:
        glm::mat4 World;
        glm::mat4 Local;
        
public:
        float start_time;
        std::map<unsigned int, Texture::TexturePtr> m_TextureObjs;
        Material* m_MatrialObjs;

        void SetShader(unsigned int id, MyShader* shader);
        MyShader* GetShader(unsigned int id);

        void CreateDictShaderToVBO(unsigned int id, std::map<std::string, int> dict);
        void SetDictShaderToVBO(unsigned int id, std::map<int, int> dict);

        void CreateDictShaderUniforms(unsigned int id, std::map<std::string, int> dict);
        
        void SetDictShaderUniforms(unsigned int id, std::map<int, int> dict);

        void CreateDictShaderSpecificUniforms(unsigned int id);

        std::map<int, int> GetDictShaderToVBO(unsigned int id);
        std::map<int, int> GetDictShaderUniform(unsigned int id);

        /*Die Idee davon ist ziemlich easy. Man muss die VBOs (oder auch VAOs) 
         mit dem Befehl 
                glEnableVertexAttribArray(...) 
         den richtigen Attrib Variable zuweisen (also die in Variablen im MyShader). Diese kriegt man über die Funktion 
                get_attrib_location(...).
         Dieses Map speichert nun einfach für jede Attrib-Location den dazugehörigen VBO
         
         Also es wird gespeichert das Ergebnis von get_attrib_location(...) und von VertexGeometry ein Eintrag von dem ArrayTabe enum,
         also <0, VertexGeometry::AT_POSITION>
         */
        std::vector<std::map<int, int>> m_dict_shader_vbo;      

        /*Die gleiche Idee wie bei dem m_dict_shader_vbo Dictionary.
        Nur jetzt mit dem Uniform Variablen. 
        */
        std::vector<std::map<int, int>> m_dict_shader_uniform;

        std::vector<std::vector<ShaderObj*>> m_shader_uniforms;

public:
        glm::mat4 m_modelMatrix;
        std::vector<glm::mat4> m_oldModelMatrix;        

        unsigned int m_type;
        bool useNormals;
        bool useTextures;


public:
        bool renderTo3DTexture;
        int actDepth;

        unsigned int m_bones_count;
        glm::mat4* bones;
        glm::mat4* oldBones;
        glm::mat4* act_bones;


        glm::mat4* bones_helper;

        unsigned int m_rendertype;

        std::vector<MyShader*> m_shader;
};