SceneObject.h

#pragma once
#include "BaseObject.h"
#include "ShadowVolume.h"
#include "ShapeRay.h"
#include "SceneState.h"
#include "ObjScriptPool.h"
#include "IScene.h"
#include "IObjectDrag.h"
#include "util/ParaMemPool.h"
#include "util/unordered_array.hpp"
#include <list>
#include <map>
#include <queue>

namespace ParaTerrain
{
    class CGlobalTerrain;
}

namespace ParaEngine
{
    class IParaDebugDraw;
    class IBatchedElementDraw;
    class CBatchedElementDraw;
    class BlockWorldClient;
    class CTerrainTileRoot;
    class DropShadowRenderer;
    class CSunLight;
    typedef ObjectScriptPool<CBaseObject> CSceneScripts;

    typedef CTerrainTile* CTerrainTilePtr;
    typedef FixedSizedAllocator<CTerrainTilePtr>    DL_Allocator_CTerrainTilePtr;
    typedef std::deque<CTerrainTilePtr, DL_Allocator_CTerrainTilePtr >  deque_CTerrainTilePtr_Type;
    typedef std::queue<CTerrainTilePtr, deque_CTerrainTilePtr_Type >    queue_CTerrainTilePtr_Type;

    typedef CBaseObject* CBaseObjectPtr;
    typedef FixedSizedAllocator<CBaseObjectPtr> DL_Allocator_CBaseObjectPtr;
    typedef std::deque<CBaseObjectPtr, DL_Allocator_CBaseObjectPtr >    deque_CBaseObjectPtr_Type;
    typedef std::queue<CBaseObjectPtr, deque_CBaseObjectPtr_Type >  queue_CBaseObjectPtr_Type;

    typedef unordered_array<WeakPtr>    list_IObjectWeakPtr_Type;

    typedef bool (*OBJECT_FILTER_CALLBACK)(CBaseObject* obj);
    
