F:/My Projects/LSEngine/Modules/LSGraphicsLib/Src/Sprites/LSGSprite.h

#ifndef __LSG_SPRITE_H__
#define __LSG_SPRITE_H__

#include "../LSGGraphicsLib.h"
#include "../ShaderLanguage/LSGShader.h"
#include "../Texture/LSGStandardTexture.h"
#include "../Texture/LSGTextureManager.h"
#include "../VertexBuffer/LSGVertexBuffer.h"
#include "Matrix/LSMMatrix4x4.h"
#include "Vector/LSMVector2.h"

namespace lsg {

        class CSprite {
        public :
                // == Various constructors.
                LSE_CALLCTOR                                                                    CSprite();


                // == Types.
                typedef struct LSG_CELL {
                        LSREAL                                                                          fStartX;

                        LSREAL                                                                          fStartY;

                        LSREAL                                                                          fWidth;

                        LSREAL                                                                          fHeight;

                        LSREAL                                                                          fCenterX;

                        LSREAL                                                                          fCenterY;
                } * LPLSG_CELL, * const LPCLSG_CELL;

                typedef LSVOID (LSE_CALL *                                              PfCellResizeCallback)( LSVOID * _pvParm );


                // == Functions.
                LSE_INLINE const CStandardTexture * LSE_CALL    GetTexture() const;

                LSE_INLINE LSVOID LSE_CALL                                              SetTexture( CSharedStdTexPtr _sstpTexture );

                LSE_INLINE LSBOOL LSE_CALL                                              SetTexture( const LSCHAR * _pcPath );

                LSE_INLINE LSBOOL LSE_CALL                                              SetTexture( const LSCHAR * _pcPath, const LSG_TEX_PARMS &_tpParms );

                LSE_INLINE LSVOID LSE_CALL                                              SetShader( const CSharedShaderPtr * _psspShader );

                LSBOOL LSE_CALL                                                                 DrawAtImm( const CVector2 &_vPos, LSREAL _fRot = LSM_ZERO,
                        const CVector2 &_vScale = CVector2( LSM_ONE, LSM_ONE ), LSREAL _fAlpha = LSM_ONE ) const;

                LSBOOL LSE_CALL                                                                 DrawAtImm( const CVector2 &_vPos, const CMatrix2x2 &_mRotScale, LSREAL _fAlpha = LSM_ONE ) const;

                LSVOID LSE_CALL                                                                 SetCellCenter( LSREAL _fX, LSREAL _fY );

                LSVOID LSE_CALL                                                                 SetCellCenterNorm( LSREAL _fX, LSREAL _fY );

                LSVOID LSE_CALL                                                                 SetCell( const CVector2 &_vUpperLeft, const CVector2 &_vSize,
                        const CVector2 &_vCenter );

                LSE_INLINE LSVOID LSE_CALL                                              SetCell( const LSG_CELL &_cCell );

                LSE_INLINE const CVector2 & LSE_CALL                    CellSize() const;

                LSE_INLINE const CVector2 & LSE_CALL                    CellScale() const;

                LSE_INLINE CVector2 LSE_CALL                                    CellCenterNegated() const;

                LSVOID LSE_CALL                                                                 SetCallbackFunction( PfCellResizeCallback _pcrcCallback, LSVOID * _pvParm );

                static LSVOID LSE_CALL                                                  ShutDownSprites();


                // == Members.
                static CTextureManager                                                  m_tmTexMan;

        protected :
                // == Members.
                mutable CSharedStdTexPtr                                                m_sstpTexture;

                mutable CSharedShaderPtr                                                m_sspShader;

                PfCellResizeCallback                                                    m_pcrcCellResizeCallback;

                LSVOID *                                                                                m_pvCallbackParm;

                CVector3                                                                                m_vPos;

                CVector2                                                                                m_vScale;

                LSREAL                                                                                  m_fRot;

                LSREAL                                                                                  m_fAlpha;

                CVector2                                                                                m_vCellSize;

