cXSpriteMgr.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cXSpriteMgr_H
#define _INC_cXSpriteMgr_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayGUI.h"
#include "Gray3D/include/Texture/cXSpritePage.h"
 
#ifdef USE_DX
#include "GrayLib/include/Geometry/cRectI.h"
#include "GrayLib/include/Math/cValueRange.h"
#include "GrayLib/include/Image/cSpriteMap.h"
#include "GrayCore/include/cArray.h"
#include "GrayCore/include/cUnitTestDecl.h"
 
namespace Gray3D
{
        class cDXSpriteElem;
}
 
namespace GrayGUI
{
 
        class GRAY3D_LINK cXSpriteMap : public cXTextureFile, public cSpriteMap
        {
 
        public:
                cXSpriteMap(const FILECHAR_t* pszFilePath);
                virtual ~cXSpriteMap();
 
                void ClearMap()
                {
                        DeleteDeviceObjects();
                        cSpriteMap::ClearMap();
                }
 
                virtual HRESULT put_TextureName(cStringF sFileName) override;
 
                virtual HRESULT LoadResource();
 
                HRESULT GetSpriteElem(ELEM_t nElem, OUT cDXSpriteElem& elem);
        };
 
        typedef cRefPtr<cXSpriteMap> cXSpriteMapPtr;
 
        enum SPRITEMAP_t;                                       
        static const SPRITEMAP_t SPRITEMAP_INVALID = (SPRITEMAP_t)0xFFFF;       
        typedef WORD SPRITEID_t;                                        
        static const SPRITEID_t SPRITEID_0 = 0;         
 
        class cXSpriteId
        {
        public:
                typedef int ELEM_t;             
 
        protected:
                SPRITEID_t m_nSpriteId;
 
        public:
                cXSpriteId(SPRITEID_t nSpriteId = SPRITEID_0)
                        : m_nSpriteId(nSpriteId)
                {
                }
                cXSpriteId(SPRITEMAP_t eMap, ELEM_t nElem)
                        : m_nSpriteId(GetId(eMap, nElem))
                {
                }
                bool isValidId() const noexcept
                {
                        return m_nSpriteId != SPRITEID_0;
                }
                static inline SPRITEID_t GetId(SPRITEMAP_t eMap, ELEM_t nElem)
                {
                        return (((SPRITEID_t)eMap) << 10) | (nElem & 0x3ff);
                }
                SPRITEID_t get_Id() const
                {
                        return m_nSpriteId;
                }
                void put_Id(SPRITEID_t id)
                {
                        m_nSpriteId = id;
                }
                static inline SPRITEMAP_t GetMap(SPRITEID_t nSpriteId)
                {
                        return (SPRITEMAP_t)(nSpriteId >> 10);
                }
                SPRITEMAP_t get_Map() const
                {
                        return GetMap(m_nSpriteId);
                }
                void put_Map(SPRITEMAP_t eMap)
                {
                        m_nSpriteId = GetId(eMap, get_Elem());
                }
                static inline ELEM_t GetElem(SPRITEID_t nSpriteId)
                {
                        return (ELEM_t)(nSpriteId & 0x3ff);
                }
                ELEM_t get_Elem() const
                {
                        return GetElem(m_nSpriteId);
                }
                void put_Elem(ELEM_t nElem)
                {
                        m_nSpriteId = GetId(get_Map(), nElem);
                }
        };
 
        class GRAY3D_LINK cXSpriteAnim : public cXSpriteId
        {
 
        public:
                cXSpriteAnim(SPRITEMAP_t eSheet = SPRITEMAP_INVALID, ELEM_t iElemBegin = 0, ELEM_t iElemEnd = 0, TIMESYSD_t timeElemRateMS = 0, bool bLoop = true);
                ~cXSpriteAnim();
 
                void SetAnimation(SPRITEMAP_t eSheet, ELEM_t iElemBegin, ELEM_t iElemEnd, TIMESYSD_t timeElemRateMS, bool bLoop = true);
 
                void put_CurrentElem(ELEM_t nElem)
                {
                        Calc::ClampRef(nElem, m_ElemRange.get_Min(), m_ElemRange.get_Max() + 1);
                        m_nSpriteId = GetId(get_Map(), nElem);
                        m_timeLastElem.InitTimeNow();
                }
 
                void UpdateElemTime();
 
        public:
                cValueRange<ELEM_t> m_ElemRange;        
                TIMESYSD_t m_timeElemRate;                      
                bool m_bLoop;                                           
                cTimeSys m_timeLastElem;                        
        };
 
        struct GRAY3D_LINK cXSpriteMgr // cSingleton
        {
                // Manage the sprint maps for the app. enum SPRITEMAP_t
                HRESULT SetSpriteMap(SPRITEMAP_t eSheet, const FILECHAR_t* pszFileName);
                cRefPtr<cXSpriteMap> GetSpriteMap(SPRITEMAP_t eSheet) const;
                HRESULT GetSpriteElem(SPRITEID_t nSpriteId, OUT cDXSpriteElem& elem) const;
                cArrayRef<cXSpriteMap> m_aSpriteMaps;   
        };
 
}
#endif
#endif