    class CSceneObject :
        public CBaseObject,public IObjectDrag, public IScene
    {
    public:
        typedef unordered_ref_array <CAutoCamera*> CameraPool_type;
        typedef unordered_ref_array <CMiniSceneGraph*> MiniSceneGraphPool_type;
        typedef unordered_ref_array <CSkyMesh*> SkyMeshPool_type;
        typedef std::list <ShadowVolume*> ShadowVolumePool_Type;
        typedef unordered_ref_array<CMissileObject*> MissileObjectPool_Type;
#ifdef PARAENGINE_CLIENT
        typedef std::vector <CMirrorSurface*> MirrorSufacePool_Type;
#endif
        CSceneObject();
        virtual ~CSceneObject(void);

        virtual CBaseObject::_SceneObjectType GetType(){return CBaseObject::SceneRoot;};
        static CSceneObject* g_pRootscene;
        static CSceneObject* GetInstance();

        /************************************************************************/
        /* Object-level culling method                                          */
        /************************************************************************/
        enum OBJECT_LEVEL_CULLING_METHOD
        {
            CENTER_ON_CAMERA = 1,
            CENTER_ON_PLAYER = 0x1<<1,
            CENTER_ON_FRUSTUM = 0x1<<2,
            VIEW_RADIUS_FOG = 0x1<<3,
            VIEW_RADIUS_FRUSTUM = 0x1<<4,
        };
    public:

        // implementation of IAttributeFields

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

        virtual IAttributeFields* GetChildAttributeObject(const std::string& sName);
        virtual int GetChildAttributeObjectCount(int nColumnIndex = 0);
        virtual int GetChildAttributeColumnCount();
        virtual IAttributeFields* GetChildAttributeObject(int nRowIndex, int nColumnIndex = 0);

        ATTRIBUTE_METHOD1(CSceneObject, IsModified_s, bool*)    {*p1 = cls->IsModified(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetModified_s, bool)    {cls->SetModified(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsUsingFullScreenGlow_s, bool*) {*p1 = cls->IsUsingFullScreenGlow(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, EnableFullScreenGlow_s, bool)   {cls->EnableFullScreenGlow(p1); return S_OK;}
        

        ATTRIBUTE_METHOD1(CSceneObject, GetFullscreenGlowIntensity_s, float*)   {*p1 = cls->GetFullscreenGlowIntensity(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetFullscreenGlowIntensity_s, float)    {cls->SetFullscreenGlowIntensity(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, GetFullscreenGlowBlendingFactor_s, float*)  {*p1 = cls->GetFullscreenGlowBlendingFactor(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetFullscreenGlowBlendingFactor_s, float)   {cls->SetFullscreenGlowBlendingFactor(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, GetGlowness_s, Vector4*)        {*p1 = *(Vector4*)(&cls->GetGlowness()); return S_OK;}
        //ATTRIBUTE_METHOD1(CSceneObject, SetGlowness_s, Vector4)       {LinearColor c(p1.x, p1.y,p1.z,1); cls->SetGlowness(c); return S_OK;}
        //change glowness type to Vector4  --clayman 2011.7.19
        ATTRIBUTE_METHOD1(CSceneObject, SetGlowness_s, Vector4)     { cls->SetGlowness(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsSunLightEnabled_s, bool*) {*p1 = cls->IsSunLightEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, EnableSunLight_s, bool) {cls->EnableSunLight(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsLightEnabled_s, bool*)    {*p1 = cls->IsLightEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, EnableLight_s, bool)    {cls->EnableLight(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsShowLocalLightMesh_s, bool*)  {*p1 = cls->IsShowLocalLightMesh(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, ShowLocalLightMesh_s, bool) {cls->ShowLocalLightMesh(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, GetMaxLocalLightsNum_s, int*)   {*p1 = cls->GetMaxLocalLightsNum(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetMaxLocalLightsNum_s, int)    {cls->SetMaxLocalLightsNum(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsShadowMapEnabled_s, bool*)    {*p1 = cls->IsShadowMapEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetShadow_s, bool)  {cls->SetShadow(p1); return S_OK;}
        
        ATTRIBUTE_METHOD1(CSceneObject, GetMaximumNumShadowCasters_s, int*) {*p1 = cls->GetMaximumNumShadowCasters(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetMaximumNumShadowCasters_s, int)  {cls->SetMaximumNumShadowCasters(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, GetMaximumNumShadowReceivers_s, int*)   {*p1 = cls->GetMaximumNumShadowReceivers(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetMaximumNumShadowReceivers_s, int)    {cls->SetMaximumNumShadowReceivers(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, GetMaxCharTriangles_s, int*)    {*p1 = cls->GetMaxCharTriangles(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetMaxCharTriangles_s, int) {cls->SetMaxCharTriangles(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, GetBackGroundColor_s, Vector3*)     { *p1 = cls->GetBackGroundColor().ToVector3(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetBackGroundColor_s, Vector3)      {LinearColor c(p1.x, p1.y,p1.z,1); cls->SetBackGroundColor(c); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsFogEnabled_s, bool*)  {*p1 = cls->IsFogEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, EnableFog_s, bool)  {cls->EnableFog(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, GetFogColor_s, Vector3*)        { *p1 = cls->GetFogColorFactor().ToVector3(); return S_OK; }
        ATTRIBUTE_METHOD1(CSceneObject, SetFogColor_s, Vector3)     {LinearColor c(p1.x, p1.y,p1.z,1); cls->SetFogColorFactor(c); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, GetFogStart_s, float*)  {*p1 = cls->GetFogStart(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetFogStart_s, float)   {cls->SetFogStart(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, GetFogEnd_s, float*)    {*p1 = cls->GetFogEnd(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetFogEnd_s, float) {cls->SetFogEnd(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, GetFogDensity_s, float*)    {*p1 = cls->GetFogDensity(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetFogDensity_s, float) {cls->SetFogDensity(p1); return S_OK;}
        
        ATTRIBUTE_METHOD1(CSceneObject, GetMinPopUpDistance_s, float*)  {*p1 = cls->GetMinPopUpDistance(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetMinPopUpDistance_s, float)   {cls->SetMinPopUpDistance(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, GetOnClickDistance_s, float*)   {*p1 = cls->GetOnClickDistance(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetOnClickDistance_s, float)    {cls->SetOnClickDistance(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsRenderSky_s, bool*)   {*p1 = cls->IsRenderSky(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, EnableSkyRendering_s, bool) {cls->EnableSkyRendering(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsScenePaused_s, bool*) {*p1 = cls->IsScenePaused(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, PauseScene_s, bool) {cls->PauseScene(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsSceneEnabled_s, bool*)    {*p1 = cls->IsSceneEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, EnableScene_s, bool)    {cls->EnableScene(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsShowBoundingBox_s, bool*) {*p1 = cls->IsShowBoundingBox(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, ShowBoundingBox_s, bool)    {cls->ShowBoundingBox(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsGenerateReport_s, bool*)  {*p1 = cls->IsGenerateReport(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetGenerateReport_s, bool)  {cls->SetGenerateReport(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsPortalSystemShown_s, bool*)   {*p1 = cls->IsPortalSystemShown(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, ShowPortalSystem_s, bool)   {cls->ShowPortalSystem(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsAutoPlayerRippleEnabled_s, bool*) {*p1 = cls->IsAutoPlayerRippleEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, EnableAutoPlayerRipple_s, bool) {cls->EnableAutoPlayerRipple(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsHeadOnDisplayShown_s, bool*)  {*p1 = cls->IsHeadOnDisplayShown(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, ShowHeadOnDisplay_s, bool)  {cls->ShowHeadOnDisplay(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsPortalZoneEnabled_s, bool*)   {*p1 = cls->IsPortalZoneEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, EnablePortalZone_s, bool)   {cls->EnablePortalZone(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsUseWireFrame_s, bool*)    {*p1 = cls->IsUseWireFrame(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetUseWireFrame_s, bool)    {cls->SetUseWireFrame(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsForceExportPhysics_s, bool*)  {*p1 = cls->IsForceExportPhysics(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetForceExportPhysics_s, bool)  {cls->SetForceExportPhysics(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsInstancingEnabled_s, bool*)   {*p1 = cls->IsInstancingEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, EnableInstancing_s, bool)   {cls->EnableInstancing(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, GetMaxHeadOnDisplayDistance_s, float*)  {*p1 = cls->GetMaxHeadOnDisplayDistance(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetMaxHeadOnDisplayDistance_s, float)   {cls->SetMaxHeadOnDisplayDistance(p1); return S_OK;}
        
        ATTRIBUTE_METHOD1(CSceneObject, IsPersistent_s, bool*)      {*p1 = cls->IsPersistent(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetPersistent_s, bool)      {cls->SetPersistent(p1); return S_OK;}

        ATTRIBUTE_METHOD(CSceneObject, ScreenShotReflection_s)  {return cls->ScreenShotReflection() ? S_OK:E_FAIL;}
        ATTRIBUTE_METHOD(CSceneObject, ScreenShotShadowMap_s)   {return cls->ScreenShotShadowMap() ? S_OK:E_FAIL;}
        ATTRIBUTE_METHOD(CSceneObject, ScreenShotGlowMap_s) {return cls->ScreenShotGlowMap() ? S_OK:E_FAIL;}
        ATTRIBUTE_METHOD(CSceneObject, ClearParticles_s)    {cls->ClearParticles(); return  S_OK;}
        ATTRIBUTE_METHOD(CSceneObject, UnLoadFlashTextures_s)   {return cls->UnLoadFlashTextures() ? S_OK:E_FAIL;}
        
        ATTRIBUTE_METHOD1(CSceneObject, GetPhysicsDebugDrawMode_s, int*)    {*p1 = cls->GetPhysicsDebugDrawMode(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetPhysicsDebugDrawMode_s, int) {cls->SetPhysicsDebugDrawMode(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsBlockInput_s, bool*)  {*p1 = cls->IsBlockInput(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetBlockInput_s, bool)  {cls->SetBlockInput(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, GetAllMiniSceneGraphNames_s, const char**)  {*p1 = cls->GetAllMiniSceneGraphNames().c_str(); return S_OK;}
        
        ATTRIBUTE_METHOD1(CSceneObject, GetShadowRadius_s, float*)  {*p1 = cls->GetShadowRadius(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetShadowRadius_s, float)   {cls->SetShadowRadius(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsDropShadow_s, bool*)  {*p1 = cls->IsDropShadow(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetDropShadow_s, bool)  {cls->SetDropShadow(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsUsingScreenWaveEffect_s, bool*)   {*p1 = cls->IsUsingScreenWaveEffect(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, SetEnableScreenWaveEffect_s, bool)  {cls->EnableScreenWaveEffect(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, IsShowMainPlayer_s, bool*)  {*p1 = cls->IsShowMainPlayer(); return S_OK;}
        ATTRIBUTE_METHOD1(CSceneObject, ShowMainPlayer_s, bool) {cls->ShowMainPlayer(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CSceneObject, SetShadowMapTexelSize_s, int)   { cls->SetShadowMapTexelSize(p1, p1); return S_OK; }
    public:
        void ShowHeadOnDisplay(bool bShow){m_bShowHeadOnDisplay = bShow;};

        bool IsHeadOnDisplayShown(){return m_bShowHeadOnDisplay;};
        
        void SetMaxHeadOnDisplayDistance(float fDist){m_fMaxHeadOnDisplayDistance = fDist;};

        float GetMaxHeadOnDisplayDistance(){return m_fMaxHeadOnDisplayDistance;};

        bool ScreenShotReflection();
        bool ScreenShotShadowMap();
        bool ScreenShotGlowMap();

        bool UnLoadFlashTextures();

        void ClearParticles();

        void SetForceExportPhysics(bool bWhetherPhysicsAreAlwaysExported);

        bool IsForceExportPhysics();

        float GetMinPopUpDistance(){return m_fMinPopUpDistance;};
        void SetMinPopUpDistance(float fDist){m_fMinPopUpDistance = fDist;}
        
        bool IsSnapToTerrain(){return m_bSnapToTerrain;};

        bool IsShowBoundingBox(){return m_bShowBoundingBox;};
        void ShowBoundingBox(bool bEnable){m_bShowBoundingBox = bEnable;}

        bool IsGenerateReport(){return m_bGenerateReport;};
        void SetGenerateReport(bool bEnable){m_bGenerateReport = bEnable;}
        
        bool IsOcclusionQueryEnabled(){return m_bEnableOcclusionQuery;};
        void EnableOcclusionQuery(bool bEnable){m_bEnableOcclusionQuery = bEnable;}

        bool IsInstancingEnabled(){return m_bUseInstancing;};
        void EnableInstancing(bool bEnable){m_bUseInstancing = bEnable;}

        bool IsShowMainPlayer();
        void ShowMainPlayer(bool bEnable);

        bool CanShowMainPlayer() const;
        void SetCanShowMainPlayer(bool val);

        bool IsScenePaused(){return m_bGamePaused;};
        void PauseScene(bool bEnable);

        bool IsSceneEnabled(){return m_bGameEnabled;};
        void EnableScene(bool bEnable);
        
        void SetModified(bool bModified);
        bool IsModified();

        bool IsSunLightEnabled();
        void EnableSunLight(bool bEnable);

        bool IsLightEnabled();
        void EnableLight(bool bEnable);

        void SetMaxLocalLightsNum(int nNum);

        int GetMaxLocalLightsNum();

        bool IsShowLocalLightMesh();
        void ShowLocalLightMesh(bool bShow);

        bool IsRenderSky(){ return m_bRenderSky; }
        void EnableSkyRendering(bool bEnable){m_bRenderSky = bEnable;};

        void SetBackGroundColor(const LinearColor& bgColor);
        LinearColor GetBackGroundColor();

        LinearColor GetClearColor();

        void SetFogColorFactor(const LinearColor& fogColorFactor){m_FogColorFactor = fogColorFactor;};
        const LinearColor& GetFogColorFactor(){return m_FogColorFactor;};
        void SetFogColor(const LinearColor& fogColor);
        LinearColor GetFogColor();
        void SetFogStart(float fFogStart);
        float GetFogStart();
        void SetFogEnd(float fFogEnd);
        float GetFogEnd();
        void SetFogDensity(float fFogDensity);
        float GetFogDensity();
        void EnableFog(bool bEnableFog);
        bool IsFogEnabled();
        void ResetCameraAndFog();
        void SetAndRestoreFog(bool bEnableFog, DWORD dwFogColor, FLOAT fFogStart, FLOAT fFogEnd, FLOAT fFogDensity);
        
        void SetShadow(bool bRenderShadow);
        bool IsShadowMapEnabled();

        int GetMaximumNumShadowCasters();

        void SetMaximumNumShadowCasters(int nNum);

        int GetMaximumNumShadowReceivers();

        void SetMaximumNumShadowReceivers(int nNum);

        void SetMaxCharTriangles(int nNum);

        int  GetMaxCharTriangles();

        void SetMaxRenderCount(int nRenderImportance, int nCount);
        int GetMaxRenderCount(int nRenderImportance);
        
        bool IsUsingFullScreenGlow();

        void EnableFullScreenGlow( bool bEnable);

        bool IsUsingScreenWaveEffect();
        void EnableScreenWaveEffect(bool value);

        void SetCursor(const char* szCursorFile, int nHotSpotX = -1, int nHotSpotY = -1);
        const std::string& GetCursor(int* pnHotSpotX = 0, int* pnHotSpotY = 0) const;
        
        //now glowness contains 4 control value
        //glowness.x : glow saturate
        //glowness.y : glow brightness/intensity
        //glowness.z : original scene saturate
        //glowness.w : original scene brightness/intensity  --clayman 2011.7.19

        void SetGlowness(const Vector4& Glowness);
        const Vector4& GetGlowness();


        void SetShadowMapTexelSizeLevel(int nLevel);
        void SetShadowMapTexelSize(int nWidth, int nHeight);

    public:
        CMissileObject* NewMissile();
        bool CheckObjectCullingMethod(DWORD dwMethod){
            return ((dwMethod & m_dwObjCullingMethod)==dwMethod); 
        };
        CManagedLoader* GetManagedLoader(string sName);
        bool DeleteManagedLoader(string sName);
        CManagedLoader* CreateManagedLoader(string sName);

        void AddConsoleStr(const char * pStr);
        void ClearConsoleStr();
                
        bool IsInitialized();

        void OnTerrainChanged(const Vector3& vCenter, float fRadius);

        void ResetScene();
        Vector3 GetRenderOrigin();
        void RegenerateRenderOrigin(const Vector3& vPos);

        // void CleanDeleteList();

        ParaTerrain::CGlobalTerrain*    GetGlobalTerrain();

        bool DeleteSentientObject(IGameObject* pObj);
        void AddSentientObject(IGameObject* pObj, bool bCheckDuplicate = false);

        inline CTerrainTileRoot* GetRootTile()  {return m_pTileRoot.get();};

        inline CBaseCamera* GetCurrentCamera(){ return m_pCurrentCamera;};

        CSkyMesh*               GetCurrentSky();
        bool CreateSkyBox(const string& strObjectName, AssetEntity& MeshAsset, float fScaleX, float fScaleY,float fScaleZ, float fHeightOffset);
        bool DeleteSkyBox(const string& strObjectName);

        CSunLight&              GetSunLight();

        /*
        * @absolete: this function is no longer used. 
        * detach a specified object from the scene and destroy it. A destroyed object can no longer be used.
        * @param id: if id == "\\", the entire scene is deleted and game is put into unloaded state and paused. 
        *   asset is not released by this call.
        */
        void DestroyObjectByName(const char * id);
        IObject* AttachObject(CBaseObject * pObject);

        bool DetachObject(CBaseObject * pObject);
        
        virtual CBaseObject* GetGlobalObject(const string& sName);

        CBaseObject* GetLocalObject(const string& sName, const Vector3& vPos);
        
        CBaseObject* GetLocalObject(const Vector3& vPos, float fEpsilon=0.01f);
        CBaseObject* GetLocalObject(const Vector3& vPos, const std::string& sName, float fEpsilon=0.01f);

        CBaseObject* GetObject(const string& sName, const Vector3& vPos, bool bGlobal);

        CBaseObject* FindObjectByNameAndType(const std::string& sName, const std::string& sClassName);

        CBaseObject* GetObjectByViewBox(const CShapeAABB& viewbox);

        int GetObjectsBySphere(list<CBaseObject*>& output, const CShapeSphere& sphere, OBJECT_FILTER_CALLBACK pFnctFilter=NULL, int nMethod=0);

        int GetObjectsByScreenRect(list<CBaseObject*>& output, const RECT& rect,OBJECT_FILTER_CALLBACK pFnctFilter=NULL, float fMaxDistance = -1.f);

        CMiniSceneGraph* GetPostProcessingScene();

        void EnablePostProcessing(bool bEnable, const char* sCallbackScript);

        bool IsPostProcessingEnabled();

        CMiniSceneGraph*  GetMiniSceneGraph(const string& name);
            
        int DeleteMiniSceneGraph(const string& name);

        void EnableMiniSceneGraph(bool bEnable);

        bool IsMiniSceneGraphEnabled();

        const std::string& GetAllMiniSceneGraphNames();

        bool DeleteObject(CBaseObject * pObject);

        void ShowPortalSystem(bool bEnable);

        bool IsPortalSystemShown();         

        void UnloadObjectResources(CBaseObject * pObject);

        virtual HRESULT InitDeviceObjects();
        virtual HRESULT DeleteDeviceObjects();
        virtual HRESULT RestoreDeviceObjects();
        virtual HRESULT InvalidateDeviceObjects();
        virtual HRESULT RendererRecreated();
        virtual void Cleanup();

        float PickClosest(const Vector3& vPickRayOrig, const Vector3& vPickRayDir , CBaseObject** pTouchedObject, Vector3* vIntersectPos, Vector3* vImpactNormal = NULL, bool bTestObject=false, float fMaxDistance = 0, DWORD dwGroupMask=0xffffffff);

        float PickClosest(int nScreenX, int nScreenY, CBaseObject** pPickedObject, Vector3* vIntersectPos, Vector3* vImpactNormal = NULL, bool bTestObject=false, float fMaxDistance=0, DWORD dwGroupMask=0xffffffff);
        bool PickObject(const CShapeRay& ray, CBaseObject** pTouchedObject, float fMaxDistance=0, OBJECT_FILTER_CALLBACK pFnctFilter=NULL);
        bool PickObject(int nScreenX, int nScreenY, CBaseObject** pTouchedObject, float fMaxDistance=0, OBJECT_FILTER_CALLBACK pFnctFilter=NULL);

        int SelectObject(int nGroupIndex, const CShapeOBB& box, OBJECT_FILTER_CALLBACK pFnctFilter=NULL);
        int SelectObject(int nGroupIndex, const CShapeSphere& circle, OBJECT_FILTER_CALLBACK pFnctFilter=NULL);

        void PauseGame(){PauseScene(true);};
        void DisableGame(){ EnableScene(false);};
        
        
        // -- For rendering and frame move --
        virtual void Animate( double dTimeDelta, int nRenderNumber=0);

        HRESULT AdvanceScene( double dTimeDelta, int nPipelineOrder = PIPELINE_3D_SCENE);

        void UpdateFogColor();
        Vector3 GetFogColor(float fAngle);

        int RenderSelection(DWORD dwSelection=0xffffffff, double dTimeDelta=0);

        int RenderCharacters(SceneState& sceneState, SceneState::List_PostRenderObject_TrackRef_Type& listPRBiped);

        int RenderHeadOnDisplay(int nPass = 0);

        CMirrorSurface* GetMirrorSurface(int nIndex);
        
        // -- Used mostly internally
        virtual HRESULT Draw(SceneState * sceneState);
        void RenderShadows();   
        void RenderShadowMap(); 

        void RenderFullScreenGlowEffect();  

        //render screen wave effect
        void RenderScreenWaveEffect();

        void ApplyWaterFogParam();
        void RestoreSceneFogParam();

        void SetCurrentPlayer(CBipedObject* pPlayer);

        CBipedObject*           GetCurrentPlayer();
        CBipedObject*           GetNextPlayer(CBipedObject* pObj);

        bool HandleUserInput();

        CSceneScripts&  GetScripts();

        void EnableMouseEvent(bool bEnable, DWORD dwEvents=0xffff);

        const CEventBinding * GetEventBinding();

        void LoadDefaultEventBinding();

        CBaseObject* GetCurrentActor();
        void SetCurrentActor(CBaseObject* pActor);

        void UpdateOcean();

        int SaveLocalCharacters();
        
        int SaveAllCharacters();

        int SaveCharacterToDB(IGameObject* pObj);
        int RemoveCharacterFromDB(IGameObject* pObj);

        bool IsPersistent();

        void SetPersistent(bool bPersistent);

        virtual void SetCandrag(bool bCandrag){m_bCandrag=bCandrag;}
        virtual bool GetCandrag()const{return m_bCandrag;}
        virtual void BeginDrag(int nEvent, int x, int y, int z){}
        virtual void EndDrag(int nEvent, int x, int y, int z){}
        virtual BOOL IsOnObject(int x,int y, int z);
        bool IsPickingObject(){return m_bPickFlag;};

        CBaseObject* TogglePlayer();

        bool LoadNPCByNPCDbItem(CNpcDbItem& npc,CRpgCharacter** pOut, bool bReload = false);

        bool DB_LoadNPCByID(int nNPCID, CRpgCharacter** pOut, bool bReload = false);
        bool DB_LoadNPCByName(const string& sName, CRpgCharacter** pOut, bool bReload = false);

        int DB_LoadNPCsByRegion(const Vector3& vMin, const Vector3& vMax, bool bReload = false);
        
        void SetFullscreenGlowIntensity(float fGlowIntensity);
        float GetFullscreenGlowIntensity();

        void SetFullscreenGlowBlendingFactor(float fGlowFactor);
        float GetFullscreenGlowBlendingFactor();

        bool IsAutoPlayerRippleEnabled(){return m_bAutoPlayerRipple;};
        void EnableAutoPlayerRipple(bool bEnable){m_bAutoPlayerRipple = bEnable;};

        bool IsPortalZoneEnabled(){return m_bEnablePortalZone;};

        void EnablePortalZone(bool bEnable){m_bEnablePortalZone = bEnable;};
        
        bool IsUseWireFrame(){return m_bUseWireFrame;};

        void SetUseWireFrame(bool UseWireFrame );
        

        inline list_IObjectWeakPtr_Type&    GetSentientObjects(){ return m_sentientGameObjects; };

        inline MissileObjectPool_Type& GetMissiles(){return m_missiles;};

        void SetEnvironmentSim(IEnvironmentSim* pSim);

        SceneState* GetSceneState(){return m_sceneState.get();};
        inline CPhysicsWorld* GetPhysicsWorld() {return m_pPhysicsWorld.get();} ;
        inline IEnvironmentSim* GetEnvSim() {return m_pEnvironmentSim;};

        IParaDebugDraw* GetDebugDrawer();
        
        IBatchedElementDraw* GetBatchedElementDrawer();

        void SetPhysicsDebugDrawMode(int nMode);

        int GetPhysicsDebugDrawMode();

        void SetOnClickDistance(float fDist){ m_fOnClickDistance = fDist;}
        float GetOnClickDistance(){ return m_fOnClickDistance;}

        CZoneNode * CreateGetZoneNode(const char* sName);
        CZoneNode * GetZoneNode(const char* sName);
        CPortalNode * CreateGetPortalNode(const char* sName);
        CPortalNode * GetPortalNode(const char* sName);

        virtual float GetShadowRadius() { return m_fShadowRadius; }
        void SetShadowRadius(float fShadowRadius);

        bool IsBlockInput(){return m_bBlockInput;}
        void SetBlockInput(bool bBlockInput){m_bBlockInput = bBlockInput;}

        virtual void SetPhysicsGroupMask(DWORD dwValue); 

        virtual DWORD GetPhysicsGroupMask(); 

        bool IsDropShadow(){return m_renderDropShadow;}
        void SetDropShadow(bool useDropShadow){m_renderDropShadow = useDropShadow;}

        void AddToDeadObjectPool(CBaseObject* pObject);
        void RemoveDeadObjects();
    private:

        bool m_bBlockInput;

        bool m_bEnablePostProcessing;
        string m_sPostPorcessorCallbackScript;

        bool m_bShowHeadOnDisplay;

        float m_fMaxHeadOnDisplayDistance;

        bool m_bEnableMiniScenegraph;

        bool m_bAutoPlayerRipple;
        DWORD m_dwObjCullingMethod;
        float   m_fCullingPixelsHeight;
        float   m_fMinPopUpDistance;
        
        map <string, CManagedLoader*> m_managedloader;

        bool                    m_bRenderFog;
        DWORD                   m_dwFogColor;
        LinearColor             m_FogColorFactor;
        FLOAT                   m_fFogStart;
        FLOAT                   m_fFogEnd;
        FLOAT                   m_fFogDensity;
        
        float m_fShadowRadius;
        
        DWORD                   m_dwBackGroundColor;
        bool                    m_bSnapToTerrain; 
        bool                    m_bShowBoundingBox;
        bool                    m_bGenerateReport;

        bool                    m_bEnableOcclusionQuery;

        bool                    m_bGamePaused;      
        bool                    m_bGameEnabled;     
        
        ShadowVolumePool_Type   m_ShadowVolumes;
        bool                    m_bRenderMeshShadow;
        
        CameraPool_type     m_cameras;
        CBaseCamera* m_pCurrentCamera;
        SkyMeshPool_type        m_skymeshes;
        MiniSceneGraphPool_type     m_miniSceneGraphs;
        
        bool                    m_bRenderSky;

        bool m_bModified;

        CGUIEvent *m_event;

        Vector3 m_vRenderOrigin;

        ref_ptr<SceneState>             m_sceneState;

        int                     m_nMaxNumShadowCasters;
        int                     m_nMaxNumShadowReceivers;

        int                     m_nMaxCharTriangles;


        float m_fFullscreenGlowIntensity;
        float m_fFullscreenGlowBlendingFactor;

        ref_ptr<ParaTerrain::CGlobalTerrain>    m_globalTerrain;
        
        CSceneScripts           m_scripts;
        bool                    m_bInitialized;

        DWORD m_dwEnableMouseEvent;
        CBipedObject*           m_currentplayer;

        bool                    m_bEnableLighting;
        bool                    m_bEnableSunLight;

        ref_ptr<CSunLight> m_pSunLight;

        CBaseObject* m_pickObj;
        CBaseObject* m_pActor;

        bool m_bShowLocalLightMesh;

        bool m_bPickFlag;


        bool m_bEnablePortalZone;

        bool m_bShowPortalSystem;

        bool m_bUseWireFrame;


        float m_fCoefF, m_fCoefN, m_fCoefK;

        virtual bool PrepareRenderObject(CBaseObject* pObj, CBaseCamera* pCamera, SceneState& sceneState);
        
        virtual int PrepareRender(CBaseCamera* pCamera, SceneState * pSceneState);

        void PrepareRenderAllChildren(CBaseCamera* pCamera, SceneState& sceneState);

        void PrepareCameraState(CBaseCamera* pCamera, SceneState &sceneState);

        void PreparePortalsAndZones(CBaseCamera* pCamera, SceneState &sceneState);

        void PrepareMissileObjects(CBaseCamera* pCamera, SceneState &sceneState);

        void PrepareTileObjects(CBaseCamera* pCamera, SceneState &sceneState);

        void UpdateMovableObjectZone(SceneState &sceneState, SceneState::List_PostRenderObject_Type& listPRBiped);

        void AutoGenPlayerRipple(float fTimeDelta);

        void CreateAttributeModels();

#ifdef USE_DIRECTX_RENDERER
        std::unique_ptr<DropShadowRenderer> m_dropShadowRenderer;
#endif
        bool m_renderDropShadow;

        LinearColor m_defaultAmbColor;
        LinearColor m_defaultFogColor;
        float m_defaultFogStart;
        float m_defaultFogEnd;


        //
        ref_ptr<BlockWorldClient> m_pBlockWorldClient;
        
    protected:
        IEnvironmentSim*        m_pEnvironmentSim;      
        ref_ptr<CPhysicsWorld>          m_pPhysicsWorld;        

        CBatchedElementDraw*            m_pBatchedElementDraw;

        list_IObjectWeakPtr_Type        m_sentientGameObjects;
        MissileObjectPool_Type  m_missiles;
#ifdef PARAENGINE_CLIENT

        MirrorSufacePool_Type m_mirrorSurfaces;
#endif

        map <string, CZoneNode*> m_zones;
        map <string, CPortalNode*> m_portals;

        ref_ptr<CTerrainTileRoot>   m_pTileRoot;
        unordered_ref_array<CBaseObject*>  m_dead_objects;

        char                    m_sConsoleString[200];  
        
        float m_fOnClickDistance;

        bool m_bUseInstancing;

        bool m_bIsPersistent;

        bool m_bShowMainPlayer;

        bool m_bCanShowMainPlayer;

        vector<int> m_MaxRenderCount;

        std::string m_sMiniSceneGraphNames;

        std::string m_sCursorFile;
        int16 m_nCursorHotSpotX;
        int16 m_nCursorHotSpotY;

        DWORD m_dwPhysicsGroupMask;

        float m_fPostRenderQueueOrder;
        unordered_ref_array<IAttributeFields*> m_attribute_models;
        friend class CParaEngineApp;
    };

}