F:/My Projects/LSEngine/Modules/LSGraphicsLib/Src/ShaderLanguage/LSGShaderBase.h

#ifndef __LSG_SHADERBASE_H__
#define __LSG_SHADERBASE_H__

#include "../LSGGraphicsLib.h"
#include "../PreProc/LSGPreProc.h"
#include "Algorithm/LSTLAlgorithm.h"
#include "HighLevel/LSFFilesEx.h"
#include "LSGShaderLanguageParser.h"
#include "LSGShaderLexer.h"
#include "LSGShaderParserWrapper.h"
#include "LSGShaderTranslationProcessorBase.h"
#include "Map/LSTLMap.h"
#include "Matrix/LSMMatrix2x2.h"
#include "Matrix/LSMMatrix3x3.h"
#include "Matrix/LSMMatrix4x4.h"
#include "Set/LSTLSet.h"
#include "String/LSTLString.h"
#include "String/LSTLStringList.h"
#include "Vector/LSMVector2.h"
#include "Vector/LSMVector3.h"
#include "Vector/LSMVector4.h"

namespace lsg {

        class CShaderBase {
        public :
                // == Various constructors.
                LSE_CALLCTOR                                            CShaderBase();
                virtual LSE_CALLCTOR                            ~CShaderBase();


                // == Enumerations.
                enum LSG_SHADER_ERRORS {
                        LSG_SE_SUCCESS,                                 // No error.
                        LSG_SE_INVALIDINPUT,                    // Input shader string is NULL.
                        LSG_SE_STREAMERROR,                             // Error creating the input stream.
                        LSG_SE_PARSERERROR,                             // Error during parsing.
                        LSG_SE_TRANSLATIONRERROR,               // Error during translation.
                        LSG_SE_FILENOTFOUND,                    // File does not exist.
                        LSG_SE_OUTOFMEMORY,                             // Out of memory.
                        LSG_SE_SYNTAX,                                  // Syntax error.
                        LSG_SE_INCLUDERECURSE,                  // Too many recursive includes.
                        LSG_SE_INVALIDSHADERTYPE,               // Invalid shader type.
                        LSG_SE_GFXAPIERROR,                             // Error related to the graphics API.
                        LSG_SE_NOENDIF,                                 // #endif not found.
                        LSG_SE_PREPROC,                                 // Preprocessor error.
                };


                // == Types.
                typedef LSUINT32                                        LSG_HANDLE;

                typedef struct LSG_DEFINE {
                        const LSCHAR *                                  pcMacro;

                        const LSCHAR *                                  pcDefinition;
                } * LPLSG_DEFINE, * const LPCLSG_DEFINE;


                // == Functions.
                LSVOID LSE_CALL                                         Reset();

                virtual LSUINT64 LSE_CALL                       GetId() const;

                LSG_SHADER_ERRORS LSE_CALL                      Compile( CString &_sError );

                LSG_SHADER_ERRORS LSE_CALL                      CompileFromFiles( const LSCHAR * _pcVertexFile, const LSCHAR * _pcPixelFile,
                        CString * _psError = NULL );

                LSBOOL LSE_CALL                                         SetVertexShader( const LSCHAR * _pcShader, LSUINT32 _ui32Length = 0 );

                LSBOOL LSE_CALL                                         SetPixelShader( const LSCHAR * _pcShader, LSUINT32 _ui32Length = 0 );

                LSG_SHADER_ERRORS LSE_CALL                      SetShaderFromFile( const LSCHAR * _pcPath, CShaderLanguageParser::LSG_SHADER_TYPES _stShaderType,
                        CString &_sError );

                LSG_SHADER_ERRORS LSE_CALL                      SetShaderFromMemory( const LSUINT8 * _pui8Src, LSUINT32 _ui32Length,
                        const LSCHAR * _pcPath, CShaderLanguageParser::LSG_SHADER_TYPES _stShaderType,
                        CString &_sError );

                LSBOOL LSE_CALL                                         SetMacros( const LSG_DEFINE * _pdDefines, LSUINT32 _ui32Total, CShaderLanguageParser::LSG_SHADER_TYPES _stShaderType );

                virtual LSBOOL LSE_CALL                         Activate( LSVOID * _pvSysValue ) = 0;

                virtual LSVOID LSE_CALL                         Deactivate() = 0;

                virtual LSVOID LSE_CALL                         PreRender();

