F:/My Projects/LSEngine/Modules/LSGraphicsLib/Src/DirectX/LSGDirectX10.h

#ifndef __LSG_DIRECTX10_H__
#define __LSG_DIRECTX10_H__

#ifdef LSG_DX10

#include "../Fnd/LSGFndBase.h"
#include "../Fnd/LSGFndConstants.h"
#include "Windows/LSSTDWindows.h"

#include <d3d10.h>
#include <d3dx10.h>

namespace lsg {

        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // CONSTANTS
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        enum LSG_BUFFERS {
                LSG_B_COLOR_BUFFER                                                      = (1UL << 16UL),
                LSG_B_STENCIL_BUFFER                                            = D3D10_CLEAR_STENCIL,
                LSG_B_DEPTH_BUFFER                                                      = D3D10_CLEAR_DEPTH,
                LSG_B_ALL                                                                       = LSG_B_COLOR_BUFFER | LSG_B_STENCIL_BUFFER | LSG_B_DEPTH_BUFFER,
        };



        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // TYPES
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        typedef class CDirectX10ShaderManager                   CShaderManager;
        class CShader;



        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // INTERFACE
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        class CDirectX10 {
        public :
                // == Types.
                typedef struct LSG_DIRECTX10_INIT {
                        HWND                                                                    hWnd;

                        LSBOOL                                                                  bWindowed;
                } * LPLSG_DIRECTX10_INIT, * const LPCLSG_DIRECTX10_INIT;

                // == Functions.
                static LSBOOL LSE_CALL                                          InitDirectX10( LPCLSG_DIRECTX10_INIT _lpdiInit );

                static LSVOID LSE_CALL                                          PostInitDirectX10();

                static LSVOID LSE_CALL                                          DestroyDirectX10();

                static LSVOID LSE_CALL                                          LoseDevice();

                static LSBOOL LSE_CALL                                          ResetDevice();

                static LSVOID LSE_CALL                                          SetInitialValues();

                static LSE_INLINE ID3D10Device * LSE_CALL       GetDirectX10Device();

                static CMatrix4x4 LSE_CALL                                      OffsetOrtho( LSREAL _fLeft, LSREAL _fRight, LSREAL _fBottom, LSREAL _fTop, LSREAL _fNear, LSREAL _fFar );


                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                // INTERFACE
                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                static LSE_INLINE LSVOID LSE_FCALL                      AssertError();

                static LSE_INLINE LSVOID LSE_FCALL                      Present();

                static LSE_INLINE LSVOID LSE_FCALL                      Clear( LSUINT32 _ui32Mask );

                static LSE_INLINE LSVOID LSE_FCALL                      ClearAll();

                static LSVOID LSE_CALL                                          SetClearColor( LSREAL _fR, LSREAL _fG, LSREAL _fB, LSREAL _fA );

                static LSE_INLINE LSVOID LSE_FCALL                      SetClearDepth( LSREAL _fValue );

                static LSE_INLINE LSVOID LSE_FCALL                      SetViewport( LSINT32 _i32X, LSINT32 _i32Y, LSINT32 _i32Width, LSINT32 _i32Height );

                static LSE_INLINE LSVOID LSE_FCALL                      SetDepthTest( LSBOOL _bVal );

                static LSE_INLINE LSVOID LSE_FCALL                      SetDepthFunc( LSG_DEPTH_TEST _dtFunc );

                static LSE_INLINE LSVOID LSE_FCALL                      SetDepthWrite( LSBOOL _bVal );

                static LSE_INLINE LSVOID LSE_FCALL                      SetCulling( LSBOOL _bVal );

                static LSE_INLINE LSVOID LSE_FCALL                      SetCullMode( LSG_CULL_MODES _cmMode );

                static LSE_INLINE LSG_CULL_MODES LSE_CALL       GetCullMode();

                static LSE_INLINE LSVOID LSE_FCALL                      SetBlendEnabled( LSBOOL _bVal );

                static LSE_INLINE LSVOID LSE_FCALL                      SetBlendFunc( LSG_BLEND_MODES _bmSrc, LSG_BLEND_MODES _bmDst );

                static LSE_INLINE LSVOID LSE_FCALL                      SetFillMode( LSG_FILL_MODES _fmMode );

                static LSE_INLINE LSBOOL LSE_FCALL                      BeginRender();

                static LSE_INLINE LSVOID LSE_FCALL                      EndRender();

                static LSE_INLINE CShaderManager * LSE_FCALL
                                                                                                        GetShaderManager();

                static LSVOID LSE_FCALL                                         SetShader( CShader * _psShader );

                static CShader * LSE_FCALL                                      GetShader();

                static LSVOID LSE_CALL                                          PreRender();



                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                // METRICS
                // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
                static LSE_INLINE LSBOOL LSE_CALL                       NonPo2();

                template <typename tnType>
                static LSE_INLINE LSVOID LSE_CALL                       SafeRelease( tnType &_tObj );


                // == Members.
                static const void *                                                     m_pvShaderSignature;

                static SIZE_T                                                           m_stShaderSize;

                static ID3D10ShaderResourceView *                       m_psrvActiveTextures[LSG_MAX_TEXTURE_UNITS];


        protected :
                // == Members.
                static ID3D10Device *                                           m_pdDevice;

                static IDXGISwapChain *                                         m_pscSwapChain;

                static D3D10_DRIVER_TYPE                                        m_dtDriver;

                static ID3D10RenderTargetView *                         m_prtvRenderTarget;

                static ID3D10DepthStencilState *                        m_pdssDepthStencil;

                static ID3D10RasterizerState  *                         m_prsRasterizerState;

                static ID3D10DepthStencilView *                         m_pdsvDepthStencilView;

                static ID3D10BlendState *                                       m_pbsBlendState;

                static ID3D10Texture2D *                                        m_pt2dDepthStencilBuffer;

                static CShaderManager *                                         m_psmShaderMan;

                static ID3D10ShaderResourceView *                       m_psrvLastActiveTextures[LSG_MAX_TEXTURE_UNITS];

                static D3D10_DEPTH_STENCIL_DESC                         m_dsdDepthStencilDesc;

                static D3D10_RASTERIZER_DESC                            m_rdRasterizerDesc;

                static D3D10_BLEND_DESC                                         m_bdBlendDesc;

                static LSUINT32                                                         m_ui32ClearColor;

                static LSFLOAT                                                          m_fDepthClear;

                static D3D10_CULL_MODE                                          m_cmLastCull;


                // == Functions.
                static LSVOID LSE_CALL                                          ResetInternal();

        };


        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // DEFINITIONS
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // == Functions.
        LSE_INLINE ID3D10Device * LSE_CALL CDirectX10::GetDirectX10Device() {
                return m_pdDevice;
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX10::AssertError() {
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX10::Present() {
                m_pscSwapChain->Present( 0UL, 0UL );
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX10::Clear( LSUINT32 _ui32Mask ) {
                if ( _ui32Mask & LSG_B_COLOR_BUFFER ) {
                        // Clearing color.
                        const FLOAT fColor[4] = {
                                (m_ui32ClearColor >> 24) * (1.0f / 255.0f),                             // Red.
                                ((m_ui32ClearColor >> 16) & 0xFF) * (1.0f / 255.0f),    // Green.
                                ((m_ui32ClearColor >> 8) & 0xFF) * (1.0f / 255.0f),             // Blue.
                                (m_ui32ClearColor & 0xFF) * (1.0f / 255.0f),                    // Alpha.
                        };
                        m_pdDevice->ClearRenderTargetView( m_prtvRenderTarget, fColor );
                }
                m_pdDevice->ClearDepthStencilView( m_pdsvDepthStencilView, _ui32Mask & (LSG_B_DEPTH_BUFFER | LSG_B_STENCIL_BUFFER),
                        m_fDepthClear, 0 );
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX10::ClearAll() {
                Clear( LSG_B_ALL );
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX10::SetClearDepth( LSREAL _fValue ) {
                m_fDepthClear = static_cast<LSFLOAT>(_fValue);
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX10::SetViewport( LSINT32 _i32X, LSINT32 _i32Y, LSINT32 _i32Width, LSINT32 _i32Height ) {
                if ( m_pdDevice ) {
                        D3D10_VIEWPORT vpViewPort = {
                                _i32X,
                                _i32Y,
                                _i32Width,
                                _i32Height,
                                D3D10_MIN_DEPTH,
                                D3D10_MAX_DEPTH
                        };
                        m_pdDevice->RSSetViewports( 1UL, &vpViewPort );
                }
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX10::SetDepthTest( LSBOOL _bVal ) {
                _bVal = _bVal != false;
                if ( m_dsdDepthStencilDesc.DepthEnable != _bVal ) {
                        m_dsdDepthStencilDesc.DepthEnable = _bVal;
                        SafeRelease( m_pdssDepthStencil );
                        m_pdDevice->CreateDepthStencilState( &m_dsdDepthStencilDesc, &m_pdssDepthStencil );
                        m_pdDevice->OMSetDepthStencilState( m_pdssDepthStencil, 1UL );
                }
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX10::SetDepthFunc( LSG_DEPTH_TEST _dtFunc ) {
                if ( CFndBase::m_dtDepthTestFunc != _dtFunc ) {
                        CFndBase::m_dtDepthTestFunc = _dtFunc;
                        static const D3D10_COMPARISON_FUNC dcfFuncs[] = {
                                D3D10_COMPARISON_NEVER,                                 // LSG_DT_NEVER
                                D3D10_COMPARISON_ALWAYS,                                // LSG_DT_ALWAYS
                                D3D10_COMPARISON_LESS,                                  // LSG_DT_LESS
                                D3D10_COMPARISON_EQUAL,                                 // LSG_DT_EQUAL
                                D3D10_COMPARISON_NOT_EQUAL,                             // LSG_DT_NOTEQUAL
                                D3D10_COMPARISON_LESS_EQUAL,                    // LSG_DT_LESSEQUAL
                                D3D10_COMPARISON_GREATER,                               // LSG_DT_GREATER
                                D3D10_COMPARISON_GREATER_EQUAL,                 // LSG_DT_GREATEREQUAL
                        };
                        m_dsdDepthStencilDesc.DepthFunc = dcfFuncs[_dtFunc];
                        SafeRelease( m_pdssDepthStencil );
                        m_pdDevice->CreateDepthStencilState( &m_dsdDepthStencilDesc, &m_pdssDepthStencil );
                        m_pdDevice->OMSetDepthStencilState( m_pdssDepthStencil, 1UL );
                }
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX10::SetDepthWrite( LSBOOL _bVal ) {
                _bVal = _bVal != false;
                if ( m_dsdDepthStencilDesc.DepthWriteMask != _bVal ) {
                        m_dsdDepthStencilDesc.DepthWriteMask = static_cast<D3D10_DEPTH_WRITE_MASK>(_bVal);
                        SafeRelease( m_pdssDepthStencil );
                        m_pdDevice->CreateDepthStencilState( &m_dsdDepthStencilDesc, &m_pdssDepthStencil );
                        m_pdDevice->OMSetDepthStencilState( m_pdssDepthStencil, 1UL );
                }
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX10::SetCulling( LSBOOL _bVal ) {
                _bVal = _bVal != false;
                if ( _bVal && m_rdRasterizerDesc.CullMode == D3D10_CULL_NONE ) {
                        // Turning on culling.
                        m_rdRasterizerDesc.CullMode = m_cmLastCull;
                        SafeRelease( m_prsRasterizerState );
                        m_pdDevice->CreateRasterizerState( &m_rdRasterizerDesc, &m_prsRasterizerState );
                        m_pdDevice->RSSetState( m_prsRasterizerState );
                }
                else if ( !_bVal && m_rdRasterizerDesc.CullMode != D3D10_CULL_NONE ) {
                        // Turning off culling.
                        m_cmLastCull = m_rdRasterizerDesc.CullMode;
                        m_rdRasterizerDesc.CullMode = D3D10_CULL_NONE;
                        SafeRelease( m_prsRasterizerState );
                        m_pdDevice->CreateRasterizerState( &m_rdRasterizerDesc, &m_prsRasterizerState );
                        m_pdDevice->RSSetState( m_prsRasterizerState );
                }
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX10::SetCullMode( LSG_CULL_MODES _cmMode ) {
                static const D3D10_CULL_MODE cmModes[] = {
                        D3D10_CULL_FRONT,
                        D3D10_CULL_BACK,
                };
                assert( _cmMode == LSG_CM_CW || _cmMode == LSG_CM_CCW );
                if ( m_rdRasterizerDesc.CullMode == D3D10_CULL_NONE ) {
                        // Just set the last cull mode.
                        m_cmLastCull = cmModes[_cmMode];
                }
                else if ( m_rdRasterizerDesc.CullMode != cmModes[_cmMode] ) {
                        // Culling is on and not equal to the current mode.
                        m_rdRasterizerDesc.CullMode = cmModes[_cmMode];

                        SafeRelease( m_prsRasterizerState );
                        m_pdDevice->CreateRasterizerState( &m_rdRasterizerDesc, &m_prsRasterizerState );
                        m_pdDevice->RSSetState( m_prsRasterizerState );
                }
        }

        LSE_INLINE LSG_CULL_MODES LSE_CALL CDirectX10::GetCullMode() {
                if ( m_rdRasterizerDesc.CullMode == D3D10_CULL_FRONT ) { return LSG_CM_CCW; }
                return LSG_CM_CW;
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX10::SetBlendEnabled( LSBOOL _bVal ) {
                _bVal = (_bVal != false);
                if ( _bVal != m_bdBlendDesc.BlendEnable[0] ) {
                        m_bdBlendDesc.BlendEnable[0] = _bVal;

                        SafeRelease( m_pbsBlendState );
                        m_pdDevice->CreateBlendState( &m_bdBlendDesc, &m_pbsBlendState );
                        m_pdDevice->OMSetBlendState( m_pbsBlendState, 0, 0xFFFFFFFF );
                }
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX10::SetBlendFunc( LSG_BLEND_MODES _bmSrc, LSG_BLEND_MODES _bmDst ) {
                static const D3D10_BLEND bModes[] = {
                        D3D10_BLEND_ZERO,                                               // LSG_BM_ZERO
                        D3D10_BLEND_ONE,                                                // LSG_BM_ONE
                        D3D10_BLEND_SRC_COLOR,                                  // LSG_BM_SRC_COLOR
                        D3D10_BLEND_INV_SRC_COLOR,                              // LSG_BM_INV_SRC_COLOR
                        D3D10_BLEND_DEST_COLOR,                                 // LSG_BM_DST_COLOR
                        D3D10_BLEND_INV_DEST_COLOR,                             // LSG_BM_INV_DST_COLOR
                        D3D10_BLEND_SRC_ALPHA,                                  // LSG_BM_SRC_ALPHA
                        D3D10_BLEND_INV_SRC_ALPHA,                              // LSG_BM_INV_SRC_ALPHA
                        D3D10_BLEND_DEST_ALPHA,                                 // LSG_BM_DST_ALPHA
                        D3D10_BLEND_INV_DEST_ALPHA,                             // LSG_BM_INV_DEST_ALPHA
                        D3D10_BLEND_SRC_ALPHA_SAT,                              // LSG_BM_SRC_ALPHA_SAT
                };
                if ( m_bdBlendDesc.SrcBlend != bModes[_bmSrc] || m_bdBlendDesc.DestBlend != bModes[_bmDst] ) {
                        m_bdBlendDesc.SrcBlend = bModes[_bmSrc];
                        m_bdBlendDesc.DestBlend = bModes[_bmDst];

                        SafeRelease( m_pbsBlendState );
                        m_pdDevice->CreateBlendState( &m_bdBlendDesc, &m_pbsBlendState );
                        m_pdDevice->OMSetBlendState( m_pbsBlendState, 0, 0xFFFFFFFF );
                }
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX10::SetFillMode( LSG_FILL_MODES _fmMode ) {
                static const D3D10_FILL_MODE fmValue[] = {
                        D3D10_FILL_SOLID,
                        D3D10_FILL_WIREFRAME,
                };
                if ( m_rdRasterizerDesc.FillMode != fmValue[_fmMode] ) {
                        m_rdRasterizerDesc.FillMode = fmValue[_fmMode];

                        SafeRelease( m_prsRasterizerState );
                        m_pdDevice->CreateRasterizerState( &m_rdRasterizerDesc, &m_prsRasterizerState );
                        m_pdDevice->RSSetState( m_prsRasterizerState );
                }
        }

        LSE_INLINE LSBOOL LSE_FCALL CDirectX10::BeginRender() {
                return true;
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX10::EndRender() {
        }

        LSE_INLINE CShaderManager * LSE_FCALL CDirectX10::GetShaderManager() {
                return m_psmShaderMan;
        }

        LSE_INLINE LSBOOL LSE_CALL CDirectX10::NonPo2() {
                return true;
        }

        template <typename tnType>
        LSE_INLINE LSVOID LSE_CALL CDirectX10::SafeRelease( tnType &_tObj ) {
                if ( _tObj ) {
                        _tObj->Release();
                        _tObj = NULL;
                }
        }

}       // namespace lsg

#endif  // #ifdef LSG_DX10

#endif  // __LSG_DIRECTX10_H__