UnityInteriorMaterial.h

#pragma once

#include "InteriorsMaterialBase.h"
#include "InteriorRenderable.h"
#include "UnityCallbacks.h"
#include <string>

namespace Eegeo
{
    namespace Unity
    {
        class UnityInteriorMaterial : public Resources::Interiors::InteriorsMaterialBase
        {
        public:

            UnityInteriorMaterial(
                const void* unityMaterialHandle,
                const IndoorMapCallbacks& indoorMapCallbacks,
                const Rendering::TMaterialId materialId,
                const std::string& name,
                const Lighting::GlobalLighting& lighting,
                Resources::Interiors::IInteriorsMaterialAssignmentObserver& materialAssignmentObserver,
                bool useAlternativeAmbient,
                bool isTranslucent,
                bool isStencilMirror,
                const v4& diffuseColor,
                Resources::Interiors::InteriorsRenderableLayer::Type renderableLayer,
                const Rendering::Shader& shader
                )
                : Resources::Interiors::InteriorsMaterialBase(
                    materialId, 
                    name, 
                    lighting, 
                    materialAssignmentObserver, 
                    useAlternativeAmbient, 
                    isTranslucent, 
                    diffuseColor, 
                    renderableLayer)
                , m_unityMaterialHandle(unityMaterialHandle)
                , m_shader(shader)
                , m_isStencilMirror(isStencilMirror)
                , m_indoorMapCallbacks(indoorMapCallbacks)
            {
            }

            ~UnityInteriorMaterial()
            {
                m_indoorMapCallbacks.DeleteMaterial(m_unityMaterialHandle);
            }

            const void* GetUnityMaterialHandle() const
            {
                return m_unityMaterialHandle;
            }

            const Rendering::Shader& GetShader() const override
            {
                return m_shader;
            }

            void OnAssignedToRenderable(Rendering::Renderables::InteriorRenderable& renderable) override
            {
                InteriorsMaterialBase::OnAssignedToRenderable(renderable);
                
                if (m_isStencilMirror)
                {
                    renderable.SetStencilMirrorType(Resources::Interiors::StencilMirror_Mirror);
                }
            }


            void SetStatePerRenderable(const Rendering::RenderableBase* renderableBase, Rendering::GLState& glState) const override
            {
                
            }

        private:

            const void* m_unityMaterialHandle;
            const Rendering::Shader& m_shader;
            const bool m_isStencilMirror;
            const IndoorMapCallbacks& m_indoorMapCallbacks;
        };
    }
}