SceneState.h

#pragma once

#include "util/unordered_array.hpp"
#include "SortedFaceGroups.h"
#include "util/ParaMemPool.h"
#include "IRefObject.h"
#include "ParaXModel/ParticleSystemRef.h"
#include "BillBoardViewInfo.h"
#include "BaseObject.h"

using namespace std;

namespace ParaEngine
{
    class CBaseObject;
    class IBatchedElementDraw;
    class CParaWorldAsset;
    class CContainerObject;
    class CSpriteObject;
    class CBipedObject;
    struct GUIState;
    class ParticleSystem;
    class CEffectFile;
    class CSortedFaceGroups;
    class IScene;
    class CLightObject;

    struct SceneState;

    enum RENDER_GROUP{
        RENDER_SKY_BOX = 1,
        RENDER_GLOBAL_TERRAIN = 0x1 << 1,
        RENDER_MESH_FRONT_TO_BACK = 0x1 << 2,
        RENDER_MESH_BACK_TO_FRONT = 0x1 << 3,
        RENDER_MESH_TRANSPARENT = 0x1 << 4,
        RENDER_CHARACTERS = 0x1 << 5,
        RENDER_PLAYER = 0x1 << 6,
        RENDER_SPRITES = 0x1 << 7,
        RENDER_MISSILES = 0x1 << 8,
        RENDER_PARTICLES = 0x1 << 9,
        RENDER_BOUNDINGBOX = 0x1 << 10,
        RENDER_GEN_SM_TERRAIN = 0x1 << 11, // generate shadow map for global terrain object.
        RENDER_TRANSLUCENT_FACE_GROUPS = 0x1 << 12,
        RENDER_PORTAL_SYSTEM = 0x1 << 13,
        RENDER_SELECTION = 0x1 << 14,
        RENDER_SHADOWMAP = 0x1 << 15,
        RENDER_TRANSPARENT_CHARACTERS = 0x1 << 16,
        RENDER_OWNER_DRAW = 0x1 << 17,
        RENDER_POST_RENDER_LIST = 0x1 << 18,
    };

#define CHECK_SELECTION(x) ((dwSelection&(x))>0)

    enum RENDER_PIPELINE_ORDER{
        PIPELINE_ORDER_PRE_SCENE = 0,
        PIPELINE_3D_SCENE = 1,
        // TODO: add more here. 
        PIPELINE_UI = 50,
        PIPELINE_POST_UI_3D_SCENE = 51,
        PIPELINE_COLOR_PICKING = 100,
    };

    struct PostRenderObjectWeakPtr
    {
    public:
        float m_fObjectToCameraDistance;
        // this will lead to crash if used cross frame. 
        CBaseObject::WeakPtr_type m_pRenderObject;
        int m_nOccluded;
    public:
        PostRenderObjectWeakPtr(CBaseObject* pRenderObject, float fObjectToCameraDistance, int nOccluded = 0)
            :m_pRenderObject(pRenderObject), m_fObjectToCameraDistance(fObjectToCameraDistance), m_nOccluded(nOccluded) {};

        bool IsOccluded() const { return m_nOccluded > 1; }
    };

    struct PostRenderObject
    {
    public:
        float m_fObjectToCameraDistance;
        // this will lead to crash if used cross frame. 
        CBaseObject* m_pRenderObject;
        int m_nOccluded;
    public:
        //PostRenderObject(CBaseObject* pRenderObject);
        PostRenderObject(CBaseObject* pRenderObject, float fObjectToCameraDistance, int nOccluded = 0);

        //PostRenderObject& operator = (const PostRenderObject& _right);

        bool IsOccluded() const { return m_nOccluded > 1; }
    };

    struct AlphaPostRenderObject : PostRenderObject
    {
    public:
        // the alpha value: 0-1.0f
        float m_fAlpha;
        enum ALPHA_ANIM{
            ALPHA_INCREASE_ANIM,    
            ALPHA_DECREASE_ANIM,        
            ALPHA_NO_ANIM,          
        };
        ALPHA_ANIM m_nAlphaAnimMethod;
    public:
        AlphaPostRenderObject(CBaseObject* pRenderObject, float fObjectToCameraDistance, int nOccluded = 0, float fAlpha = 1.f, ALPHA_ANIM nAlphaAnimMethod = ALPHA_NO_ANIM);
    };

