UnityMaterialToTextureMap.h

#pragma once

#include "MessageQueue.h"
#include "Graphics.h"
#include <vector>
#include <string>
#include <unordered_map>

namespace Eegeo
{
    namespace Unity
    {
        class UnityMaterialToTextureMap
        {
        private:

            struct MaterialTexturePairing
            {
                std::string materialName;
                GLuint textureID;
            };

        public:

            void SetTextureForMaterial(const std::string& materialName, GLuint textureID) // called from bg threads
            {
                m_messageQueue.Enqueue(MaterialTexturePairing{ materialName, textureID });
            }

            GLuint GetTextureForMaterial(const std::string& materialName) // called on main thread
            {
                GLuint result = 0;
                
                auto it = m_materials.find(materialName);

                if (it == m_materials.end())
                {
                    DrainQueue();
                    it = m_materials.find(materialName);
                }

                if (it != m_materials.end())
                {
                    result = it->second;
                }

                return result;
            }

            void ReleaseTexture(GLuint id) // ultimately called on main thread
            {
                auto it = m_reverseMaterialMapping.find(id);

                if (it == m_reverseMaterialMapping.end())
                {
                    DrainQueue();
                    it = m_reverseMaterialMapping.find(id);
                }

                if (it != m_reverseMaterialMapping.end())
                {
                    for (const auto& materialName : it->second)
                    {
                        m_materials.erase(materialName);
                    }

                    m_reverseMaterialMapping.erase(it);
                }
            }

        private:

            void DrainQueue()
            {
                MaterialTexturePairing pairing;

                while (m_messageQueue.TryDequeue(pairing))
                {
                    m_materials.insert({ pairing.materialName, pairing.textureID });
                    auto existingReverseEntry = m_reverseMaterialMapping.find(pairing.textureID);

                    if (existingReverseEntry != m_reverseMaterialMapping.end())
                    {
                        existingReverseEntry->second.push_back(pairing.materialName);
                    }
                    else
                    {
                        m_reverseMaterialMapping.insert({ pairing.textureID, { pairing.materialName } });
                    }
                }
            }

            Messaging::MessageQueue<MaterialTexturePairing> m_messageQueue;
            std::unordered_map<std::string, GLuint> m_materials;
            std::unordered_map<GLuint, std::vector<std::string>> m_reverseMaterialMapping;
        };
    }
}