meshManager.h

#pragma once
#ifndef _meshManager_H_
 
 
#include"matManager.h"
#include <assimp/scene.h>
#include"model.h"
#include"mathHelper.h"
#include "../utils/error.h"
#include "../utils/log.h"
 
namespace Aire
{
    using MeshPtr = shared_ptr<Mesh>;
 
    using MeshHash = map<MeshHandle, MeshPtr>;
 
    using ModelHash = map<ModelHandle, ModelPtr>;
    using ModelNameHash = std::unordered_map<ModelHandle, ModelPtr>;
 
    //the list of one hash
    using MeshSoupHandle = unsigned int;
 
    using MeshSoupHash = map<MeshSoupHandle, ModelData>;
    using MeshSoupNameHash = std::unordered_map<std::string, ModelData>;
 
    class MeshManager {
    private:
        MeshHash meshHash;
        MeshHandle meshHandle;
 
        ModelHash modelHash;
        ModelHandle modelHandle;
        ModelNameHash modelNameHash;
 
 
        MeshSoupHash meshSoupHash;
        MeshSoupNameHash meshSoupNameHash;
        MeshSoupHandle meshSoupHandle;
 
        MaterialManager& matManager = MaterialManager::get_instance();
        MeshManager();
        std::string dir;
 
        void processNode(aiNode* node, const aiScene* scene, std::vector<MeshPtr>&,BoneInfoMap& map, int& count, bool isflipped);
        MeshPtr processMesh(aiMesh* mesh, const aiScene* scene, BoneInfoMap& map, int& count, bool isflipped);
        MaterialPtr processMaterial(aiMaterial* material,bool isflipped);
        std::string getPath(aiMaterial* mat, aiTextureType type);
        
 
    public:
        //singleton pattern
        MeshManager(const MeshManager&) = delete;
        MaterialManager& operator=(const MeshManager&) = delete;
        static MeshManager& get_instance() {
            static MeshManager instance;
            return instance;
        }
 
        ~MeshManager();
 
        //NOTE: DO NOT call delete on returned pointer. The texture will be automatically deleted when the loader goes out of scope.
 
        MeshHandle createMesh(std::vector<Vertex> vertices, std::vector<unsigned int> indices, MaterialPtr& handle);
 
        ModelHandle createModel(const std::string& path, bool flippedUV = false);
 
        void freeModelDataInCpu(const ModelHandle& handle);
 
        void moveModelToGpu(const ModelHandle& );
 
        void moveModelToGpu(const std::string&);
 
        void moveMeshToGpu(const MeshHandle&);
        //additional attribute maybe necesseary to add.
 
        void RemoveMeshInGpu(const MeshHandle&);
 
        void RemoveMoelInGpu(const ModelHandle&);
 
        MeshPtr getMeshPtr(const MeshHandle& );
 
        ModelPtr getModelPtr(const ModelHandle&);
 
        void SetVertexBoneDataToDefault(Vertex& vertex);
 
        void SetVertexBoneData(Vertex& vertex, int boneID, float weight);
 
        void ExtractBoneWeightForVertices(std::vector<Vertex>& vertices, aiMesh* mesh, const aiScene* scene, BoneInfoMap& map, int& count);
 
    };
 
 
 
    inline MeshManager::MeshManager()
    {
        meshHandle = 0;
        modelHandle = 0;
 
    }
 
}
 
#endif // !_meshManager_H_