WaterMaterial2.h

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

#pragma once

#include "Types.h"
#include "IMaterial.h"
#include "IdTypes.h"
#include "Lighting.h"
#include "Rendering.h"
#include "WaterShader.h"
#include "TextureMinifyType.h"
#include "VectorMath.h"
#include <string>

namespace Eegeo
{
    namespace Rendering
    {
        namespace Materials
        {
            class WaterMaterial2 : protected Eegeo::NonCopyable, public IMaterial
            {
            public:
                WaterMaterial2(
                                      const TMaterialId materialId,
                                      const std::string& name,
                                      Shaders::WaterShader& shader,
                                      const Lighting::GlobalLighting& lighting,
                                      const Lighting::GlobalFogging& fogging,
                                        AsyncTexturing::IAsyncTexture& diffuseTextureId,
                                        AsyncTexturing::IAsyncTexture& normalMapTextureId,
                                        AsyncTexturing::IAsyncTexture& reflectionTextureId,
                                      Rendering::TextureMinifyType textureMinifyType,
                                      bool useAlternativeAmbient,
                                      bool textureRepeat,
                                      Eegeo::v2 animationScaleUV,
                                      Eegeo::v2 animationWrapUV,
                                      float envMapFadeoutAltitude
                               );
                
                bool IsUsingAlternativeAmbient() const { return m_useAlternativeAmbient; }
                void UseAlternativeAmbient(bool useAlternativeAmbient) { m_useAlternativeAmbient = useAlternativeAmbient; }
                
                const TMaterialId GetId() const { return m_id; }
                const Shader& GetShader() const { return m_shader; }
                const std::string& GetName() const { return m_name; }
                
                void SetDiffuseTexture(AsyncTexturing::IAsyncTexture& textureId) { m_diffuseTextureId = &textureId; }
                AsyncTexturing::IAsyncTexture& GetDiffuseTextureId() const { return *m_diffuseTextureId; }

                void SetNormalMapTexture(AsyncTexturing::IAsyncTexture& textureId) { m_normalMapTextureId = &textureId; }
                AsyncTexturing::IAsyncTexture& GetNormalMapTextureId() const { return *m_normalMapTextureId; }

                void SetReflectionTexture(AsyncTexturing::IAsyncTexture* textureId) { m_reflectionMapTextureId = textureId; }
                AsyncTexturing::IAsyncTexture* GetReflectionTextureId() const { return m_reflectionMapTextureId; }
                
                void UpdateMaterial(float deltaTime, const dv3& ecefCameraPosition);
                
                void SetState(Rendering::GLState& glState) const;
                
                void SetStatePerRenderable(const Rendering::RenderableBase* renderableBase, Rendering::GLState& glState) const;

                static m44 CalculateViewToCubeMapMatrix(const Renderables::WaterRenderable& waterRenderable);
                
            protected:
                const TMaterialId m_id;
                const std::string m_name;
                Shaders::WaterShader& m_shader;
                const Lighting::GlobalLighting& m_lighting;
                const Lighting::GlobalFogging& m_fogging;
                Rendering::AsyncTexturing::IAsyncTexture* m_diffuseTextureId;
                Rendering::AsyncTexturing::IAsyncTexture* m_normalMapTextureId;
                Rendering::AsyncTexturing::IAsyncTexture* m_reflectionMapTextureId;
                Rendering::AsyncTexturing::IAsyncTexture* m_defaultReflectionCubeMapTextureId;
                Rendering::TextureMinifyType m_textureMinifyType;
                bool m_textureRepeat;
                bool m_useAlternativeAmbient;
                float m_altitudeScale;
                Eegeo::v2 m_animationScaleUV;
                Eegeo::v2 m_animationWrapUV;
                Eegeo::v4 m_animationStateUV;
                const float m_envMapFadeoutAltitude;
            };
        }
    }
}