Model.h

Go to the documentation of this file.

#ifndef SKR_FPS2_RENDERER_OPENGL_MODEL_H
#define SKR_FPS2_RENDERER_OPENGL_MODEL_H
 
#include "..\..\pch.h"
 
#include <vector>
 
#include "Texture.h"
#include "Mesh.h"
#include "Shader.h"
#include "..\..\Collision\BoundingBox.h"
 
namespace skr
{
namespace fps2
{
namespace Renderer
{
namespace OpenGL
{
    class Model
    {
        public:
            std::vector<Texture> _texturesLoaded;   
            std::vector<Mesh> _meshes;              
            glm::vec3 _scale;                       
            std::string _path;                      
            ShaderType _shadertype;                 
            bool _useMaterialTextures;              
            Collision::BoundingBox _boundingBox;    
            float _yOffset;                         
 
        private:
            std::string _directory;                 
            bool _gammaCorrection;                  
    
        public:
            Model();
 
            // \brief rvalue copy constructor
            Model(Model&& other) noexcept;
 
            Model(std::string const &path, glm::vec3 scale = glm::vec3(1.0f, 1.0f, 1.0f), float yoffset = 0.0f, ShaderType shadertype = ShaderType::Main, bool gamma = false);
 
            Model(std::vector<skr::pcg::Face> faces, glm::vec3 scale = glm::vec3(1.0f, 1.0f, 1.0f), float yoffset = 0.0f, ShaderType shadertype = ShaderType::Main, bool gamma = false);
 
            void Draw(Shader shader, uint32_t depthMap = 0) const;
 
            // \brief draw only geomtry without textures
            void DrawGeometry() const;
 
            void DrawBoundingBox(Shader shader, glm::mat4 view, glm::mat4 proj, glm::mat4 model, glm::vec3 color = glm::vec3(0.0f, 0.0f, 1.0f)) const;
 
            void SetScale(glm::vec3 s)
            {
                _scale = s;
            }
            
            void SetYOffset(float yoffset)
            {
                _yOffset = yoffset;
            }
    
        private:
            void LoadModel(std::string const &path);
 
            void ProcessNode(aiNode* node, const aiScene* scene);
 
            Mesh ProcessMesh(aiMesh* mesh, const aiScene* scene);
 
            void CalculateBoundingBox();
    };
 
}
}
}
}
 
#endif