InteriorsCubeMappedAnimatedUVMaterial.h

// Copyright eeGeo Ltd (2012-2014), All Rights Reserved

#pragma once

#include "Interiors.h"
#include "InteriorsMaterialBase.h"
#include "TextureMinifyType.h"
#include "IdTypes.h"
#include "Rendering.h"
#include "Lighting.h"
#include "VectorMath.h"
#include "ITimeProvider.h"

#include <string>

namespace Eegeo
{
    namespace Resources
    {
        namespace Interiors
        {
            
            class InteriorsCubeMappedAnimatedUVMaterial : public InteriorsMaterialBase
            {
            public:
                InteriorsCubeMappedAnimatedUVMaterial(const Rendering::TMaterialId materialId,
                                                      const std::string& name,
                                                      const Lighting::GlobalLighting& lighting,
                                                      IInteriorsMaterialAssignmentObserver& materialAssignmentObserver,
                                                      bool useAlternativeAmbient,
                                                      bool isTranslucent,
                                                      const v4& diffuseColor,
                                                      InteriorsRenderableLayer::Type renderableLayer,
                                                      const InteriorsCubeMappedAnimatedUVShader& shader,
                                                      IInteriorsTextureResource& diffuseTexture,
                                                      Rendering::TextureMinifyType textureMinifyType,
                                                      bool textureRepeat,
                                                      const v3& reflectionColor,
                                                      IInteriorsTextureResource& cubeMapTexture,
                                                      float viewOffsetScale,
                                                      Eegeo::v2 animationScaleUV,
                                                      const Helpers::ITimeProvider& timeProvider);
                
                
                
                ~InteriorsCubeMappedAnimatedUVMaterial();
                
                const Eegeo::Rendering:: Shader& GetShader() const;
                
                void OnAssignedToRenderable(Rendering::Renderables::InteriorRenderable& renderable);
                
                void SetState(Eegeo::Rendering::GLState& glState) const;
                
                void SetStatePerRenderable(const Eegeo::Rendering::RenderableBase* renderableBase, Eegeo::Rendering::GLState& glState) const;

            private:
                const InteriorsCubeMappedAnimatedUVShader& m_shader;
                IInteriorsTextureResource& m_diffuseTexture;
                const Rendering::TextureMinifyType m_textureMinifyType;
                const bool m_textureRepeat;
                const v3 m_reflectionColor;
                IInteriorsTextureResource& m_cubeMapTexture;
                const float m_viewOffsetScale;
                Eegeo::v2 m_animationScaleUV;

                const Helpers::ITimeProvider& m_timeProvider;

            };
        }
    }
}