                virtual LSG_HANDLE LSE_CALL                     GetConstantByName( const LSCHAR * _pcName ) = 0;

                virtual LSBOOL LSE_CALL                         SetFloat( LSG_HANDLE _hHandle, LSFLOAT _fValue ) = 0;

                virtual LSBOOL LSE_CALL                         SetFloatArray( LSG_HANDLE _hHandle, const LSFLOAT * _pfValues, LSUINT32 _ui32Total ) = 0;

                virtual LSBOOL LSE_CALL                         SetInt( LSG_HANDLE _hHandle, LSINT32 _iValue ) = 0;

                virtual LSBOOL LSE_CALL                         SetIntArray( LSG_HANDLE _hHandle, const LSINT32 * _piValues, LSUINT32 _ui32Total ) = 0;

                virtual LSBOOL LSE_CALL                         SetBool( LSG_HANDLE _hHandle, LSBOOL _bValue ) = 0;

                virtual LSBOOL LSE_CALL                         SetBoolArray( LSG_HANDLE _hHandle, const LSBOOL * _pbValues, LSUINT32 _ui32Total ) = 0;

                virtual LSBOOL LSE_CALL                         SetVector2( LSG_HANDLE _hHandle, const CVector2 &_vValue ) = 0;

                virtual LSBOOL LSE_CALL                         SetVector2Array( LSG_HANDLE _hHandle, const CVector2 * _pvValues, LSUINT32 _ui32Total ) = 0;

                virtual LSBOOL LSE_CALL                         SetVector3( LSG_HANDLE _hHandle, const CVector3 &_vValue ) = 0;

                virtual LSBOOL LSE_CALL                         SetVector3Array( LSG_HANDLE _hHandle, const CVector3 * _pvValues, LSUINT32 _ui32Total ) = 0;

                virtual LSBOOL LSE_CALL                         SetVector4( LSG_HANDLE _hHandle, const CVector4 &_vValue ) = 0;

                virtual LSBOOL LSE_CALL                         SetVector4Array( LSG_HANDLE _hHandle, const CVector4 * _pvValues, LSUINT32 _ui32Total ) = 0;

                virtual LSBOOL LSE_CALL                         SetMatrix2x2( LSG_HANDLE _hHandle, const CMatrix2x2 &_mValue ) = 0;
                
                virtual LSBOOL LSE_CALL                         SetMatrix3x3( LSG_HANDLE _hHandle, const CMatrix3x3 &_mValue ) = 0;
                
                virtual LSBOOL LSE_CALL                         SetMatrix4x4( LSG_HANDLE _hHandle, const CMatrix4x4 &_mValue ) = 0;

                virtual LSBOOL LSE_CALL                         SetMatrix4x4Array( LSG_HANDLE _hHandle, const CMatrix4x4 * _pmValues, LSUINT32 _ui32Total ) = 0;

                static LSBOOL LSE_CALL                          AddSearchPath( const LSCHAR * _pcPath );

                static LSVOID LSE_CALL                          RemoveSearchPath( const LSCHAR * _pcPath );

                static LSUINT32 LSE_CALL                        TotalSearchPaths();

                static const CString & LSE_CALL         GetSearchPath( LSUINT32 _ui32Index );

        protected :
                // == Enumerations.
                enum LSG_CLEAR_STATE {
                        LSG_CS_NONE,
                        LSG_CS_CLEAR,
                        LSG_CS_SEEKING_ENDIF,
                };
                
                // == Types.
                typedef struct LSG_INCLUDES {
                        CString                                                 sPath;

                        LSUINT32                                                ui32RefCount;

                        // == Various constructors.
                        LSE_CALLCTOR                                    LSG_INCLUDES();

                        // == Operators.
                        LSBOOL LSE_CALL                                 operator < ( const LSG_INCLUDES &_iOther ) const;

                        LSBOOL LSE_CALL                                 operator == ( const LSG_INCLUDES &_iOther ) const;
                } * LPLSG_INCLUDES, * const LPCLSG_INCLUDES;

                typedef struct LSG_PREPROC_DEFINE {
                        CString                                                 sName;

                        CString                                                 sDef;


                        // == Operators.
                        LSG_PREPROC_DEFINE & LSE_CALL   operator = ( const LSG_PREPROC_DEFINE &_pdOther );
                } * LPLSG_PREPROC_DEFINE, * const LPCLSG_PREPROC_DEFINE;

                typedef CMap<CString, LSUINT32>         CIncludeSet;