    template<class Type>
    struct LessPostRenderObj
    {
        bool operator()(
            const Type& _Left,
            const Type& _Right
            ) const
        {
            int nLeftTech = _Left.m_pRenderObject->GetPrimaryTechniqueHandle();
            int nRightTech = _Right.m_pRenderObject->GetPrimaryTechniqueHandle();

#ifdef DONOT_SORT_BY_ASSET
            return ( (nLeftTech < nRightTech) || 
                ((nLeftTech == nRightTech) && ((_Left.m_fObjectToCameraDistance) < (_Right.m_fObjectToCameraDistance))) );
#else   
            AssetEntity* LeftAsset = _Left.m_pRenderObject->GetPrimaryAsset();
            AssetEntity* RightAsset = _Right.m_pRenderObject->GetPrimaryAsset();
            return ((nLeftTech < nRightTech) ||
                ((nLeftTech == nRightTech) && (LeftAsset < RightAsset)) ||
                ((nLeftTech == nRightTech) && (LeftAsset == RightAsset) && ((_Left.m_fObjectToCameraDistance) < (_Right.m_fObjectToCameraDistance))));
#endif
        };
    };

    template<class Type>
    struct LessPostRenderObj_NoTechBatch
    {
        inline bool operator()(
            const Type& _Left,
            const Type& _Right
            ) const
        {
            return (_Left.m_fObjectToCameraDistance) < (_Right.m_fObjectToCameraDistance);
        };
    };

    template<class Type>
    struct LessPostRenderObj_BipedSort
    {
        inline bool operator()(
            const Type& _Left,
            const Type& _Right
            ) const
        {
            int nLeftRenderImportance = _Left.m_pRenderObject->GetRenderImportance();
            int nRightRenderImportance = _Right.m_pRenderObject->GetRenderImportance();
            return (nLeftRenderImportance > nRightRenderImportance) ||
                ((nLeftRenderImportance == nRightRenderImportance) && ((_Left.m_fObjectToCameraDistance) < (_Right.m_fObjectToCameraDistance)));
        };
    };

    template<class Type>
    struct GreaterPostRenderObj_ByOrder
    {
        inline bool operator()(
            const Type& _Left,
            const Type& _Right
            ) const
        {
            float leftOrder = _Left.m_pRenderObject->GetRenderOrder();
            float rightOrder = _Right.m_pRenderObject->GetRenderOrder();
            return (leftOrder < rightOrder) ||
                ((leftOrder == rightOrder) && ((_Left.m_pRenderObject->GetPrimaryTechniqueHandle()) < (_Right.m_pRenderObject->GetPrimaryTechniqueHandle())));
        };
    };

    template<class Type>
    struct GreaterPostRenderObj
    {
        bool operator()(
            const Type& _Left,
            const Type& _Right
            ) const
        {
            int nLeftTech = _Left.m_pRenderObject->GetPrimaryTechniqueHandle();
            int nRightTech = _Right.m_pRenderObject->GetPrimaryTechniqueHandle();

#ifdef DONOT_SORT_BY_ASSET
            return ( (nLeftTech < nRightTech) || 
                ((nLeftTech == nRightTech) && ((_Left.m_fObjectToCameraDistance) > (_Right.m_fObjectToCameraDistance))) );
#else   
            AssetEntity* LeftAsset = _Left.m_pRenderObject->GetPrimaryAsset();
            AssetEntity* RightAsset = _Right.m_pRenderObject->GetPrimaryAsset();
            return ((nLeftTech < nRightTech) ||
                ((nLeftTech == nRightTech) && (LeftAsset < RightAsset)) ||
                ((nLeftTech == nRightTech) && (LeftAsset == RightAsset) && ((_Left.m_fObjectToCameraDistance) > (_Right.m_fObjectToCameraDistance))));
#endif
        };
    };

    template<class Type>
    struct GreaterPostRenderObj_NoTechBatch
    {
        inline bool operator()(
            const Type& _Left,
            const Type& _Right
            ) const
        {
            return (_Left.m_fObjectToCameraDistance) > (_Right.m_fObjectToCameraDistance);
        };
    };

    template<class Type> 
    struct CmpBaseObjectAsset
    {
        bool operator()(
            const Type& _Left,
            const Type& _Right
            ) const
        {
            int nLeftTech = _Left->GetPrimaryTechniqueHandle();
            int nRightTech = _Right->GetPrimaryTechniqueHandle();
            return ((nLeftTech < nRightTech) ||
                ((nLeftTech == nRightTech) && (_Left->GetPrimaryAsset()) < (_Right->GetPrimaryAsset())));
        };
    };

    enum SceneStateRenderState
    {
        RenderState_Standard,
        RenderState_3D,
        RenderState_Shadowmap,
        RenderState_Headon,
        RenderState_Overlay_ZPass,
        RenderState_Overlay,
        RenderState_Overlay_Picking,
        RenderState_Debug,
        RenderState_GUI,
    };

    class CPushRenderState
    {
    public:
        CPushRenderState(SceneState* pState, SceneStateRenderState state);
        CPushRenderState(SceneState* pState);
        ~CPushRenderState();
    private:
        SceneState* m_pState;
        SceneStateRenderState m_lastState;
    };

