matManager.h

#pragma once
#ifndef _meshManager_H_
 
#include<unordered_map>
#include<map>
#include"texManager.h"
#include"material.h"
 
namespace Aire
{
    using MatNameHash = std::unordered_map<std::string, MaterialPtr>;
    using MatHash = std::map<MatHandle, MaterialPtr>;
 
    class MaterialManager {
    private:
        MatHandle matHandle;
        MatHash matHash;
        MatNameHash matNameHash;
 
        TextureManager& texManager = TextureManager::get_instance();
 
        MaterialManager();
 
    public:
        //singleton pattern
        MaterialManager(const MaterialManager&) = delete;
        MaterialManager& operator=(const MaterialManager&) = delete;
        static MaterialManager& get_instance() {
            static MaterialManager instance;
            return instance;
        }
 
        ~MaterialManager();
 
        //NOTE: DO NOT call delete on returned pointer. The texture will be automatically deleted when the loader goes out of scope.
 
        MatHandle createMaterial();
 
        MatHandle createMaterial(std::string& diffusePath, std::string& specularPath, std::string& normalPath, std::string& heightPath, bool isflipped);
 
        MatHandle createMaterial(std::string Name);
 
        MaterialPtr getMaterialPtr(MatHandle&);
 
        MaterialPtr getMaterialPtrByName(std::string& name);
 
        void setMatererialInGPU(MaterialPtr&);
        
        void freeMaterialInGPU(MaterialPtr&);
 
        void freeMaterialInCPU(MaterialPtr&);
 
        //additional attribute maybe necesseary to add.
    };
 
    inline MaterialManager::MaterialManager()
    {
        matHandle = 0;
    }
    inline MaterialManager::~MaterialManager()
    {
        if (!matHash.empty())
        {
 
            matHash.erase(matHash.begin(), matHash.end());
        }
        if (!matNameHash.empty())
        {
            matNameHash.erase(matNameHash.begin(), matNameHash.end());
        }
    }
 
}
 
#endif // !_meshManager_H_