                // == Members.
                CShaderParserWrapper *                          m_pspwParser;

                CShaderLexer *                                          m_pslLexer;

                CVector<LSG_PREPROC_DEFINE>                     m_vDefs[CShaderLanguageParser::LSG_ST_TOTAL];

                CString                                                         m_sVertexShader;

                CString                                                         m_sPixelShader;

                CString                                                         m_sFinalVertex;

                CString                                                         m_sFinalPixel;

                CShaderTranslationProcessorBase::LSG_ERROR_CODES
                                                                                        m_ecTranslationResult;

                CShaderTranslationProcessorBase *       m_pstpbTranslator;

                CShaderTranslationProcessorBase::LSG_UNIFORM_SEMANTIC_LIST
                                                                                        m_uslSemantics[CShaderLanguageParser::LSG_ST_TOTAL];

                CShaderTranslationProcessorBase::LSG_UNIFORM_LIST
                                                                                        m_ulUniforms[CShaderLanguageParser::LSG_ST_TOTAL];

                CShaderTranslationProcessorBase::LSG_ATTRIBUTE_LIST
                                                                                        m_ulAttributes[CShaderLanguageParser::LSG_ST_TOTAL];

                static CStringList                                      m_slHeaderPaths;


                // == Functions.
                LSVOID LSE_CALL                                         ResetParsers();

                LSG_SHADER_ERRORS LSE_CALL                      Compile( const LSCHAR * _pcShader, LSUINT32 _ui32Length,
                        CShaderLanguageParser::LSG_SHADER_TYPES _stShaderType,
                        CString &_sError );

                LSG_SHADER_ERRORS LSE_CALL                      CompileFromFile( const LSCHAR * _pcPath, CShaderLanguageParser::LSG_SHADER_TYPES _stShaderType,
                        CString &_sError );

                LSG_SHADER_ERRORS LSE_CALL                      CompileFromFile( const LSCHAR * _pcPath, CStringList &_slData, LSUINT32 _ui32Line,
                        CShaderLanguageParser::LSG_SHADER_TYPES _stShaderType,
                        CIncludeSet &_isIncludes,
                        CPreProc::LSG_MACROS &_mMacros,
                        CString &_sError );

                LSG_SHADER_ERRORS LSE_CALL                      CompileFromMemory( const LSUINT8 * _pui8Src, LSUINT32 _ui32Length,
                        const LSCHAR * _pcPath, CStringList &_slData, LSUINT32 _ui32Line,
                        CShaderLanguageParser::LSG_SHADER_TYPES _stShaderType,
                        CIncludeSet &_isIncludes,
                        CPreProc::LSG_MACROS &_mMacros,
                        CString &_sError );

                virtual LSG_SHADER_ERRORS LSE_CALL      PostCompile( CString &_sError );

                virtual LSVOID LSE_CALL                         CreateTranslator() = 0;

                virtual LSVOID LSE_CALL                         DestroyTranslator() = 0;

                static CString LSE_CALL                         GetFilePart( const CString &_sDirective );

                static CString LSE_CALL                         FindHeader( const LSCHAR * _pcIncluder, const CString &_sFileToInclude );

                static LSBOOL LSE_CALL                          ParseDefine( const CString &_sLine, CPreProc::LSG_MACROS &_mMacros );

                static LSVOID LSE_CALL                          RemoveComments( CStringList &_slText );

                static LSVOID LSE_CALL                          SkipString( const CString &_sLine, LSUINT32 &_ui32Pos );

                static LSBOOL LSE_CALL                          ExpandMacros( CString &_sString, const CPreProc::LSG_MACROS &_mMacros, CString &_sError );

                static LSBOOL LSE_CALL                          ExpandMacros( CString &_sString, const CPreProc::LSG_MACROS &_mMacros, const CSet<CString> &_sUsedValues, CString &_sError );

                static LSBOOL LSE_CALL                          GetMacroParms( const CString &_sString, LSUINT32 _ui32Pos, LSUINT32 &_ui32NewPos, CVector<CString> &_vRet );

                static LSBOOL LSE_CALL                          GetMacroReplacementString( LSUINT32 _ui32MacroIndex, CVector<CString> &_vParms,
                        const CPreProc::LSG_MACROS &_mMacros, const CSet<CString> &_sUsedValues,
                        CString &_sRet,
                        CString &_sError );

        };

}       // namespace lsg

#endif  // __LSG_SHADERBASE_H__