SkyMesh.h

#pragma once
#include "TileObject.h"

namespace ParaEngine
{
    struct AssetEntity;
    class CMeshObject;
    class CSkyMesh : public CTileObject
    {

    public:
        CSkyMesh(void);
        virtual ~CSkyMesh(void);
        virtual CBaseObject::_SceneObjectType GetType(){ return CBaseObject::SkyMesh; };

        enum SkyType
        {
            Sky_StaticMesh,
            Sky_Simulated
        };

    public:
        virtual int GetAttributeClassID(){ return ATTRIBUTE_CLASSID_CSkyMesh; }
        virtual const char* GetAttributeClassName(){ static const char name[] = "CSkyMesh"; return name; }
        virtual const char* GetAttributeClassDescription(){ static const char desc[] = ""; return desc; }
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        ATTRIBUTE_SUPPORT_CREATE_FACTORY(CSkyMesh);
        ATTRIBUTE_METHOD1(CSkyMesh, GetSkyColorFactor_s, Vector3*)      { (*p1).x = cls->GetSkyColorFactor().r; (*p1).y = cls->GetSkyColorFactor().g; (*p1).z = cls->GetSkyColorFactor().b; return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetSkyColorFactor_s, Vector3)       { LinearColor c(p1.x, p1.y, p1.z, 1); cls->SetSkyColorFactor(c); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, GetSkyMeshFile_s, const char**) { *p1 = cls->GetSkyMeshFile(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetSkyMeshFile_s, const char*)  { cls->SetSkyMeshFile(p1); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, GetSkyMeshTexture_s, const char**)  { *p1 = cls->GetSkyMeshTexture(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetSkyMeshTexture_s, const char*)   { cls->SetSkyMeshTexture(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CSkyMesh, GetFogBlendAngleFrom_s, float*) { *p1 = cls->GetFogBlendAngleFrom(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetFogBlendAngleFrom_s, float)  { cls->SetFogBlendAngleFrom(p1); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, GetFogBlendAngleTo_s, float*)   { *p1 = cls->GetFogBlendAngleTo(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetFogBlendAngleTo_s, float)    { cls->SetFogBlendAngleTo(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CSkyMesh, IsSimulatedSkyEnabled_s, bool*) { *p1 = cls->IsSimulatedSkyEnabled(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, EnableSimulatedSky_s, bool) { cls->EnableSimulatedSky(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CSkyMesh, GetIsAutoDayTime_s, bool*)  { *p1 = cls->GetIsAutoDayTime(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetIsAutoDayTime_s, bool)   { cls->SetIsAutoDayTime(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CSkyMesh, GetSunGlowTexture_s, const char**)  { *p1 = cls->GetSunGlowTexture(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetSunGlowTexture_s, const char*)   { cls->SetSunGlowTexture(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CSkyMesh, GetCloudTexture_s, const char**)    { *p1 = cls->GetCloudTexture(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetCloudTexture_s, const char*) { cls->SetCloudTexture(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CSkyMesh, GetSunColor_s, Vector3*)        { (*p1) = cls->GetSunColor(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetSunColor_s, Vector3)     { cls->SetSunColor(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CSkyMesh, GetLightSkyColor_s, Vector3*)       { (*p1) = cls->GetLightSkyColor(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetLightSkyColor_s, Vector3)        { cls->SetLightSkyColor(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CSkyMesh, GetDarkSkyColor_s, Vector3*)        { (*p1) = cls->GetDarkSkyColor(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetDarkSkyColor_s, Vector3)     { cls->SetDarkSkyColor(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CSkyMesh, GetSunIntensity_s, Vector2*)        { (*p1) = cls->GetSunIntensity(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetSunIntensity_s, Vector2)     { cls->SetSunIntensity(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CSkyMesh, GetCloudColor_s, Vector3*)      { (*p1) = cls->GetCloudColor(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetCloudColor_s, Vector3)       { cls->SetCloudColor(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CSkyMesh, GetCloudVelocity_s, Vector2*)       { (*p1) = cls->GetCloudVelocity(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetCloudVelocity_s, Vector2)        { cls->SetCloudVelocity(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CSkyMesh, GetCloudOffset_s, Vector2*)     { (*p1) = cls->GetCloudOffset(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetCloudOffset_s, Vector2)      { cls->SetCloudOffset(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CSkyMesh, GetCloudThickness_s, float*)    { *p1 = cls->GetCloudThickness(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetCloudThickness_s, float) { cls->SetCloudThickness(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CSkyMesh, GetSunSize_s, Vector2*)     { (*p1) = cls->GetSunSize(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetSunSize_s, Vector2)      { cls->SetSunSize(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CSkyMesh, GetMoonSize_s, Vector2*)        { (*p1) = cls->GetMoonSize(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetMoonSize_s, Vector2)     { cls->SetMoonSize(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CSkyMesh, GetFogColor_s, Vector3*)        { (*p1) = cls->GetFogColor(); return S_OK; }
        ATTRIBUTE_METHOD1(CSkyMesh, SetFogColor_s, Vector3)     { cls->SetFogColor(p1); return S_OK; }

        void SetSkyMeshFile(const char* filename);
        const char* GetSkyMeshFile();

        void SetSkyMeshTexture(const char* filename, int nTexIndex = 2);
        const char* GetSkyMeshTexture(int nTexIndex = 2);

        const LinearColor& GetSkyColorFactor(){ return m_skycolorFactor; };
        void SetSkyColorFactor(const LinearColor& color){ m_skycolorFactor = color; };

        virtual HRESULT Draw(SceneState * sceneState);

        void DrawSimulatedSky(EffectManager* pEffectManager, SceneState * sceneState, CSunLight &sunlight, RenderDevicePtr pd3dDevice, Vector3 &vPos);

        void DrawStaticMeshSky(EffectManager* pEffectManager, SceneState * sceneState, RenderDevicePtr pd3dDevice, CSunLight &sunlight, Vector3 vPos);

        void DrawStaticMeshSkyInner(SceneState * sceneState);

        virtual HRESULT RendererRecreated();
        // -- set current sky mode and parameters
        void CreateSkyVertexColorSimple();
        void CreateSkyStaticMesh(const string& strObjectName, AssetEntity& MeshAsset, FLOAT fScaleX, FLOAT fScaleY, FLOAT fScaleZ, FLOAT fHeightOffset = 0);

        virtual DVector3 GetPosition(){ return m_vPos; };
        virtual void SetPosition(const DVector3 & v){ m_vPos = v; };

        void SetFogBlendAngleFrom(float fValue){ m_fFogBlendAngleFrom = fValue; };
        float GetFogBlendAngleFrom(){ return m_fFogBlendAngleFrom; };

        void SetFogBlendAngleTo(float fValue){ m_fFogBlendAngleTo = fValue; };
        float GetFogBlendAngleTo(){ return m_fFogBlendAngleTo; };

        void EnableSimulatedSky(bool bEnable);
        bool IsSimulatedSkyEnabled(){ return (m_typeSky == Sky_Simulated); };

        virtual HRESULT InitDeviceObjects();
        virtual HRESULT DeleteDeviceObjects();

    private:
        SkyType m_typeSky;

        DVector3           m_vPos;

        // pointer to the static mesh
        ref_ptr<CMeshObject> m_pStaticMesh;

        static float    m_fFogBlendAngleFrom;
        static float    m_fFogBlendAngleTo;
        LinearColor m_skycolorFactor;

        void SetSkyMesh(AssetEntity& MeshAsset, float fHeightOffset = 0);

        //
        // for simulated sky
        //
        bool m_bSimsky_BufferInited;

        bool m_bSimsky_AutoDayTime;
        bool GetIsAutoDayTime() { return m_bSimsky_AutoDayTime; }
        void SetIsAutoDayTime(bool bValue) { m_bSimsky_AutoDayTime = bValue; }
        ParaVertexBuffer m_simsky_vb;
        ParaIndexBuffer m_simsky_ib;

        int m_nSimsky_vertexCount;
        int m_nSimsky_indexCount;
        int m_nSimsky_primitiveCount;
        float m_fSimsky_verticalRadius;
        float m_fSimsky_horizonRadius;
        int m_nSimsky_verticalSampleCount;
        int m_nSimsky_horizonSampleCount;
        Vector3 m_vSimsky_sunDirection;
        Vector3 m_vSimsky_sunPosition;

        Vector3 m_vSimsky_position;

        asset_ptr<TextureEntity> m_texSimsky_sunsetGlowTexture;
        const char* GetSunGlowTexture();
        void SetSunGlowTexture(const char* sValue);

        asset_ptr<TextureEntity> m_texSimsky_cloudTexture;
        const char* GetCloudTexture();
        void SetCloudTexture(const char* sValue);

        Vector3 m_vSimsky_sunColor;
        Vector3 GetSunColor() { return m_vSimsky_sunColor; }
        void SetSunColor(const Vector3 & vValue) { m_vSimsky_sunColor = vValue; }

        Vector3 m_vSimsky_lightSkyColor;

        Vector3 GetLightSkyColor() { return m_vSimsky_lightSkyColor; }
        void SetLightSkyColor(const Vector3 & vValue) { m_vSimsky_lightSkyColor = vValue; }

        Vector3 m_vSimsky_darkSkyColor;
        Vector3 GetDarkSkyColor() { return m_vSimsky_darkSkyColor; }
        void SetDarkSkyColor(const Vector3 & vValue) { m_vSimsky_darkSkyColor = vValue; }

        Vector2 m_vSimsky_sunIntensity;
        Vector2 GetSunIntensity() { return m_vSimsky_sunIntensity; }
        void SetSunIntensity(const Vector2 & vValue) { m_vSimsky_sunIntensity = vValue; }

        Vector3 m_vSimsky_cloudColor;
        Vector3 GetCloudColor() { return m_vSimsky_cloudColor; }
        void SetCloudColor(const Vector3 & vValue) { m_vSimsky_cloudColor = vValue; }

        Vector2 m_vSimsky_cloudDirection;
        Vector2 GetCloudDirection() { return m_vSimsky_cloudDirection; }
        void SetCloudDirection(const Vector2 & vValue) { m_vSimsky_cloudDirection = vValue; }

        Vector2 m_vSimsky_cloudVelocity;
        Vector2 GetCloudVelocity() { return m_vSimsky_cloudVelocity; }
        void SetCloudVelocity(const Vector2 & vValue) { m_vSimsky_cloudVelocity = vValue; }

        Vector2 m_vSimsky_cloudOffset;
        Vector2 GetCloudOffset() { return m_vSimsky_cloudOffset; }
        void SetCloudOffset(const Vector2 & vValue) { m_vSimsky_cloudOffset = vValue; }

        Vector2 m_vSimsky_sunSize;
        Vector2 GetSunSize() { return m_vSimsky_sunSize; }

        void SetSunSize(const Vector2 & vValue) { m_vSimsky_sunSize = vValue; }

        Vector3 m_vSimsky_fogColor;
        Vector3 GetFogColor() const { return m_vSimsky_fogColor; }
        void SetFogColor(Vector3 val) { m_vSimsky_fogColor = val; }

        Vector2 m_vSimsky_moonSize;
        Vector2 GetMoonSize() const { return m_vSimsky_moonSize; }
        void SetMoonSize(Vector2 val) { m_vSimsky_moonSize = val; }

        float m_fSimsky_cloudThickness;
        float GetCloudThickness() const { return m_fSimsky_cloudThickness; }
        void SetCloudThickness(float val) { m_fSimsky_cloudThickness = val; }

        void UpdateSimSky(float fTime);
        bool m_bSimsky_isDaytime;

        void CreateSkySimulated(int verticalSampleCount, int horizonSampleCount, float verticalRadius, float horizonRadius);
    };
}