    struct SceneState : public IAttributeFields
    {
    public:
        // constructor
        SceneState(IScene * pScene = NULL);

        ATTRIBUTE_DEFINE_CLASS(SceneState);
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        ATTRIBUTE_METHOD1(SceneState, GetCurrentRenderPipeline_s, int*) { *p1 = cls->GetCurrentRenderPipeline(); return S_OK; }
        ATTRIBUTE_METHOD1(SceneState, SetCurrentRenderPipeline_s, int)  { cls->SetCurrentRenderPipeline(p1); return S_OK; }

        ATTRIBUTE_METHOD1(SceneState, GetRenderState_s, int*)   { *p1 = (int)cls->GetRenderState(); return S_OK; }
        ATTRIBUTE_METHOD1(SceneState, SetRenderState_s, int)    { cls->SetRenderState((SceneStateRenderState)p1); return S_OK; }

        ATTRIBUTE_METHOD1(SceneState, GetCameraToCurObjectDistance_s, float*)   { *p1 = cls->GetCameraToCurObjectDistance(); return S_OK; }
        ATTRIBUTE_METHOD1(SceneState, SetCameraToCurObjectDistance_s, float)    { cls->SetCameraToCurObjectDistance(p1); return S_OK; }

        ATTRIBUTE_METHOD1(SceneState, GetGlobalTime_s, int*)    { *p1 = cls->GetGlobalTime(); return S_OK; }
        ATTRIBUTE_METHOD1(SceneState, SetGlobalTime_s, int) { cls->SetGlobalTime(p1); return S_OK; }

    public:
        CBaseObject* GetCurrentSceneObject();
        void  SetCurrentSceneObject(CBaseObject* pObj);

        void SetCameraToCurObjectDistance(float fDist);

        float GetCameraToCurObjectDistance();

        bool IsLODEnabled();

        void SetShadowMapCameraToCurObjectDistance(float fDist);

        float GetShadowMapCameraToCurObjectDistance();;

        SceneStateRenderState GetRenderState() const;
        void SetRenderState(SceneStateRenderState val);

        void SetShadowPass(bool bShadowPass);
        bool IsShadowPass();
        
        void SetBatchedElementDrawer(IBatchedElementDraw* pDebugDraw);

        IBatchedElementDraw* GetBatchedElementDrawer();

        int GetGlobalTime();
        void SetGlobalTime(int nGlobalTime);

        inline bool IsIgnoreTransparent() { return m_bIgnoreTransparent; }
        void SetIgnoreTransparent(bool bIgnore);

        ParaMaterial& GetGlobalMaterial();

        ParaMaterial& GetLocalMaterial();

        ParaMaterial& GetCurrentMaterial();

        void EnableLocalMaterial(bool bEnable = true);

        bool HasLocalMaterial();

        Vector3& GetCurrentLightStrength();

        RenderDevicePtr GetRenderDevice(){ return m_pd3dDevice; };

        BillBoardViewInfo& BillBoardInfo() { return m_BillBoardInfo; }

        bool IsDeferredShading() const;

        void SetDeferredShading(bool val);

        CBaseCamera* GetCamera();

        int GetCurrentRenderPipeline() const;
        void SetCurrentRenderPipeline(int val);

        void AddToDeferredLightPool(CLightObject * lightObject);

        bool IsGlobalLODEnabled() const;
        void EnableGlobalLOD(bool val);

    public:
        IScene* GetScene(){ return m_pScene; }

        RenderDevicePtr m_pd3dDevice;   
        // scene associated with the state
        IScene*         m_pScene;
        GUIState*         pGUIState;
        CParaWorldAsset*  pAssetManager;

        int m_nCurrentRenderPipeline;

        double          dTimeDelta;
        ParaMaterial    m_matGlobalMaterial;
        ParaMaterial    m_matLocalMaterial;
        bool            m_bUseLocalMaterial : 1;
        bool            bIsBatchRender : 1;
        bool            m_bCameraMoved : 1;
        bool            m_bGlobalLOD : 1;
        
        bool            m_bEnableTranslucentFaceSorting;
        int             m_nRenderCount;
        //int m_nFrameNumber;

        float           fAlphaFactor;   
        DWORD             m_dwD3D_CULLMODE;

        int m_nOccluded;

        // -- camera and view
        Matrix4 mxView;             
        Matrix4 mxProj;             
        Vector3 vEye;               
        Vector3 vLookAt;            
        BillBoardViewInfo m_BillBoardInfo;

        FLOAT      fViewCullingRadius;  
        CBaseObject* pTouchedObject;    
        CEffectFile* m_pCurrentEffect;
        Vector3 m_curLightStrength;

