Code/CryEngine/RenderDll/Common/Shaders/CShader.h

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #ifndef __CSHADER_H__
   4 #define __CSHADER_H__
   5
   6 #include <map>
   7 #include "CShaderBin.h"
   8 #include "ShaderSerialize.h"
   9 #include "ShaderCache.h"
  10 #include "ShaderComponents.h" // ECGParam
  11 #include "../ResFileLookupDataMan.h"
  12
  13 struct SRenderBuf;
  14 class CRenderElement;
  15 struct SEmitter;
  16 struct SParticleInfo;
  17 struct SPartMoveStage;
  18 struct SSunFlare;
  19
  20 //===================================================================
  21
  22 #define MAX_ENVTEXTURES    16
  23 #define MAX_ENVTEXSCANDIST 0.1f
  24
  25 //===============================================================================
  26
  27 struct SMacroFX
  28 {
  29         string m_szMacro;
  30         uint32 m_nMask;
  31 };
  32
  33 //typedef std::unordered_map<string, SMacroFX, stl::hash_strcmp<string>, stl::hash_strcmp<string>> FXMacro;
  34 //typedef std::map<string,SMacroFX> FXMacro;
  35 typedef std::unordered_map<string, SMacroFX, stl::hash_strcmp<const char*>, stl::hash_strcmp<const char*>> FXMacro;
  36
  37 typedef FXMacro::iterator                                                                                  FXMacroItor;
  38
  39 //////////////////////////////////////////////////////////////////////////
  40 // Helper class for shader parser, holds temporary strings vector etc...
  41 //////////////////////////////////////////////////////////////////////////
  42 struct CShaderParserHelper
  43 {
  44         CShaderParserHelper()
  45         {
  46         }
  47         ~CShaderParserHelper()
  48         {
  49         }
  50
  51         char* GetTempStringArray(int nIndex, int nLen)
  52         {
  53                 m_tempString.reserve(nLen + 1);
  54                 return (char*)&(m_tempStringArray[nIndex])[0];
  55         }
  56
  57         std::vector<char> m_tempStringArray[32];
  58         std::vector<char> m_tempString;
  59 };
  60 extern CShaderParserHelper* g_pShaderParserHelper;
  61
  62 enum EShaderFlagType
  63 {
  64         eSFT_Global = 0,
  65         eSFT_Runtime,
  66         eSFT_MDV,
  67         eSFT_LT,
  68 };
  69
  70 enum EShaderFilterOperation
  71 {
  72         eSFO_Expand = 0,  // expand all permutations of the mask
  73         eSFO_And,         // and against the mask
  74         eSFO_Eq,          // set the mask
  75 };
  76
  77 // includes or excludes
  78 struct CShaderListFilter
  79 {
  80         CShaderListFilter() :
  81                 m_bInclude(true)
  82         {}
  83
  84         bool   m_bInclude;
  85         string m_ShaderName;
  86
  87         struct Predicate
  88         {
  89                 Predicate() :
  90                         m_Negated(false),
  91                         m_Flags(eSFT_Global),
  92                         m_Op(eSFO_And),
  93                         m_Mask(0)
  94                 {}
  95
  96                 bool                   m_Negated;
  97                 EShaderFlagType        m_Flags;
  98                 EShaderFilterOperation m_Op;
  99                 uint64                 m_Mask;
 100         };
 101         std::vector<Predicate> m_Predicates;
 102 };
 103
 104 //==================================================================================
 105
 106 #define PD_INDEXED 1
 107 #define PD_MERGED  4
 108
 109 struct SParamDB
 110 {
 111         const char* szName;
 112         const char* szAliasName;
 113         ECGParam    eParamType;
 114         uint32      nFlags;
 115         void        (* ParserFunc)(const char* szScr, const char* szAnnotations, std::vector<STexSamplerFX>* pSamplers, SCGParam* vpp, int nComp, CShader* ef);
 116         SParamDB()
 117                 : szName(nullptr)
 118                 , szAliasName(nullptr)
 119                 , eParamType(ECGP_Unknown)
 120                 , nFlags(0)
 121                 , ParserFunc(nullptr)
 122         {
 123         }
 124         SParamDB(const char* inName, ECGParam ePrmType, uint32 inFlags)
 125         {
 126                 szName = inName;
 127                 szAliasName = NULL;
 128                 nFlags = inFlags;
 129                 ParserFunc = NULL;
 130                 eParamType = ePrmType;
 131         }
 132         SParamDB(const char* inName, ECGParam ePrmType, uint32 inFlags, void(*InParserFunc)(const char* szScr, const char* szAnnotations, std::vector<STexSamplerFX>* pSamplers, SCGParam * vpp, int nComp, CShader * ef))
 133         {
 134                 szName = inName;
 135                 szAliasName = NULL;
 136                 nFlags = inFlags;
 137                 ParserFunc = InParserFunc;
 138                 eParamType = ePrmType;
 139         }
 140 };
 141
 142 struct SSamplerDB
 143 {
 144         const char* szName;
 145         ECGSampler  eSamplerType;
 146         uint32      nFlags;
 147         void        (* ParserFunc)(const char* szScr, const char* szAnnotations, std::vector<SFXSampler>* pSamplers, SCGSampler* vpp, CShader* ef);
 148         SSamplerDB()
 149         {
 150                 szName = NULL;
 151                 nFlags = 0;
 152                 ParserFunc = NULL;
 153                 eSamplerType = ECGS_Unknown;
 154         }
 155         SSamplerDB(const char* inName, ECGSampler ePrmType, uint32 inFlags)
 156         {
 157                 szName = inName;
 158                 nFlags = inFlags;
 159                 ParserFunc = NULL;
 160                 eSamplerType = ePrmType;
 161         }
 162         SSamplerDB(const char* inName, ECGSampler ePrmType, uint32 inFlags, void(*InParserFunc)(const char* szScr, const char* szAnnotations, std::vector<SFXSampler>* pSamplers, SCGSampler * vpp, CShader * ef))
 163         {
 164                 szName = inName;
 165                 nFlags = inFlags;
 166                 ParserFunc = InParserFunc;
 167                 eSamplerType = ePrmType;
 168         }
 169 };
 170
 171 struct STextureDB
 172 {
 173         const char* szName;
 174         ECGTexture  eTextureType;
 175         uint32      nFlags;
 176         void        (* ParserFunc)(const char* szScr, const char* szAnnotations, std::vector<SFXTexture>* pSamplers, SCGTexture* vpp, CShader* ef);
 177         STextureDB()
 178         {
 179                 szName = NULL;
 180                 nFlags = 0;
 181                 ParserFunc = NULL;
 182                 eTextureType = ECGT_Unknown;
 183         }
 184         STextureDB(const char* inName, ECGTexture ePrmType, uint32 inFlags)
 185         {
 186                 szName = inName;
 187                 nFlags = inFlags;
 188                 ParserFunc = NULL;
 189                 eTextureType = ePrmType;
 190         }
 191         STextureDB(const char* inName, ECGTexture ePrmType, uint32 inFlags, void(*InParserFunc)(const char* szScr, const char* szAnnotations, std::vector<SFXTexture>* pSamplers, SCGTexture * vpp, CShader * ef))
 192         {
 193                 szName = inName;
 194                 nFlags = inFlags;
 195                 ParserFunc = InParserFunc;
 196                 eTextureType = ePrmType;
 197         }
 198 };
 199
 200 enum EShaderCacheMode
 201 {
 202         eSC_Normal          = 0,
 203         eSC_BuildGlobal     = 2,
 204         eSC_BuildGlobalList = 3,
 205         eSC_Preactivate     = 4,
 206 };
 207
 208 //////////////////////////////////////////////////////////////////////////
 209 class CShaderMan :
 210         public ISystemEventListener
 211 #if defined(SHADERS_SERIALIZING)
 212         , public CShaderSerialize
 213 #endif
 214 {
 215         friend class CShader;
 216         friend class CParserBin;
 217
 218         //////////////////////////////////////////////////////////////////////////
 219         // ISystemEventListener interface implementation.
 220         //////////////////////////////////////////////////////////////////////////
 221         virtual void OnSystemEvent(ESystemEvent event, UINT_PTR wparam, UINT_PTR lparam);
 222         //////////////////////////////////////////////////////////////////////////
 223
 224 private:
 225         STexAnim*      mfReadTexSequence(const char* name, int Flags, bool bFindOnly);
 226         int            mfReadTexSequence(STexSamplerRT* smp, const char* name, int Flags, bool bFindOnly);
 227
 228         CShader*       mfNewShader(const char* szName);
 229
 230         bool           mfCompileShaderGen(SShaderGen* shg, char* scr);
 231         SShaderGenBit* mfCompileShaderGenProperty(char* scr);
 232
 233         void           mfSetResourceTexState(SEfResTexture* Tex);
 234         CTexture*      mfTryToLoadTexture(const char* nameTex, STexSamplerRT* smp, int Flags, bool bFindOnly);
 235         void           mfRefreshResourceTextureConstants(EEfResTextures Id, SInputShaderResources& RS);
 236         void           mfRefreshResourceTextureConstants(EEfResTextures Id, CShaderResources& RS);
 237         CTexture*      mfFindResourceTexture(const char* nameTex, const char* path, int Flags, SEfResTexture* Tex);
 238         CTexture*      mfLoadResourceTexture(const char* nameTex, const char* path, int Flags, SEfResTexture* Tex);
 239         bool           mfLoadResourceTexture(EEfResTextures Id, SInputShaderResources& RS, uint32 CustomFlags, bool bReplaceMeOnFail = false);
 240         bool           mfLoadResourceTexture(EEfResTextures Id, CShaderResources& RS, uint32 CustomFlags, bool bReplaceMeOnFail = false);
 241         void           mfLoadDefaultTexture(EEfResTextures Id, CShaderResources& RS, EEfResTextures Alias);
 242         void           mfCheckShaderResTextures(TArray<SShaderPass>& Dst, CShader* ef, CShaderResources* Res);
 243         void           mfCheckShaderResTexturesHW(TArray<SShaderPass>& Dst, CShader* ef, CShaderResources* Res);
 244         CTexture*      mfCheckTemplateTexName(const char* mapname, ETEX_Type eTT);
 245
 246         CShader*       mfCompile(CShader* ef, char* scr);
 247
 248         void           mfRefreshResources(CShaderResources* Res, const IRenderer::SLoadShaderItemArgs* pArgs = 0);
 249
 250         bool           mfReloadShaderFile(const char* szName, int nFlags);
 251 #if CRY_PLATFORM_DESKTOP
 252         bool           CheckAllFilesAreWritable(const char* szDir) const;
 253 #endif
 254
 255         static void    FilterShaderCacheGenListForOrbis(FXShaderCacheCombinations& combinations);
 256
 257 public:
 258         char*                 m_pCurScript;
 259         CShaderManBin         m_Bin;
 260         CResFileLookupDataMan m_ResLookupDataMan[2];  // CACHE_READONLY, CACHE_USER
 261
 262         const char*     mfTemplateTexIdToName(int Id);
 263         SShaderGenComb* mfGetShaderGenInfo(const char* nmFX);
 264
 265         bool            mfReloadShaderIncludes(const char* szPath, int nFlags);
 266         bool            mfReloadAllShaders(int nFlags, uint32 nFlagsHW);
 267         bool            mfReloadFile(const char* szPath, const char* szName, int nFlags);
 268
 269         void            ParseShaderProfiles();
 270         void            ParseShaderProfile(char* scr, SShaderProfile* pr);
 271
 272         EEfResTextures  mfCheckTextureSlotName(const char* mapname);
 273         SParamDB*       mfGetShaderParamDB(const char* szSemantic);
 274         const char*     mfGetShaderParamName(ECGParam ePR);
 275         bool            mfParseParamComp(int comp, SCGParam* pCurParam, const char* szSemantic, char* params, const char* szAnnotations, SShaderFXParams& FXParams, CShader* ef, uint32 nParamFlags, EHWShaderClass eSHClass, bool bExpressionOperand);
 276         bool            mfParseCGParam(char* scr, const char* szAnnotations, SShaderFXParams& FXParams, CShader* ef, std::vector<SCGParam>* pParams, int nComps, uint32 nParamFlags, EHWShaderClass eSHClass, bool bExpressionOperand);
 277         bool            mfParseFXParameter(SShaderFXParams& FXParams, SFXParam* pr, const char* ParamName, CShader* ef, bool bInstParam, int nParams, std::vector<SCGParam>* pParams, EHWShaderClass eSHClass, bool bExpressionOperand);
 278
 279         bool            mfParseFXTexture(SShaderFXParams& FXParams, SFXTexture* pr, const char* ParamName, CShader* ef, int nParams, std::vector<SCGTexture>* pParams, EHWShaderClass eSHClass);
 280         bool            mfParseFXSampler(SShaderFXParams& FXParams, SFXSampler* pr, const char* ParamName, CShader* ef, int nParams, std::vector<SCGSampler>* pParams, EHWShaderClass eSHClass);
 281
 282         void            mfCheckObjectDependParams(std::vector<SCGParam>& PNoObj, std::vector<SCGParam>& PObj, EHWShaderClass eSH, CShader* pFXShader);
 283
 284         void            mfBeginFrame();
 285
 286         void            mfGetShaderListPath(stack_string& nameOut, int nType);
 287
 288 public:
 289         bool                       m_bInitialized;
 290         bool                       m_bLoadedSystem;
 291
 292         string                     m_ShadersGamePath;
 293         string                     m_ShadersGameExtPath;
 294         const char*                m_ShadersPath;
 295         const char*                m_ShadersExtPath;
 296         const char*                m_ShadersCache;
 297         const char*                m_ShadersFilter;
 298         const char*                m_ShadersMergeCachePath;
 299         string                     m_szUserPath;
 300
 301         int                        m_nFrameForceReload;
 302
 303         char                       m_HWPath[128];
 304
 305         CShader*                   m_pCurShader;
 306         static SResourceContainer* s_pContainer;  // List/Map of objects for shaders resource class
 307
 308         std::vector<string>        m_ShaderNames;
 309
 310         static CCryNameTSCRC       s_cNameHEAD;
 311
 312         static CShader*            s_DefaultShader;
 313         static CShader*            s_shPostEffects;      // engine specific post process effects
 314         static CShader*            s_shPostDepthOfField; // depth of field
 315         static CShader*            s_shPostMotionBlur;
 316         static CShader*            s_shPostSunShafts;
 317         static CShader*            s_sh3DHUD;
 318
 319         // Deferred rendering passes
 320         static CShader*              s_shDeferredShading;
 321         static CShader*              s_ShaderDeferredCaustics;
 322         static CShader*              s_ShaderDeferredRain;
 323         static CShader*              s_ShaderDeferredSnow;
 324
 325         static CShader*              s_ShaderFPEmu;
 326         static CShader*              s_ShaderFallback;
 327         static CShader*              s_ShaderScaleForm;
 328         static CShader*              s_ShaderStars;
 329         static CShader*              s_ShaderShadowBlur;
 330         static CShader*              s_ShaderShadowMaskGen;
 331 #if defined(FEATURE_SVO_GI)
 332         static CShader*              s_ShaderSVOGI;
 333 #endif
 334         static CShader*              s_shHDRPostProcess;
 335         static CShader*              s_shPostEffectsGame; // game specific post process effects
 336         static CShader*              s_shPostEffectsRenderModes;
 337         static CShader*              s_shPostAA;
 338         static CShader*              s_ShaderDebug;
 339         static CShader*              s_ShaderLensOptics;
 340         static CShader*              s_ShaderSoftOcclusionQuery;
 341         static CShader*              s_ShaderLightStyles;
 342         static CShader*              s_ShaderCommon;
 343         static CShader*              s_ShaderOcclTest;
 344         static CShader*              s_ShaderDXTCompress;
 345         static CShader*              s_ShaderStereo;
 346         static CShader*              s_ShaderClouds;
 347         static CShader*              s_ShaderMobileComposition;
 348         static CShader*              s_ShaderGpuParticles;
 349
 350         const SInputShaderResources* m_pCurInputResources;
 351         SShaderGen*                  m_pGlobalExt;
 352
 353         std::vector<SShaderGenComb>  m_SGC;
 354
 355         int                          m_nCombinationsProcess;
 356         int                          m_nCombinationsProcessOverall;
 357         int                          m_nCombinationsCompiled;
 358         int                          m_nCombinationsEmpty;
 359
 360         EShaderCacheMode             m_eCacheMode;
 361
 362         const char*                  m_szShaderPrecache;
 363
 364         FXShaderCacheCombinations    m_ShaderCacheCombinations[2];
 365         FXShaderCacheCombinations    m_ShaderCacheExportCombinations;
 366         FILE*                        m_FPCacheCombinations[2];
 367
 368         typedef std::vector<CCryNameTSCRC, stl::STLGlobalAllocator<CCryNameTSCRC>> ShaderCacheMissesVec;
 369         ShaderCacheMissesVec    m_ShaderCacheMisses;
 370         string                  m_ShaderCacheMissPath;
 371         ShaderCacheMissCallback m_ShaderCacheMissCallback;
 372
 373         SShaderCacheStatistics  m_ShaderCacheStats;
 374
 375         uint32                  m_nFrameLastSubmitted;
 376         uint32                  m_nFrameSubmit;
 377         SShaderProfile          m_ShaderProfiles[eST_Max];
 378         SShaderProfile          m_ShaderFixedProfiles[eSQ_Max];
 379
 380         int                     m_bActivated;
 381
 382         CShaderParserHelper     m_shaderParserHelper;
 383
 384         bool                    m_bReload;
 385
 386         // Shared common global flags data
 387
 388         // Map used for storing automatically-generated flags and mapping old shader names masks to generated ones
 389         //  map< shader flag names, mask >
 390         typedef std::map<string, uint64> MapNameFlags;
 391         typedef MapNameFlags::iterator   MapNameFlagsItor;
 392         MapNameFlags m_pShaderCommonGlobalFlag;
 393
 394         MapNameFlags m_pSCGFlagLegacyFix;
 395         uint64       m_nSGFlagsFix;
 396
 397         // Map stored for convenience mapping betweens old flags and new ones
 398         //  map < shader name , map< shader flag names, mask > >
 399         typedef std::map<string, MapNameFlags*> ShaderMapNameFlags;
 400         typedef ShaderMapNameFlags::iterator    ShaderMapNameFlagsItor;
 401         ShaderMapNameFlags m_pShadersGlobalFlags;
 402
 403         typedef std::map<CCryNameTSCRC, SShaderGen*> ShaderExt;
 404         typedef ShaderExt::iterator                  ShaderExtItor;
 405         ShaderExt   m_ShaderExts;
 406
 407         // Concatenated list of shader names using automatic masks generation
 408         string m_pShadersRemapList;
 409
 410         // Helper functors for cleaning up
 411
 412         struct SShaderMapNameFlagsContainerDelete
 413         {
 414                 void operator()(ShaderMapNameFlags::value_type& pObj)
 415                 {
 416                         SAFE_DELETE(pObj.second);
 417                 }
 418         };
 419
 420 public:
 421         CShaderMan();
 422
 423         void              ShutDown();
 424         void              mfReleaseShaders();
 425
 426         SShaderGen*       mfCreateShaderGenInfo(const char* szName, bool bRuntime);
 427         void              mfRemapShaderGenInfoBits(const char* szName, SShaderGen* pShGen);
 428
 429         uint64            mfGetRemapedShaderMaskGen(const char* szName, uint64 nMaskGen = 0, bool bFixup = 0);
 430         string            mfGetShaderBitNamesFromMaskGen(const char* szName, uint64 nMaskGen);
 431
 432         bool              mfUsesGlobalFlags(const char* szShaderName);
 433         const char*       mfGetShaderBitNamesFromGlobalMaskGen(uint64 nMaskGen);
 434         uint64            mfGetShaderGlobalMaskGenFromString(const char* szShaderGen);
 435
 436         void              mfInitGlobal(void);
 437         void              mfInitLookups(void);
 438
 439         void              mfPreloadShaderExts(void);
 440         void              mfInitCommonGlobalFlags(void);
 441         void              mfInitCommonGlobalFlagsLegacyFix(void);
 442         bool              mfRemapCommonGlobalFlagsWithLegacy(void);
 443         void              mfCreateCommonGlobalFlags(const char* szName);
 444         void              mfSaveCommonGlobalFlagsToDisk(const char* szName, uint32 nMaskCount);
 445
 446         void              mfInit(void);
 447         void              mfPostInit(void);
 448         void              mfSortResources();
 449         CShaderResources* mfCreateShaderResources(const SInputShaderResources* Res, bool bShare);
 450         bool              mfRefreshResourceConstants(CShaderResources* Res);
 451         inline bool       mfRefreshResourceConstants(SShaderItem& SI) { return mfRefreshResourceConstants((CShaderResources*)SI.m_pShaderResources); }
 452         bool              mfUpdateTechnik(SShaderItem& SI, CCryNameTSCRC& Name);
 453         SShaderItem       mfShaderItemForName(const char* szName, bool bShare, int flags, SInputShaderResources* Res = NULL, uint64 nMaskGen = 0, const IRenderer::SLoadShaderItemArgs* pArgs = 0);
 454         CShader*          mfForName(const char* name, int flags, const CShaderResources* Res = NULL, uint64 nMaskGen = 0);
 455
 456         bool              mfRefreshSystemShader(const char* szName, CShader*& pSysShader)
 457         {
 458                 if (!pSysShader)
 459                 {
 460                         CryComment("Load System Shader '%s'...", szName);
 461
 462                         if (pSysShader = mfForName(szName, EF_SYSTEM))
 463                                 return true;
 464                 }
 465
 466                 return false;
 467         }
 468
 469         void              RT_ParseShader(CShader* pSH, uint64 nMaskGen, uint32 flags, CShaderResources* Res);
 470         void              RT_SetShaderQuality(EShaderType eST, EShaderQuality eSQ);
 471
 472         void              CreateShaderMaskGenString(const CShader* pSH, stack_string& flagString);
 473         void              CreateShaderExportRequestLine(const CShader* pSH, stack_string& exportString);
 474
 475         SFXParam*         mfGetFXParameter(std::vector<SFXParam>& Params, const char* param);
 476         SFXSampler*       mfGetFXSampler(std::vector<SFXSampler>& Params, const char* param);
 477         SFXTexture*       mfGetFXTexture(std::vector<SFXTexture>& Params, const char* param);
 478         const char*       mfParseFX_Parameter(const string& buf, EParamType eType, const char* szName);
 479         void              mfParseFX_Annotations_Script(char* buf, CShader* ef, std::vector<SFXStruct>& Structs, bool* bPublic, CCryNameR techStart[2]);
 480         void              mfParseFX_Annotations(char* buf, CShader* ef, std::vector<SFXStruct>& Structs, bool* bPublic, CCryNameR techStart[2]);
 481         void              mfParseFXTechnique_Annotations_Script(char* buf, CShader* ef, std::vector<SFXStruct>& Structs, SShaderTechnique* pShTech, bool* bPublic, std::vector<SShaderTechParseParams>& techParams);
 482         void              mfParseFXTechnique_Annotations(char* buf, CShader* ef, std::vector<SFXStruct>& Structs, SShaderTechnique* pShTech, bool* bPublic, std::vector<SShaderTechParseParams>& techParams);
 483         void              mfParseFXSampler_Annotations_Script(char* buf, CShader* ef, std::vector<SFXStruct>& Structs, STexSamplerFX* pSamp);
 484         void              mfParseFXSampler_Annotations(char* buf, CShader* ef, std::vector<SFXStruct>& Structs, STexSamplerFX* pSamp);
 485         void              mfParseFX_Global(SFXParam& pr, CShader* ef, std::vector<SFXStruct>& Structs, CCryNameR techStart[2]);
 486         bool              mfParseDummyFX_Global(std::vector<SFXStruct>& Structs, char* annot, CCryNameR techStart[2]);
 487         const string&     mfParseFXTechnique_GenerateShaderScript(std::vector<SFXStruct>& Structs, FXMacro& Macros, std::vector<SFXParam>& Params, std::vector<SFXParam>& AffectedParams, const char* szEntryFunc, CShader* ef, EHWShaderClass eSHClass, const char* szShaderName, uint32& nAffectMask, const char* szType);
 488         bool              mfParseFXTechnique_MergeParameters(std::vector<SFXStruct>& Structs, std::vector<SFXParam>& Params, std::vector<int>& AffectedFunc, SFXStruct* pMainFunc, CShader* ef, EHWShaderClass eSHClass, const char* szShaderName, std::vector<SFXParam>& NewParams);
 489         CTexture*         mfParseFXTechnique_LoadShaderTexture(STexSamplerRT* smp, const char* szName, SShaderPass* pShPass, CShader* ef, int nIndex, byte ColorOp, byte AlphaOp, byte ColorArg, byte AlphaArg);
 490         bool              mfParseFXTechnique_LoadShader(const char* szShaderCom, SShaderPass* pShPass, CShader* ef, std::vector<STexSamplerFX>& Samplers, std::vector<SFXStruct>& Structs, std::vector<SFXParam>& Params, FXMacro& Macros, EHWShaderClass eSHClass);
 491         bool              mfParseFXTechniquePass(char* buf, char* annotations, SShaderTechnique* pShTech, CShader* ef, std::vector<STexSamplerFX>& Samplers, std::vector<SFXStruct>& Structs, std::vector<SFXParam>& Params);
 492         bool              mfParseFXTechnique_CustomRE(char* buf, const char* name, SShaderTechnique* pShTech, CShader* ef);
 493         SShaderTechnique* mfParseFXTechnique(char* buf, char* annotations, CShader* ef, std::vector<STexSamplerFX>& Samplers, std::vector<SFXStruct>& Structs, std::vector<SFXParam>& Params, bool* bPublic, std::vector<SShaderTechParseParams>& techParams);
 494         bool              mfParseFXSampler(char* buf, char* name, char* annotations, CShader* ef, std::vector<STexSamplerFX>& Samplers, std::vector<SFXStruct>& Structs);
 495         bool              mfParseLightStyle(CLightStyle* ls, char* buf);
 496         bool              mfParseFXLightStyle(char* buf, int nID, CShader* ef, std::vector<SFXStruct>& Structs);
 497         CShader*          mfParseFX(char* buf, CShader* ef, CShader* efGen, uint64 nMaskGen);
 498         void              mfPostLoadFX(CShader* efT, std::vector<SShaderTechParseParams>& techParams, CCryNameR techStart[2]);
 499         bool              mfParseDummyFX(char* buf, std::vector<string>& ShaderNames, const char* szName);
 500         bool              mfAddFXShaderNames(const char* szName, std::vector<string>* ShaderNames, bool bUpdateCRC);
 501         bool              mfInitShadersDummy(bool bUpdateCRC);
 502
 503         uint64            mfGetRTForName(char* buf);
 504         uint32            mfGetGLForName(char* buf, CShader* ef);
 505
 506         void              mfFillGenMacroses(SShaderGen* shG, TArray<char>& buf, uint64 nMaskGen);
 507         bool              mfModifyGenFlags(CShader* efGen, const CShaderResources* pRes, uint64& nMaskGen, uint64& nMaskGenHW);
 508
 509         bool              mfGatherShadersList(const char* szPath, bool bCheckIncludes, bool bUpdateCRC, std::vector<string>* Names);
 510         void              mfGatherFilesList(const char* szPath, std::vector<CCryNameR>& Names, int nLevel, bool bUseFilter, bool bMaterial = false);
 511         int               mfInitShadersList(std::vector<string>* ShaderNames);
 512         void              mfSetDefaults(void);
 513         void              mfReleaseSystemShaders();
 514         void              mfLoadBasicSystemShaders();
 515         void              mfLoadDefaultSystemShaders();
 516         void              mfCloseShadersCache(int nID);
 517         void              mfInitShadersCacheMissLog();
 518
 519         void              mfInitShadersCache(byte bForLevel, FXShaderCacheCombinations* Combinations = NULL, const char* pCombinations = NULL, int nType = 0);
 520         void              mfMergeShadersCombinations(FXShaderCacheCombinations* Combinations, int nType);
 521         void              mfInsertNewCombination(SShaderCombIdent& Ident, EHWShaderClass eCL, const char* name, int nID, string* Str = NULL, byte bStore = 1);
 522         string            mfGetShaderCompileFlags(EHWShaderClass eClass, UPipelineState pipelineState) const;
 523         const char*       mfGetLevelListName() const;
 524         void              mfExportShaders();
 525
 526         bool              mfPreloadBinaryShaders();
 527
 528         bool              LoadShaderStartupCache();
 529         void              UnloadShaderStartupCache();
 530
 531 #if CRY_PLATFORM_DESKTOP
 532         void AddCombination(SCacheCombination& cmb, FXShaderCacheCombinations& CmbsMap, CHWShader* pHWS);
 533         void AddGLCombinations(CShader* pSH, std::vector<SCacheCombination>& CmbsGL);
 534         void AddLTCombinations(SCacheCombination& cmb, FXShaderCacheCombinations& CmbsMap, CHWShader* pHWS);
 535         void AddRTCombinations(FXShaderCacheCombinations& CmbsMap, CHWShader* pHWS, CShader* pSH, FXShaderCacheCombinations* Combinations);
 536         void AddGLCombination(FXShaderCacheCombinations& CmbsMap, SCacheCombination& cc);
 537         void FilterShaderCombinations(std::vector<SCacheCombination>& Cmbs, const std::vector<CShaderListFilter>& Filters);
 538         void mfPrecacheShaders(bool bStatsOnly);
 539         void _PrecacheShaderList(bool bStatsOnly);
 540         void mfOptimiseShaders(const char* szFolder, bool bForce);
 541         void mfAddRTCombinations(FXShaderCacheCombinations& CmbsMapSrc, FXShaderCacheCombinations& CmbsMapDst, CHWShader* pSH, bool bListOnly);
 542         void mfAddRTCombination_r(int nComb, FXShaderCacheCombinations& CmbsMapDst, SCacheCombination* cmb, CHWShader* pSH, bool bAutoPrecache);
 543         void mfAddLTCombinations(SCacheCombination* cmb, FXShaderCacheCombinations& CmbsMapDst);
 544         void mfAddLTCombination(SCacheCombination* cmb, FXShaderCacheCombinations& CmbsMapDst, DWORD dwL);
 545 #endif
 546
 547 #if CRY_PLATFORM_WINDOWS && CRY_PLATFORM_64BIT
 548         #pragma warning( push )           //AMD Port
 549         #pragma warning( disable : 4267 ) // conversion from 'size_t' to 'XXX', possible loss of data
 550 #endif
 551
 552         int Size()
 553         {
 554                 int nSize = sizeof(*this);
 555
 556                 nSize += m_SGC.capacity();
 557                 nSize += m_Bin.Size();
 558
 559                 return nSize;
 560         }
 561
 562         void GetMemoryUsage(ICrySizer* pSizer) const
 563         {
 564                 pSizer->AddObject(m_Bin);
 565                 pSizer->AddObject(m_SGC);
 566                 pSizer->AddObject(m_ShaderNames);
 567                 pSizer->AddObject(m_ShaderCacheCombinations[0]);
 568                 pSizer->AddObject(m_ShaderCacheCombinations[1]);
 569         }
 570
 571         static float EvalWaveForm(SWaveForm* wf);
 572         static float EvalWaveForm(SWaveForm2* wf);
 573         static float EvalWaveForm2(SWaveForm* wf, float frac);
 574 };
 575
 576 #if CRY_PLATFORM_WINDOWS && CRY_PLATFORM_64BIT
 577         #pragma warning( pop ) //AMD Port
 578 #endif
 579
 580 //=====================================================================
 581
 582 #endif                   // __CSHADER_H__