MiniSceneGraph.h

#pragma once
#include "RenderTarget.h"
#include "SceneState.h"
#include "IScene.h"
#include "SunLight.h"
#include <map>

namespace ParaEngine
{
    // forward declare
    class CCanvasCamera;
    class CBaseCamera;
    struct TextureEntity;
    class CShapeRay;
    class IBatchedElementDraw;
    class CBatchedElementDraw;

    typedef bool (*OBJECT_FILTER_CALLBACK)(CBaseObject* obj);

    class CMiniSceneGraph : public CRenderTarget, public IScene
    {
    public:
        typedef ParaEngine::weak_ptr<IObject, CMiniSceneGraph> WeakPtr_type;
        CMiniSceneGraph(void);
        virtual ~CMiniSceneGraph(void);
        virtual CBaseObject::_SceneObjectType GetType(){return CBaseObject::MiniSceneGraph;};
        
        // implementation of IAttributeFields
        virtual int GetAttributeClassID(){return ATTRIBUTE_CLASSID_MiniSceneGraph;}
        virtual const char* GetAttributeClassName(){static const char name[] = "CMiniSceneGraph"; return name;}
        virtual const char* GetAttributeClassDescription(){static const char desc[] = ""; return desc;}
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

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

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

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

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

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

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

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

        ATTRIBUTE_METHOD1(CMiniSceneGraph, GetFogDensity_s, float*) {*p1 = cls->GetFogDensity(); return S_OK;}
        ATTRIBUTE_METHOD1(CMiniSceneGraph, SetFogDensity_s, float)  {cls->SetFogDensity(p1); return S_OK;}

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

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

        ATTRIBUTE_METHOD1(CMiniSceneGraph, IsUsePointTexture_s, bool*)  { *p1 = cls->IsUsePointTexture(); return S_OK; }
        ATTRIBUTE_METHOD1(CMiniSceneGraph, SetUsePointTexture_s, bool)  { cls->SetUsePointTexture(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CMiniSceneGraph, GetMaxHeadOnDisplayDistance_s, float*)   {*p1 = cls->GetMaxHeadOnDisplayDistance(); return S_OK;}
        ATTRIBUTE_METHOD1(CMiniSceneGraph, SetMaxHeadOnDisplayDistance_s, float)    {cls->SetMaxHeadOnDisplayDistance(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CMiniSceneGraph, GetRenderPipelineOrder_s, int*)  {*p1 = cls->GetRenderPipelineOrder(); return S_OK;}
        ATTRIBUTE_METHOD1(CMiniSceneGraph, SetRenderPipelineOrder_s, int)   {cls->SetRenderPipelineOrder(p1); return S_OK;}
        
            
        bool IsRenderSky(){ return m_bRenderSky; }
        void EnableSkyRendering(bool bEnable){m_bRenderSky = bEnable;};

        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();

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

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

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

        CSunLight& GetSunLight();
    public:
        void SetActor(CBaseObject * pActor);

        CBaseObject * GetActor();

        virtual void Cleanup();

        virtual void DestroyChildren();

        CCanvasCamera* GetCamera();

        CBaseCamera*    GetCurrentCamera() {return (CBaseCamera*)GetCamera();};

        void CameraZoom(float fAmount);

        void CameraZoomSphere(const CShapeSphere& sphere);

        void CameraSetLookAtPos(float x, float y, float z);
        void CameraGetLookAtPos(float* x, float* y, float* z);

        void CameraSetEyePosByAngle(float fRotY, float fLiftupAngle, float fCameraObjectDist);
        void CameraGetEyePosByAngle(float* fRotY, float* fLiftupAngle, float* fCameraObjectDist);
        void CameraSetEyePos(double x, double y, double z);
        void CameraGetEyePos(double* x, double* y, double* z);

        void CameraRotate(float dx, float dy, float dz);

        void CameraPan(float dx, float dy);

        int PrepareRender(CBaseCamera* pCamera, SceneState* pSceneState);

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

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

        int RenderHeadOnDisplay();

        void Draw(float fDeltaTime);

        void SetMaskTexture(TextureEntity* pTexture);


        const char* GetName();

        void SetName(const char* sName);

        void EnableCamera(bool bEnable);

        bool IsCameraEnabled();
        
        bool IsNeedUpdate();

        CBaseObject* GetObject(const char* name, bool bRecursive = false);

        CBaseObject* GetObject(float x, float y, float z, float fEpsilon = 0.01f);

        int RemoveObject(const char* name, bool bRecursive = false);


        int RemoveObject(CBaseObject* pObj);

        int DestroyObject(const char* name, bool bRecursive = false);

        int DestroyObject(CBaseObject* pObj);

        
        void Reset();

        virtual void AddChild(CBaseObject * pObject);

        SceneState* GetSceneState(){return &m_sceneState;};

        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);

        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 IsUsePointTexture() const;
        void SetUsePointTexture(bool val);
    
        Vector3 GetRenderOrigin();
        

        IBatchedElementDraw* GetBatchedElementDrawer();;

        //
        // following functions are just for post processing effects that are called per render frame move. 
        //


        bool SetEffect(CEffectFile* pEffect);

        void SetRenderPipelineOrder(int nOrder);

        int GetRenderPipelineOrder();

        void SetBackGroundColor(const LinearColor& bgColor);

        LinearColor GetBackGroundColor();
    private:
        typedef std::map<std::string, CBaseObject*> ObjectNameMap_Type;
        ObjectNameMap_Type m_name_map;

        CCanvasCamera* m_pCamera;

        bool m_bUseLocalCamera;

        bool m_bUsePointTexture;

        bool m_bEnabled;

        asset_ptr<TextureEntity> m_pMask;

        CBaseObject *   m_pActor;

        SceneState              m_sceneState;

        Vector3 m_vRenderOrigin;

        bool m_bShowHeadOnDisplay;

        float m_fMaxHeadOnDisplayDistance;

        unordered_ref_array<CSkyMesh*>      m_skymeshes;
        bool                    m_bRenderSky;

        // render fog
        bool                    m_bRenderFog;
        DWORD                   m_dwFogColor;
        LinearColor             m_FogColorFactor;
        FLOAT                   m_fFogStart;
        FLOAT                   m_fFogEnd;
        FLOAT                   m_fFogDensity;

        bool                    m_bEnableLighting;

        bool                    m_bEnableSunLight;

        CSunLight m_SunLight;

        int     m_nRenderPipelineOrder;

        CBatchedElementDraw*            m_pBatchedElementDraw;
    private:
        void Draw_Internal(float fDeltaTime);

    };

}