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

#ifndef __LSG_DIRECTX11_H__
#define __LSG_DIRECTX11_H__

#ifdef LSG_DX11

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

#include <d3d11.h>
#include <d3dx11.h>

namespace lsg {

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



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



        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // INTERFACE
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        class CDirectX11 {
        public :
                // == Types.
                typedef struct LSG_DIRECTX11_INIT {
                        HWND                                                                    hWnd;

                        LSBOOL                                                                  bWindowed;
                } * LPLSG_DIRECTX11_INIT, * const LPCLSG_DIRECTX11_INIT;

                typedef struct LSG_VECTOR4 {
                        FLOAT                                                                   x;

                        FLOAT                                                                   y;

                        FLOAT                                                                   z;

                        FLOAT                                                                   w;
                } * LPLSG_VECTOR4, * const LPCLSG_VECTOR4;

                typedef struct LSG_MATRIX {
                        FLOAT                                                                   _11, _12, _13, _14;

                        FLOAT                                                                   _21, _22, _23, _24;

                        FLOAT                                                                   _31, _32, _33, _34;

                        FLOAT                                                                   _41, _42, _43, _44;
                } * LPLSG_MATRIX, * const LPCLSG_MATRIX;


                // == Functions.
                static LSBOOL LSE_CALL                                          InitDirectX11( LPCLSG_DIRECTX11_INIT _lpdiInit );

                static LSVOID LSE_CALL                                          PostInitDirectX11();

                static LSVOID LSE_CALL                                          DestroyDirectX11();

                static LSVOID LSE_CALL                                          LoseDevice();

                static LSBOOL LSE_CALL                                          ResetDevice();

                static LSVOID LSE_CALL                                          SetInitialValues();

                static LSE_INLINE ID3D11Device * LSE_CALL       GetDirectX11Device();

                static LSE_INLINE ID3D11DeviceContext * LSE_CALL
                                                                                                        GetDirectX11Context();

                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 ID3D11ShaderResourceView *                       m_psrvActiveTextures[LSG_MAX_TEXTURE_UNITS];


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

                static ID3D11DeviceContext *                            m_pdcContext;

                static IDXGISwapChain *                                         m_pscSwapChain;

                static D3D_DRIVER_TYPE                                          m_dtDriver;

                static ID3D11RenderTargetView *                         m_prtvRenderTarget;

                static ID3D11DepthStencilState *                        m_pdssDepthStencil;

                static ID3D11RasterizerState  *                         m_prsRasterizerState;

                static ID3D11DepthStencilView *                         m_pdsvDepthStencilView;

                static ID3D11BlendState *                                       m_pbsBlendState;

                static ID3D11Texture2D *                                        m_pt2dDepthStencilBuffer;

                static CShaderManager *                                         m_psmShaderMan;

                static ID3D11ShaderResourceView *                       m_psrvLastActiveTextures[LSG_MAX_TEXTURE_UNITS];

                static D3D11_DEPTH_STENCIL_DESC                         m_dsdDepthStencilDesc;

                static D3D11_RASTERIZER_DESC                            m_rdRasterizerDesc;

                static D3D11_BLEND_DESC                                         m_bdBlendDesc;

                static LSUINT32                                                         m_ui32ClearColor;

                static LSFLOAT                                                          m_fDepthClear;

                static D3D11_CULL_MODE                                          m_cmLastCull;


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


        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // DEFINITIONS
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // == Functions.
        LSE_INLINE ID3D11Device * LSE_CALL CDirectX11::GetDirectX11Device() {
                return m_pdDevice;
        }

        LSE_INLINE ID3D11DeviceContext * LSE_CALL CDirectX11::GetDirectX11Context() {
                return m_pdcContext;
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX11::AssertError() {
        }

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

        LSE_INLINE LSVOID LSE_FCALL CDirectX11::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_pdcContext->ClearRenderTargetView( m_prtvRenderTarget, fColor );
                }
                m_pdcContext->ClearDepthStencilView( m_pdsvDepthStencilView, _ui32Mask & (LSG_B_DEPTH_BUFFER | LSG_B_STENCIL_BUFFER),
                        m_fDepthClear, 0 );
        }

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

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

