cDXSprite.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cDXSprite_H
#define _INC_cDXSprite_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cDXBase.h"
#include "GrayLib/include/Image/cColorRef.h"
#include "GrayLib/include/Image/cSpriteMap.h"
 
#ifdef USE_DXX
#include "GrayLib/include/Math/cValueRange.h"
#include "GrayLib/include/Math/cVector.h"
#include "GrayLib/include/Math/cMatrix.h"
#include "GrayLib/include/Geometry/cRectI.h"
#include "GrayCore/include/cString.h"
 
namespace Gray3D
{
        class cDXTextureBase;
 
        class GRAY3D_LINK cDXSpriteElem
        {
 
                friend class cDXSpriteDC;
 
        public:
                cIUnkPtr<ID3DTexture> m_pDXTexture;     
                cRectI m_ElemRect;                      
 
        private:
                cColorDX m_Color;               
 
                cVector2f m_vScaling;   
 
                cVector2f m_vRotationCenter;
                RADIANf_t m_Rotation;   
 
        protected:
                HRESULT UpdateTexureSize();
 
        public:
                cDXSpriteElem(ID3DTexture* pTex = nullptr);
                cDXSpriteElem(const cDXSpriteElem& Sprite);
                ~cDXSpriteElem(void);
 
                bool SetCopyElem(const cDXSpriteElem& src);
 
                bool isTextureSet() const
                {
                        if (m_pDXTexture == nullptr)
                                return false;
                        return true;
                }
                ID3DTexture* get_Texture() const
                {
                        return m_pDXTexture;
                }
                HRESULT put_Texture(ID3DTexture* pDXTexture);
 
                virtual cRectI get_ElemRect(void) const
                {
                        return m_ElemRect;
                }
                void put_ElemRect(const cRectI& ElemRect)
                {
                        m_ElemRect = ElemRect;
                }
                PIXELS_t get_ElemWidth(void) const
                {
                        return m_ElemRect.Width() ;
                }
                PIXELS_t get_ElemHeight(void) const
                {
                        return m_ElemRect.Height() ;
                }
 
                D3DCOLOR get_SpriteColor(void) const
                {
                        return m_Color;
                }
                D3DCOLOR put_SpriteColor(D3DCOLOR color);
                void put_ObjectColor(D3DCOLOR Hue, COLOR_ELEM_t HuePercent);
                COLOR_ELEM_t get_Alpha() const noexcept
                {
                        return m_Color.get_A() ;
                }
                void put_Alpha(COLOR_ELEM_t bVal)
                {
                        m_Color.put_A(bVal);
                }
 
                const cVector2f& get_Scaling(void) const
                {
                        return m_vScaling;
                }
                void put_Scaling(const cVector2f& vScaling)
                {
                        m_vScaling = vScaling;
                }
                void SetScalingDest(PIXELS_t cx, PIXELS_t cy);
 
                cVector2f get_RotationCenter(void) const
                {
                        return m_vRotationCenter;
                }
                void put_RotationCenter(cVector2f vRotationCenter)
                {
                        m_vRotationCenter = vRotationCenter;
                }
                RADIANf_t get_Rotation(void) const
                {
                        return m_Rotation;
                }
                void put_Rotation(RADIANf_t Rotation)
                {
                        m_Rotation = Rotation;
                }
        };
 
        class GRAY3D_LINK cDXSpriteDC : public cDXBaseT<ID3DXSprite>
        {
 
                typedef cDXBaseT<ID3DXSprite> SUPER_t;
 
        private:
                bool m_bDrawOpen;
                DWORD m_dwDrawOpenFlags;
 
        public:
                // DECLARE_HEAP_ALIGNED_ALLOC(cDXSpriteDC);
                cDXSpriteDC();
                ~cDXSpriteDC();
 
                ID3DXSprite* get_Sprite() const
                {
                        return m_pDXObj;
                }
 
                HRESULT MakeTransform(const cPoint2i& ptDst, const cDXSpriteElem& SpriteElem);
 
                HRESULT DrawBegin(DWORD dwFlags);
                HRESULT DrawBeginText();
                HRESULT DrawElem(const cPoint2i& ptDst, const cDXSpriteElem& SpriteElem);
                HRESULT DrawEnd();
                HRESULT DrawEndBatch(); // end the current batch!
 
                // Begin, Draw, End in one function.
                HRESULT DrawFull(const cPoint2i& ptDst, const cDXSpriteElem& SpriteElem);
 
                HRESULT InitDeviceObjects(cDXDevice* pDXDev);
                virtual HRESULT OnLostDeviceX(void)
                {
                        ASSERT(!m_bDrawOpen);
                        return SUPER_t::OnLostDeviceX();
                }
        };
 
        class GRAY3D_LINK cDXSpriteDrawBatch
        {
        };
        class GRAY3D_LINK cDXSpriteDraw
        {
        };
}
 
#endif // USE_DXX
#endif // _INC_cDXSprite_H