        enum TOUCH_METHOD{ LButton, RButton, None }touchMethod; // how the above object is being touched

        enum ProcessingStage
        {
            /* stages during frame move*/
            stage_framemove = 0,
            stage_UserInputHandling = 1,
            stage_EnvironmentSim = 2,
            stage_AISimulator = 3,
            stage_RootSceneAnimate = 4,
            stage_RootGUIAnimate = 5,

            /* stages during rendering*/
            stage_SetCamera = 101,
            stage_AdvanceScene = 102,
            stage_AdvanceGUI = 103
        }CurrentStage;

        DWORD   m_nCurRenderGroup;
    public:
        typedef std::vector<PostRenderObject>   List_PostRenderObject_Type;
        typedef std::vector<CSpriteObject*> List_CSpriteObjectPtr_Type;
        typedef unordered_array<ParticleSystemRef>  List_ParticleSystemPtr_Type;
        typedef std::vector<AlphaPostRenderObject>  List_AlphaPostRenderObject_Type;
        typedef std::vector<PostRenderObjectWeakPtr>    List_HeadOnRenderObject_Type;
        typedef std::vector<CLightObject*>              List_LightObject_Type;
        

        class List_PostRenderObject_TrackRef_Type : public IRefObject, public List_PostRenderObject_Type
        {
        public:
            void push_back(PostRenderObject& item);

            void clear();

            virtual void OnRefDeleted(IRefObject* rm);
        };

        // -- for batched rendering optimization such as sprites objects
        SceneState::List_PostRenderObject_TrackRef_Type     listPostRenderingObjects;   
#ifdef USE_DIRECTX_RENDERER
        SceneState::List_CSpriteObjectPtr_Type  listPRSprite;               
#endif
        SceneState::List_PostRenderObject_TrackRef_Type     listPRBiped;                
        SceneState::List_PostRenderObject_TrackRef_Type     listPRTransparentBiped;     

        SceneState::List_PostRenderObject_Type  listPRSolidObject;
        SceneState::List_PostRenderObject_Type  listShadowCasters;
        SceneState::List_PostRenderObject_Type  listShadowReceivers;
        SceneState::List_AlphaPostRenderObject_Type listPRSmallObject;
        SceneState::List_HeadOnRenderObject_Type    listHeadonDisplayObject;

        SceneState::List_AlphaPostRenderObject_Type listPRTransparentObject;
        SceneState::List_AlphaPostRenderObject_Type listPRMissiles;
        SceneState::List_ParticleSystemPtr_Type listParticleSystems;

        SceneState::List_PostRenderObject_Type      listZones;
        SceneState::List_PostRenderObject_Type      listPortals;
        SceneState::List_PostRenderObject_Type      listBoundingBox;
        SceneState::List_PostRenderObject_Type      listSelections;
        SceneState::List_LightObject_Type           listDeferredLightObjects;
        // like the render target 
        unordered_array<WeakPtr>        listOwnerDrawObjs;

        bool m_bSkipOcean;
        bool m_bSkipTerrain;
        bool m_bSkipSky;
        // whether the outer world is visible. this is usually true, unless camera is inside a zone. 
        // if this is false, ocean terrain sky are escaped. 
        bool m_bOuterWorldZoneVisible;
        bool m_bDeferredShading;

        vector<int> m_MaxRenderCount;

        vector<int> m_RenderCount;

        void SetMaxRenderCount(int nRenderImportance, int nCount);

        bool CheckAddRenderCount(int nRenderImportance);

        inline int GetRenderFrameCount() { return m_nRenderCount; }

        template <class T>
        typename T::value_type* FindObject(T& renderlist, CBaseObject* pObject)
        {
            typename T::iterator itCur, itEnd = renderlist.end();
            for (itCur = renderlist.begin(); itCur != itEnd; ++itCur)
            {
                if (itCur->m_pRenderObject == pObject)
                {
                    return &(*itCur);
                }
            }
            return NULL;
        }

        CSortedFaceGroups m_SortedFaceGroups;

        void CleanupSceneState();
        void Cleanup();

        void AddParticleSystem(ParticleSystem* ps);

        CSortedFaceGroups* GetFaceGroups();

        HRESULT InitDeviceObjects();    // device independent
        HRESULT RestoreDeviceObjects(); // device dependent
        HRESULT InvalidateDeviceObjects();
        HRESULT DeleteDeviceObjects();

    private:
        static CBaseObject*     m_pCurrentSceneObject;

        IBatchedElementDraw* m_pBatchedDrawer;

        float m_fCameraToObjectDistance;

        float m_fShadowMapCameraToObjectDistance;

        bool m_bIgnoreTransparent;

        bool m_bIsShadowPass;

        int m_nGlobalTime;

        SceneStateRenderState m_renderState;
    };
}