        LSE_INLINE LSVOID LSE_FCALL CDirectX11::SetViewport( LSINT32 _i32X, LSINT32 _i32Y, LSINT32 _i32Width, LSINT32 _i32Height ) {
                if ( m_pdDevice ) {
                        D3D11_VIEWPORT vpViewPort = {
                                static_cast<FLOAT>(_i32X),
                                static_cast<FLOAT>(_i32Y),
                                static_cast<FLOAT>(_i32Width),
                                static_cast<FLOAT>(_i32Height),
                                D3D11_MIN_DEPTH,
                                D3D11_MAX_DEPTH
                        };
                        m_pdcContext->RSSetViewports( 1UL, &vpViewPort );
                }
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX11::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_pdcContext->OMSetDepthStencilState( m_pdssDepthStencil, 1UL );
                }
        }

        LSE_INLINE LSVOID LSE_FCALL CDirectX11::SetDepthFunc( LSG_DEPTH_TEST _dtFunc ) {
                if ( CFndBase::m_dtDepthTestFunc != _dtFunc ) {
                        CFndBase::m_dtDepthTestFunc = _dtFunc;
                        static const D3D11_COMPARISON_FUNC dcfFuncs[] = {
                                D3D11_COMPARISON_NEVER,                                 // LSG_DT_NEVER
                                D3D11_COMPARISON_ALWAYS,                                // LSG_DT_ALWAYS
                                D3D11_COMPARISON_LESS,                                  // LSG_DT_LESS
                                D3D11_COMPARISON_EQUAL,                                 // LSG_DT_EQUAL
                                D3D11_COMPARISON_NOT_EQUAL,                             // LSG_DT_NOTEQUAL
                                D3D11_COMPARISON_LESS_EQUAL,                    // LSG_DT_LESSEQUAL
                                D3D11_COMPARISON_GREATER,                               // LSG_DT_GREATER
                                D3D11_COMPARISON_GREATER_EQUAL,                 // LSG_DT_GREATEREQUAL
                        };
                        m_dsdDepthStencilDesc.DepthFunc = dcfFuncs[_dtFunc];
                        SafeRelease( m_pdssDepthStencil );
                        m_pdDevice->CreateDepthStencilState( &m_dsdDepthStencilDesc, &m_pdssDepthStencil );
                        m_pdcContext->OMSetDepthStencilState( m_pdssDepthStencil, 1UL );
                }
        }

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

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

        LSE_INLINE LSVOID LSE_FCALL CDirectX11::SetCullMode( LSG_CULL_MODES _cmMode ) {
                static const D3D11_CULL_MODE cmModes[] = {
                        D3D11_CULL_FRONT,
                        D3D11_CULL_BACK,
                };
                assert( _cmMode == LSG_CM_CW || _cmMode == LSG_CM_CCW );
                if ( m_rdRasterizerDesc.CullMode == D3D11_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_pdcContext->RSSetState( m_prsRasterizerState );
                }
        }

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

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

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

        LSE_INLINE LSVOID LSE_FCALL CDirectX11::SetBlendFunc( LSG_BLEND_MODES _bmSrc, LSG_BLEND_MODES _bmDst ) {
                static const D3D11_BLEND bModes[] = {
                        D3D11_BLEND_ZERO,                                               // LSG_BM_ZERO
                        D3D11_BLEND_ONE,                                                // LSG_BM_ONE
                        D3D11_BLEND_SRC_COLOR,                                  // LSG_BM_SRC_COLOR
                        D3D11_BLEND_INV_SRC_COLOR,                              // LSG_BM_INV_SRC_COLOR
                        D3D11_BLEND_DEST_COLOR,                                 // LSG_BM_DST_COLOR
                        D3D11_BLEND_INV_DEST_COLOR,                             // LSG_BM_INV_DST_COLOR
                        D3D11_BLEND_SRC_ALPHA,                                  // LSG_BM_SRC_ALPHA
                        D3D11_BLEND_INV_SRC_ALPHA,                              // LSG_BM_INV_SRC_ALPHA
                        D3D11_BLEND_DEST_ALPHA,                                 // LSG_BM_DST_ALPHA
                        D3D11_BLEND_INV_DEST_ALPHA,                             // LSG_BM_INV_DEST_ALPHA
                        D3D11_BLEND_SRC_ALPHA_SAT,                              // LSG_BM_SRC_ALPHA_SAT
                };
                if ( m_bdBlendDesc.RenderTarget[0].SrcBlend != bModes[_bmSrc] || m_bdBlendDesc.RenderTarget[0].DestBlend != bModes[_bmDst] ) {
                        m_bdBlendDesc.RenderTarget[0].SrcBlend = bModes[_bmSrc];
                        m_bdBlendDesc.RenderTarget[0].DestBlend = bModes[_bmDst];

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

        LSE_INLINE LSVOID LSE_FCALL CDirectX11::SetFillMode( LSG_FILL_MODES _fmMode ) {
                static const D3D11_FILL_MODE fmValue[] = {
                        D3D11_FILL_SOLID,
                        D3D11_FILL_WIREFRAME,
                };
                if ( m_rdRasterizerDesc.FillMode != fmValue[_fmMode] ) {
                        m_rdRasterizerDesc.FillMode = fmValue[_fmMode];

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

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

        LSE_INLINE LSVOID LSE_FCALL CDirectX11::EndRender() {
        }

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

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

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

}       // namespace lsg

#endif  // #ifdef LSG_DX11

#endif  // __LSG_DIRECTX11_H__