                CVector2                                                                                m_vInvTexSize;

                CVector2                                                                                m_vUvStart;

                CVector2                                                                                m_vUvEnd;

                CMatrix4x4                                                                              m_mLocalTrans;

                static CVertexBuffer *                                                  m_pvbImmVertBuf;

                static CSharedShaderPtr                                                 m_sspDefaultShader;

                static CShader::LSG_HANDLE                                              m_hDefaultAlpha;


                // == Functions.
                static LSVOID LSE_CALL                                                  UpdateTrans( const CVector3 &_vPos, LSREAL _fRot, const CVector2 &_vScale,
                        CMatrix4x4 &_mRet );

                static CShader * LSE_CALL                                               GetDefShader();

                static CVertexBuffer * LSE_CALL                                 GetImmVertBuffer();
        };


        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // DEFINITIONS
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // == Types.
        typedef CSharedPtr<CSprite>                                                     CSharedSpritePtr;

        // == Functions.
        LSE_INLINE const CStandardTexture * LSE_CALL CSprite::GetTexture() const {
                return m_sstpTexture.Get();
        }

        LSE_INLINE LSVOID LSE_CALL CSprite::SetTexture( CSharedStdTexPtr _sstpTexture ) {
                m_sstpTexture = _sstpTexture;
                if ( m_sstpTexture.Valid() ) {
                        m_vCellSize.x = static_cast<LSREAL>(m_sstpTexture->GetWidth());
                        m_vCellSize.y = static_cast<LSREAL>(m_sstpTexture->GetHeight());

                        m_vInvTexSize = CVector2( LSM_ONE / m_vCellSize.x, LSM_ONE / m_vCellSize.y );
                }
                else {
                        m_vCellSize.x = m_vCellSize.y = m_vInvTexSize.x = m_vInvTexSize.y = LSM_ZERO;
                }
                m_vUvStart = CVector2( LSM_ZERO, LSM_ZERO );
                m_vUvEnd = CVector2( LSM_ONE, LSM_ONE );
                if ( m_pcrcCellResizeCallback ) {
                        m_pcrcCellResizeCallback( m_pvCallbackParm );
                }
        }

        LSE_INLINE LSBOOL LSE_CALL CSprite::SetTexture( const LSCHAR * _pcPath ) {
                return SetTexture( _pcPath, CTextureBase::m_tpSpritePreset );
        }

        LSE_INLINE LSBOOL LSE_CALL CSprite::SetTexture( const LSCHAR * _pcPath, const LSG_TEX_PARMS &_tpParms ) {
                CSharedStdTexPtr sstpThis = m_tmTexMan.CreateSharedTexFromFile( _pcPath, _tpParms );
                if ( !sstpThis.Valid() ) { return false; }
                if ( !sstpThis->Finalized() ) { sstpThis->Finalize(); }
                SetTexture( sstpThis );
                return true;
        }

        LSE_INLINE LSVOID LSE_CALL CSprite::SetShader( const CSharedShaderPtr * _psspShader ) {
                if ( _psspShader ) {
                        m_sspShader = (*_psspShader);
                }
                else {
                        m_sspShader.Reset();
                }
        }

        LSE_INLINE LSVOID LSE_CALL CSprite::SetCell( const LSG_CELL &_cCell ) {
                SetCell( CVector2( _cCell.fStartX, _cCell.fStartY ), CVector2( _cCell.fWidth, _cCell.fHeight ),
                        CVector2( _cCell.fCenterX, _cCell.fCenterY ) );
        }

        LSE_INLINE const CVector2 & LSE_CALL CSprite::CellSize() const {
                return m_vCellSize;
        }

        LSE_INLINE const CVector2 & LSE_CALL CSprite::CellScale() const {
                return m_vScale;
        }

        LSE_INLINE CVector2 LSE_CALL CSprite::CellCenterNegated() const {
                return CVector2( m_vPos.x, m_vPos.y );
        }

}       // namespace lsg

#endif  // __LSG_SPRITE_H__