BufferPicking.h

#pragma once
#include "math/ParaRect.h"
#include "AssetEntity.h"
#include "IObjectScriptingInterface.h"

namespace ParaEngine
{
    class CRenderTarget;

    struct CBufferPicking : public AssetEntity
    {
    public:
        explicit CBufferPicking(const AssetKey& key);
        virtual ~CBufferPicking();

        ATTRIBUTE_DEFINE_CLASS(CBufferPicking);

        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(CBufferPicking, GetPickingCount_s, int*)  { *p1 = cls->GetPickingCount(); return S_OK; }
        ATTRIBUTE_METHOD1(CBufferPicking, GetPickingID_s, DWORD*)   { *p1 = cls->GetPickingID(-1); return S_OK; }
        ATTRIBUTE_METHOD1(CBufferPicking, FetchPickingResult_s, void**) { cls->FetchPickingResult((DWORD **)p1); return S_OK; }
        ATTRIBUTE_METHOD(CBufferPicking, ClearPickingResult_s)  { cls->ClearPickingResult(); return S_OK; }
        ATTRIBUTE_METHOD(CBufferPicking, CheckDoPick_s) { cls->CheckDoPick(); return S_OK; }
        
        ATTRIBUTE_METHOD1(CBufferPicking, GetPickLeftTop_s, Vector2*)   { *p1 = cls->GetPickLeftTop(); return S_OK; }
        ATTRIBUTE_METHOD1(CBufferPicking, SetPickLeftTop_s, Vector2)    { cls->SetPickLeftTop(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBufferPicking, GetPickWidthHeight_s, Vector2*)   { *p1 = cls->GetPickWidthHeight(); return S_OK; }
        ATTRIBUTE_METHOD1(CBufferPicking, SetPickWidthHeight_s, Vector2)    { cls->SetPickWidthHeight(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBufferPicking, IsResultDirty_s, bool*)   { *p1 = cls->IsResultDirty(); return S_OK; }
        ATTRIBUTE_METHOD1(CBufferPicking, SetResultDirty_s, bool)   { cls->SetResultDirty(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBufferPicking, GetPickIndex_s, int*) { *p1 = cls->GetPickIndex(); return S_OK; }
        ATTRIBUTE_METHOD1(CBufferPicking, SetPickIndex_s, int)  { cls->SetPickIndex(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBufferPicking, GetViewport_s, int*)  { *p1 = cls->GetViewport(); return S_OK; }
        ATTRIBUTE_METHOD1(CBufferPicking, SetViewport_s, int)   { cls->SetViewport(p1); return S_OK; }

    public:
        virtual HRESULT InitDeviceObjects();
        virtual HRESULT DeleteDeviceObjects();

        DWORD Pick(int nX, int nY, int nViewportId = -1);
        
        int Pick(const QRect& region, int nViewportId = -1);

        const vector<DWORD>& GetPickingResult() { return m_pickingResult; };

        int GetPickingCount();

        DWORD GetPickingID(int nIndex = 0);

        void FetchPickingResult(DWORD ** ppResult);

        void ClearPickingResult();

        void SetPickLeftTop(const Vector2& vPos);
        const Vector2& GetPickLeftTop();
        void SetPickWidthHeight(const Vector2& vPos);
        const Vector2& GetPickWidthHeight();

        int GetPickIndex() const;
        void SetPickIndex(int val);

        bool IsResultDirty() const;
        void SetResultDirty(bool bDirty=true);

        /* in which viewport to pick. default to -1, which is the default one. */
        int GetViewport() const;
        /* in which viewport to pick. default to -1, which is the default one. */
        void SetViewport(int val);

        void CheckDoPick(bool bForceUpdate = false);
    protected:
        bool BeginBuffer();

        void DrawObjects();

        void EndBuffer();
        virtual CRenderTarget* CreateGetRenderTarget(bool bCreateIfNotExist = true);

    private:
        vector <DWORD> m_pickingResult;
        QRect m_pickRect;
        bool m_bResultDirty;
        
        int m_currentPickIndex;
    
        Vector2 m_cache_left_top;
        Vector2 m_cache_width_height;
        int m_nViewport;
        
        WeakPtr m_renderTarget;
    };

    class BufferPickingManager : public AssetManager <CBufferPicking>
    {
    public:
        BufferPickingManager(){};
        static BufferPickingManager& GetInstance();
    public:
        void SetResultDirty();
    };
}