RenderTarget.h

#pragma once
#include "BaseObject.h"
#include "PaintEngine/PaintDevice.h"

namespace ParaEngine
{
    struct TextureEntity;
    class ImageEntity;
    class CPaintEngine;
    class CPainter;

    class CRenderTarget : public CBaseObject, public CPaintDevice
    {
    public:
        CRenderTarget();
        virtual ~CRenderTarget();

        ATTRIBUTE_DEFINE_CLASS(CRenderTarget);
        ATTRIBUTE_SUPPORT_CREATE_FACTORY(CRenderTarget);

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

        ATTRIBUTE_METHOD1(CRenderTarget, GetClearColor_s, Vector3*)     { *p1 = cls->GetClearColor().ToVector3(); return S_OK; }
        ATTRIBUTE_METHOD1(CRenderTarget, SetClearColor_s, Vector3)      { LinearColor c(p1.x, p1.y, p1.z, 1); cls->SetClearColor(c); return S_OK; }

        ATTRIBUTE_METHOD1(CRenderTarget, GetRenderTargetSize_s, Vector2*)       { *p1 = cls->GetRenderTargetSize(); return S_OK; }
        ATTRIBUTE_METHOD1(CRenderTarget, SetRenderTargetSize_s, Vector2)        { cls->SetRenderTargetSize(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CRenderTarget, IsActiveRenderingEnabled_s, bool*)     { *p1 = cls->IsActiveRenderingEnabled(); return S_OK; }
        ATTRIBUTE_METHOD1(CRenderTarget, EnableActiveRendering_s, bool)     { cls->EnableActiveRendering(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CRenderTarget, IsDirty_s, bool*)      { *p1 = cls->IsDirty(); return S_OK; }
        ATTRIBUTE_METHOD1(CRenderTarget, SetDirty_s, bool)      { cls->SetDirty(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CRenderTarget, IsPersistentRenderTarget_s, bool*)     { *p1 = cls->IsPersistentRenderTarget(); return S_OK; }
        ATTRIBUTE_METHOD1(CRenderTarget, SetPersistentRenderTarget_s, bool)     { cls->SetPersistentRenderTarget(p1); return S_OK; }

        DEFINE_SCRIPT_EVENT(CRenderTarget, Paint);

        
    public:
        virtual CPaintEngine * paintEngine() const;
        virtual int metric(PaintDeviceMetric metric) const;

        bool InitWithWidthAndHeight(int width, int height, D3DFORMAT format = D3DFMT_A8R8G8B8, D3DFORMAT depthStencilFormat = D3DFMT_D16);

        virtual int PrepareRender(CBaseCamera* pCamera, SceneState* pSceneState);
        virtual HRESULT Draw(SceneState * sceneState);

        virtual bool Begin();

        void CheckInit();

        virtual void End();

        virtual void Clear(const LinearColor& color, float depthValue = 1.f, int stencilValue = 0, DWORD flags = D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER);

        void EnableActiveRendering(bool bEnable);

        bool IsActiveRenderingEnabled() const;

        HRESULT InitDeviceObjects();
        HRESULT RestoreDeviceObjects();
        HRESULT InvalidateDeviceObjects();
        HRESULT DeleteDeviceObjects();
        virtual void Cleanup();
        virtual void DoPaint(CPainter* painter = NULL);

        void SetClearColor(const LinearColor& bgColor);
        LinearColor GetClearColor();

        bool IsPersistentRenderTarget() const;
        void SetPersistentRenderTarget(bool val);

        virtual TextureEntity* GetTexture();
        virtual AssetEntity* GetPrimaryAsset();

        HRESULT SaveToFile(const char* filename, int width = 0, int height = 0, DWORD dwFormat = 3, UINT MipLevels = 0, int srcLeft = 0, int srcTop = 0, int srcWidth = 0, int srcHeight = 0);

        /* creates a new Image from with the texture's data.
        Caller is responsible for releasing it by calling delete.
        * @param colorKey: if 0 no color key is used. for black color key use 0xff000000
        */
        ImageEntity* NewImage(bool bFlipImage = true, Color colorKey = 0);

        void SetRenderTargetSize(int nWidth, int nHeight);
        void GetRenderTargetSize(int* nWidth, int* nHeight);
        void SetRenderTargetSize(const Vector2& size);
        Vector2 GetRenderTargetSize();

        int GetTextureWidth() const { return m_nTextureWidth; }
        int GetTextureHeight() const { return m_nTextureHeight; }

        bool IsDirty() const;
        void SetDirty(bool val);

        int GetLifeTime() const;
        void SetLifeTime(int val);

        virtual bool IsDead();
        virtual void SetDead();

        const std::string& GetCanvasTextureName();
        void SetCanvasTextureName(const std::string& sValue);
    protected:
        // whether device is created.
        bool        m_bInitialized;
        
        bool        m_bPersistentRenderTarget;
        int         m_nTextureWidth;
        int         m_nTextureHeight;
        /* -1 means alive forever. 0 means dead. any other value means number of frames to live before it is released. */
        int m_nLifeTime;
        
        DWORD       m_depthStencilFormat;
        asset_ptr<TextureEntity> m_pCanvasTexture;
#ifdef USE_DIRECTX_RENDERER
        LPDIRECT3DSURFACE9      m_pCanvasSurface;
        LPDIRECT3DSURFACE9      m_pDepthStencilSurface;

        LPDIRECT3DSURFACE9 m_pOldRenderTarget;
        LPDIRECT3DSURFACE9 m_pOldZBuffer;
#elif defined USE_OPENGL_RENDERER
        GLuint       _FBO;
        GLuint       _depthRenderBufffer;
        GLint        _oldFBO;
        GLint        _oldRBO;
#endif
        D3DVIEWPORT9 m_oldViewport;
        Vector3 m_vOldRenderOrigin;

        DWORD m_dwClearColor;

        /* whether we are currently inside begin() end() function pair. */
        bool m_bIsBegin;

        bool m_bActiveRendering;
        bool m_bIsDirty;
        std::string m_sCanvasTextureName;

        mutable CPaintEngine *engine;
    };

    class ScopedPaintOnRenderTarget
    {
    public:
        ScopedPaintOnRenderTarget(CRenderTarget* pRendertarget) :m_pRenderTarget(pRendertarget){
            if (m_pRenderTarget)
                m_pRenderTarget->Begin();
        }
        ~ScopedPaintOnRenderTarget(){
            if (m_pRenderTarget)
                m_pRenderTarget->End();
        };
    public:
        CRenderTarget* m_pRenderTarget;
    };
}