mesh.hpp

Go to the documentation of this file.

 
#ifndef __MESH_H__
#define __MESH_H__ 1
 
#pragma once
#include <vector>
#include <string>
#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>
#include <GL/glew.h>
#include <glm/glm.hpp> 
#include <raftel/material.hpp>
#include <raftel/shader.hpp>
#include <raftel/global_macros.hpp>
 
#include <raftel/engine.hpp>
 
namespace Raftel {
    struct Vertex {
        glm::vec3 position;
        glm::vec3 normal;
        glm::vec2 texCoord;

        Vertex() = default;

        Vertex(const glm::vec3& position, const glm::vec3& normal, const glm::vec2& texCoord)
            : position(position), normal(normal), texCoord(texCoord) {
        }
 
        bool operator==(const Vertex& other) const {
            return position == other.position && normal == other.normal && texCoord == other.texCoord;
        }
    };
    
    class Mesh {
    public:

        Mesh() = default;

        ~Mesh();

        MOVABLE_BUT_NOT_COPYABLE(Mesh)
 
        
        static std::shared_ptr<Mesh> Create(const std::string& filePath, bool multithread);

        Mesh(const std::string& filePath);

        Mesh(std::vector<std::vector<Vertex>> verticesPerSubmesh,
            std::vector<std::vector<unsigned int>> indicesPerSubmesh,
            std::vector<std::shared_ptr<Material>> mats); 

        Mesh(std::vector<std::vector<Vertex>> verticesPerSubmesh,
            std::vector<std::vector<unsigned int>> indicesPerSubmesh); 

        bool loadMesh(const std::string& filePath);

        void setMaterials(const std::vector<std::shared_ptr<Material>>& newMaterials) {
            materials = newMaterials;
        }

        void setMaterial(const std::shared_ptr<Material>& mat) {
            materials.clear();
            materials.push_back(mat);
        }

        void addMaterial(const std::shared_ptr<Material>& mat) {
            materials.push_back(mat);
        }

        void setupMesh();

        void draw(ShaderProgram& shader);

        void setUniforms(GLuint shaderProgramID);

        void renderMaterial(ShaderProgram& shader);

        std::string getName() { return nameMesh; }

        void setName(std::string n_) {  nameMesh = n_; }

        const std::string& getLastError() const { return lastError; }

        std::shared_ptr<Material> GetMaterialByIndex(int index);

        std::vector<std::shared_ptr<Material>>& GetAllMaterials() { return materials; }

        std::vector<GLuint> GetVAOs() { return VAOs; }

        std::vector<std::vector<unsigned int>> GetSubMeshIndex() { return submeshIndices; }
 
    private:

        bool loadFromFile(const std::string& filePath);

        bool loadFromAssimp(const std::string& filePath);

        void processNode(aiNode* node, const aiScene* scene);

        void processAssimpMesh(aiMesh* mesh, const aiScene* scene);
 
        /*@brief Sets an error message.
        * @param errorMessage The error message.
        * @param file The source file where the error occurred.
        * @param line The line number where the error occurred.
        */
        void setError(const std::string& errorMessage, const char* file, int line);
 
        std::vector<std::shared_ptr<Material>> materials; 
        
        std::shared_ptr<Raftel::Material> convertAssimpMaterial(aiMaterial* material);
 
        std::vector<GLuint> VBOs;  
        std::vector<GLuint> EBOs; 
        std::vector<GLuint> VAOs; 
        std::vector<std::vector<unsigned int>> submeshIndices;  
        std::vector<std::vector<Vertex>> submeshVertex;  
        //TODO: quitar shared_ptr -> simplemente vector de materiales
        std::string nameMesh; 
 
        std::string lastError; 
    };

    class MeshFactory
    {
    public:

        static std::shared_ptr<Mesh> createPlane(float width, float height);

        static std::shared_ptr<Mesh> createCube(float size);

        static std::shared_ptr<Mesh> createSphere(float radius, int segments);

        static std::shared_ptr<Mesh> createTerrain(const char* heightMapFile,
                                                    float size,
                                                    float heightMultiplier,
                                                    bool isCentered);

        static std::shared_ptr<Raftel::Mesh> createCone(float radius, float height, int segments);
 
        
    };
 
} // namespace Raftel
#endif // __MESH_HPP__