123

RenderDll/Common/Shaders/CShader.h

@@ -0,0 +1,408 @@
+
+#ifndef __CSHADER_H__
+#define __CSHADER_H__
+
+#include <map>
+
+struct SRenderBuf;
+class CRendElement;
+struct SEmitter;
+struct SParticleInfo;
+struct SPartMoveStage;
+struct SSunFlare;
+
+//===================================================================
+
+#define MAX_ENVLIGHTCUBEMAPS 16
+#define ENVLIGHTCUBEMAP_SIZE 16
+#define MAX_ENVLIGHTCUBEMAPSCANDIST_UPDATE 16
+#define MAX_ENVLIGHTCUBEMAPSCANDIST_THRESHOLD 2
+
+#define MAX_ENVCUBEMAPS 4
+#define MAX_ENVCUBEMAPSCANDIST_THRESHOLD 1
+
+#define MAX_ENVTEXTURES 4
+#define MAX_ENVTEXSCANDIST 0.1f
+
+struct SNameAlias
+{
+  CName m_Alias;
+  CName m_Name;
+};
+
+struct SEnvTexture
+{
+  bool m_bInprogress;
+  bool m_bReady;
+  bool m_bWater;
+  bool m_bReflected;
+  int m_MaskReady;
+  int m_Id;
+  int m_TexSize;
+  // Result Cube-Map or 2D RT texture
+  STexPic *m_Tex;
+  // Temporary 2D texture
+  STexPic *m_TexTemp;
+  float m_TimeLastUsed;
+  Vec3d m_CamPos;
+  Vec3d m_ObjPos;
+  Vec3d m_Angle;
+  int m_nFrameReset;
+  // Cube maps average colors (used for RT radiosity)
+  int m_nFrameCreated[6];
+  UCol m_EnvColors[6];
+  void *m_RenderTargets[6];
+};
+
+//===================================================================
+
+#define MAX_EF_FILES 256
+
+struct SRegTemplate
+{
+  char m_Name[64];
+  SShader *m_pShader;
+};
+
+
+#define SF_RELOAD 1
+
+class CShader
+{
+friend struct SShader;
+
+private:
+
+  void mfStartScriptPreprocess();
+  int mfRemoveScript_ifdef(char *posStart, char *posEnd, bool bRemoveAll, int nPos, char *buf, const char *fileName);
+  char *mfPreprCheckMacros (char *buf, const char *nameFile);
+  char *mfPreprCheckConditions (char *buf, const char *nameFile);
+  char *mfPreprCheckIncludes (char *buf, const char *drn, const char *name);
+  int mfLoadSubdir (char *drn, int n);
+
+  int mfReadTexSequence(SShader *ef, TArray<STexPic *>& txs, const char *name, byte eTT, int Flags, int Flags2, float fAmount1=-1.0f, float fAmount2=-1.0f);
+
+  SShader *mfNewShader(EShClass Class, int num);
+
+  char *mfRescanScript(int type, int nInd, SShader *pSHOrg, uint64 nMaskGen);
+  void mfScanScript (char *scr, int n);
+  bool mfCompileShaderGen(SShader *ef, SShaderGen *shg, char *scr);
+  SShaderGenBit *mfCompileShaderGenProperty(SShader *ef, char *scr);
+  SShader *mfCompileShader(SShader *ef, char *scr);
+
+  void mfCompileFogParms(SShader *ef, char *scr);
+  void mfCompileDeform(SShader *ef, SDeform *df, char *dname, char *scr);
+  bool mfCompileSunFlares(SShader *ef, char *name, char *scr);
+  bool mfCompileFlare(SShader *ef, SSunFlare *fl, char *scr);
+  bool mfCompileParams(SShader *ef, char *scr);
+  bool mfCompileRenderParams(SShader *ef, char *scr);
+  bool mfCompilePublic(SShader *ef, char *scr);
+  void mfParseLightStyle(CLightStyle *ls, char *lstr);
+  bool mfCompileLightStyle(SShader *ef, int num, char *scr);
+  void mfCompileParamComps(SParam *pr, char *scr, SShader *ef);
+  uint mfCompileRendState(SShader *ef, SShaderPass *sm, char *scr);
+  bool mfCompileSequence(SShader *ef, SShaderTexUnit *tl, int nLayer, char *scr, ETexType eTT, int Flags, int Flags2, float fBumpAmount);
+  void mfCompileOrient(SShader *ef, int num, char *scr);
+
+  void mfCompileLightMove(SShader *ef, char *nameMove, SLightEval *le, char *scr);
+  void mfCompileEvalLight(SShader *ef, char *scr);
+  void mfCompileStencil(SShader *ef, char *params);
+  void mfCompileState(SShader *ef, char *params);
+
+  STexPic *mfTryToLoadTexture(const char *nameTex, int Flags, int Flags2, byte eTT, SShader *sh, float fAmount1=-1.0f, float fAmount2=-1.0f);
+  STexPic *mfLoadResourceTexture(const char *nameTex, const char *path, int Flags, int Flags2, byte eTT, SShader *sh, SEfResTexture *Tex, float fAmount1=-1.0f, float fAmount2=-1.0f);
+  bool mfCheckAnimatedSequence(SShaderTexUnit *tl, STexPic *tx);
+  STexPic *mfCheckTemplateTexName(char *mapname, ETexType eTT, short &nFlags);
+  void mfCheckShaderResTextures(TArray<SShaderPass> &Dst, SShader *ef, SRenderShaderResources *Res);
+  void mfCheckShaderResTexturesHW(TArray<SShaderPassHW> &Dst, SShader *ef, SRenderShaderResources *Res);
+  int mfTemplateNameToId(char *name);
+  void mfCompileTemplate(SShader *ef, char *scr);
+  bool mfCompileTexGen(char *name, char *params, SShader *ef, SShaderTexUnit *ml);
+
+  SShader *mfCompile(SShader *ef, char *scr);
+
+  void mfCompileLayers(SShader *ef, char *scr, TArray<SShaderPassHW>& Layers, EShaderPassType eType);
+  void mfCompileVarsPak(char *scr, TArray<CVarCond>& Vars, SShader *ef);
+  void mfCompileHWConditions(SShader *ef, char *scr, SShaderTechnique *hs, int Id);
+  SShaderTechnique *mfCompileHW(SShader *ef, char *scr, int Id);
+  bool mfUpdateMergeStatus(SShaderTechnique *hs, TArray<SCGParam4f> *p);
+  bool mfCompileHWShadeLayer(SShader *ef, char *scr, TArray<SShaderPassHW>& Layers);
+
+  void mfClEfCompile(SShader *ef, char *scr, char *name);
+  
+  bool mfReloadShaderScript(const char *szShaderName, int nFlags, SShader *pSH);
+  void mfRefreshResources(SShader *eft, SRenderShaderResources *Res);
+  bool mfAddTemplate(SRenderShaderResources *Res, SShader *ef, int IdTempl, const char *Name=NULL, uint64 nMaskGen=0);
+  void mfRegisterDefaultTemplates();
+  void mfUnregisterDefaultTemplates();
+  bool mfSetOpacity (SShaderPass *Layer, float Opa, SShader *ef, int Mode);
+  void mfRefreshLayer(SShaderPass *sl, SShader *sh);
+  bool mfReloadShader(const char *szName, int nFlags);
+  bool mfReloadShaderFile(const char *szName, int nFlags);
+  void mfCheckAffectedFiles(const char *ShadersPath, int nCheckFile, TArray<char *>& CheckNames, TArray<char *>& AffectedFiles);
+
+public:
+  char *m_pCurScript;
+  ShaderMacro m_Macros;
+  TArray<SLocalMacros> m_LocalMacros;
+
+  bool PackCache();
+  SShaderCacheHeaderItem *GetCacheItem(SShaderCache *pCache, int nMask);
+  bool FreeCacheItem(SShaderCache *pCache, int nMask);
+  bool AddCacheItem(SShaderCache *pCache, SShaderCacheHeaderItem *pItem, byte *pData, int nLen, bool bFlush);
+  SShaderCache *OpenCacheFile(const char *szName, float fVersion);
+  bool FlushCacheFile(SShaderCache *pCache);
+  bool CloseCacheFile(SShaderCache *pCache);
+
+  char *mfScriptPreprocessor (char *buf, const char *drn, const char *name);
+  uint64 mfScriptPreprocessorMask(SShader *pSH, int nOffset);
+  bool mfReloadAllShaders(int nFlags);
+  bool mfReloadFile(const char *szPath, const char *szName, int nFlags);
+  const char *mfTemplateTexIdToName(int Id);
+  bool mfGetParmComps(int comp, SParam *vpp, char *name, char *params, SShader *ef);
+  bool mfCompilePlantsTMoving(char *scr, SShader *ef, TArray<SParam>* Params, int reg);
+  void mfCompileParamMatrix(char *scr, SShader *ef, SParamComp_Matrix *pcm);
+  bool mfCompileParam(char *scr, SShader *ef, TArray<SParam>* Params);
+  bool mfCompileCGParam(char *scr, SShader *ef, TArray<SCGParam4f>* Params);
+  void mfCheckObjectDependParams(TArray<SParam>* PNoObj, TArray<SParam>* PObj);
+  void mfCheckObjectDependParams(TArray<SCGParam4f>* PNoObj, TArray<SCGParam4f>* PObj);
+  void mfCompileArrayPointer(TArray<SArrayPointer *>& Pointers, char *scr, SShader *ef);
+  ESrcPointer mfParseSrcPointer(char *type, SShader *ef);
+  bool mfCompileLayer(SShader *ef, int num, char *scr, SShaderPass *sm);
+
+  bool mfRegisterTemplate(int nTemplId, char *Name, bool bReplace, bool bDefault=false);
+  void mfLoadFromFiles(int num);
+  
+  void mfBeginFrame();
+
+  void mfCompileMatrixOp(TArray<SMatrixTransform>* MatrixOps, char *scr, char *name, SShader *ef);
+
+  SEnvTexture *mfFindSuitableEnvLCMap(Vec3d& Pos, bool bMustExist, int RendFlags, float fDistToCam, CCObject *pObj=NULL);
+  SEnvTexture *mfFindSuitableEnvCMap(Vec3d& Pos, bool bMustExist, int RendFlags, float fDistToCam);
+  SEnvTexture *mfFindSuitableEnvTex(Vec3d& Pos, Vec3d& Angs, bool bMustExist, int RendFlags, bool bUseExistingREs, SShader *pSH, SRenderShaderResources *pRes, CCObject *pObj, bool bReflect, CRendElement *pRE);
+
+private:
+
+  ShaderFilesMap *m_RefEfs[2];
+  LoadedShadersMap m_RefEfsLoaded;
+
+public:
+  bool m_bInitialized;
+
+  char m_ShadersPath[2][128];
+  char m_ShadersCache[128];
+  char *m_ModelsPath;
+  char *m_TexturesPath;
+  char *m_SystemPath;
+
+  char m_HWPath[128];
+  
+  SOrient m_Orients[MAX_ORIENTS];
+  int m_NumOrients;
+
+  string m_FileNames[2][MAX_EF_FILES];
+  short m_nFrameReload[2][MAX_EF_FILES];
+  FILETIME m_WriteTime[2][MAX_EF_FILES];
+  int m_NumFiles[2];
+  int m_nFrameForceReload;
+
+  int m_NightMapReady;
+  int m_nCountNightMap;
+
+  int m_CurEfsNum;
+  SShader *m_CurShader;
+
+  TArray<SNameAlias> m_AliasNames;
+  TArray<SNameAlias> m_CustomAliasNames;
+
+  static SShader *m_DefaultShader;
+
+#ifndef NULL_RENDERER
+  static SShader *m_ShaderVFog;
+  static SShader *m_ShaderVFogCaust;
+  static SShader *m_ShaderFog;
+  static SShader *m_ShaderFogCaust;
+  static SShader *m_ShaderFog_FP;
+  static SShader *m_ShaderFogCaust_FP;
+  static SShader *m_ShaderStateNoCull;
+  static SShader *m_ZBuffPassShader;
+  static SShader *m_ShadowMapShader;
+	static SShader *m_ShaderHDRProcess;
+  static SShader *m_GlareShader;
+  static SShader *m_ShaderSunFlares;
+  static SShader *m_ShaderLightStyles;
+  static SShader *m_ShaderCGPShaders;
+  static SShader *m_ShaderCGVProgramms;
+
+#else
+  static SShaderItem m_DefaultShaderItem;
+#endif
+
+  TArray<SRegTemplate> m_KnownTemplates;
+
+  int m_Frame;
+  SRenderShaderResources *m_pCurResources;
+
+  Matrix44 m_TempMatrices[4][8];
+
+  bool m_bReload;
+
+  int m_Nums;
+  int m_MaxNums;
+  int m_FirstCopyNum;
+
+  bool m_bNeedSysBuf;
+  bool m_bNeedCol;
+  bool m_bNeedSecCol;
+  bool m_bNeedNormal;
+  bool m_bNeedTangents;
+  int  m_nTC;
+
+
+public:
+  CShader()
+  {
+    m_bInitialized = false;
+    m_CurEfsNum = 0;
+    m_NumFiles[0] = m_NumFiles[1] = 0;
+    m_DefaultShader = NULL;
+  }
+
+  void mfShutdown (void);
+  void mfClearAll (void);
+  void mfClearShaders (TArray<SShader *> &Efs, int *Nums);
+  
+  SShader *mfCopyShader(SShader *ef);
+  void mfCompileWaveForm(SWaveForm *wf, char *scr);
+  void mfCompileRGBAStyle(char *scr, SShader *ef, SShaderPass *sp, bool bRGB);
+  void mfCompileRGBNoise(SRGBGenNoise *cn, char *scr, SShader *ef);
+  void mfCompileAlphaNoise(SAlphaGenNoise *cn, char *scr, SShader *ef);
+  void mfAddToHash (char *Name, SShader *ef);
+  void mfAddToHashLwr (char *Name, SShader *ef);
+  void mfRemoveFromHash (SShader *ef);
+  //STexPic *mfLoadCubeTex(const char *mapname, uint flags, uint flags2, int State, ETexType eTT, int RState, int Id, int BindId=0);
+
+  int mfReadAllImgFiles(SShader *ef, SShaderTexUnit *tl, STexAnim *ta, char *name);
+
+  void mfInit(void);
+  void mfShaderNameForAlias(const char *nameAlias, char *nameEf, int nSize);
+  SRenderShaderResources *mfCreateShaderResources(const SInputShaderResources *Res, bool bShare);
+  SShaderItem mfShaderItemForName (const char *name, EShClass Class, bool bShare, const char *templName, int flags, const SInputShaderResources *Res=NULL, uint64 nMaskGen=0);
+  SShader *mfForName (const char *name, EShClass Class, int flags, const SInputShaderResources *Res=NULL, uint64 nMaskGen=0);
+  SShader *mfSpawn (char *name, SShader *ef, SShader *efGen, uint64 nMaskGen);
+
+  bool    mfParseFXTechnique_MergeParameters (std::vector<SFXStruct>& Structs, std::vector<SFXParam>& Params, int nNum, SShader *ef, bool bPixelShader, const char *szShaderName);
+  bool    mfParseFXTechnique_LoadShaderTexture (SFXSampler *smp, SFXTexture *tx, SShaderPassHW *pShPass, SShader *ef, int nIndex, byte ColorOp, byte AlphaOp, byte ColorArg, byte AlphaArg);
+  bool    mfParseFXTechnique_LoadShader (const char *szShaderCom, SShaderPassHW *pShPass, SShader *ef, std::vector<SFXSampler>& Samplers, std::vector<SFXTexture>& Textures, std::vector<SFXStruct>& Structs, std::vector<SFXParam>& Params, std::vector<SPair>& Macros, bool bPixelShader);
+  bool    mfParseFXTechniquePass (char *buf, char *annotations, SShaderTechnique *pShTech, SShader *ef, std::vector<SFXSampler>& Samplers, std::vector<SFXTexture>& Textures, std::vector<SFXStruct>& Structs, std::vector<SFXParam>& Params);
+  bool    mfParseFXTechnique (char *buf, char *annotations, SShader *ef, std::vector<SFXSampler>& Samplers, std::vector<SFXTexture>& Textures, std::vector<SFXStruct>& Structs, std::vector<SFXParam>& Params);
+  bool    mfParseFXSampler(char *buf, char *name, SShader *ef, std::vector<SFXSampler>& Samplers, std::vector<SFXTexture>& Textures);
+  SShader *mfParseFX (char *buf, SShader *ef, SShader *efGen, uint64 nMaskGen);
+
+  char *mfFindInAllText (char *name, char *&pBuf, SShader *shGen, uint64 nMaskGen);
+  char **mfListInScript (char *scr);
+  char *mfScriptForFileName(const char *name, SShader *shGen, uint64 nMaskGen);
+
+  void mfSetDefaults(void);
+  void mfOptimizeShader(SShader *ef, TArray<SShaderPass>& Layers, int Stage);
+  void mfOptimizeShaderHW(SShader *ef, TArray<SShaderPassHW>& Layers, int Stage);
+  void mfConstruct(SShader *ef);
+
+#ifdef WIN64
+#pragma warning( push )							//AMD Port
+#pragma warning( disable : 4267 )				// conversion from 'size_t' to 'XXX', possible loss of data
+#endif
+
+  int Size()
+  {
+    int i, j;
+    int nSize = sizeof(*this);
+
+    nSize += m_KnownTemplates.GetMemoryUsage();
+    nSize += m_AliasNames.GetMemoryUsage();
+
+    for (i=0; i<2; i++)
+    {
+      for (j=0; j<MAX_EF_FILES; j++)
+      {
+        if (!m_FileNames[i][j].empty())
+          nSize += m_FileNames[i][j].capacity();
+      }
+    }
+
+    return nSize;
+  }
+};
+
+#ifdef WIN64
+#pragma warning( pop )							//AMD Port
+#endif
+
+//=====================================================================
+
+struct SSunFlare
+{
+  float   m_Scale;
+  float   m_Loc;  // position offset on axis
+  CFColor m_Color;
+  STexPic *m_Tex;
+  Vec3d   m_Position;
+  float   m_RenderSize;
+
+  int Size()
+  {
+    int nSize = sizeof(SSunFlare);
+    return nSize;
+  }
+  SSunFlare()
+  {
+    m_Tex = NULL;
+    m_Scale = 1.0f;
+    m_Loc = 0;
+    m_Color = Col_White;
+  }
+  ~SSunFlare();
+};
+
+class CSunFlares
+{
+private:
+
+public:
+  static TArray<CSunFlares *> m_SunFlares;
+  static CSunFlares *m_CurFlares;
+
+  char m_Name[32];
+  int m_NumFlares;
+  SSunFlare *m_Flares;
+
+//==================================================================
+
+  int Size()
+  {
+    int nSize = sizeof(CSunFlares);
+    for (int i=0; i<m_NumFlares; i++)
+    {
+      nSize += m_Flares[i].Size();
+    }
+    return nSize;
+  }
+
+  static CSunFlares *mfForName(char *name);
+
+  CSunFlares()
+  {
+    m_NumFlares = 0;
+    m_Flares = NULL;
+  }
+  ~CSunFlares()
+  {
+    if (m_Flares)
+      delete [] m_Flares;
+    m_NumFlares = 0;
+  }
+};
+
+//=====================================================================
+
+#endif  // __CSHADER_H__

RenderDll/Common/Shaders/Parser.h

@@ -0,0 +1,80 @@
+/*=============================================================================
+  Parser.h : Script parser declarations.
+  Copyright (c) 2001 Crytek Studios. All Rights Reserved.
+
+  Revision history:
+    * Created by Khonich Andrey
+
+=============================================================================*/
+
+#ifndef PARSER_H
+#define PARSER_H
+
+extern char *pCurCommand;
+
+/**
+ * Structure to describe a single token
+ */
+typedef struct
+{
+  /// value returned when token is matched
+  long  id;
+  /// token to match
+  char  *token;
+} tokenDesc;
+
+struct SFXTokenDesc
+{
+  int id;
+  char *token;
+};
+
+
+extern const char *kWhiteSpace;
+
+
+/// Get an object from the buffer.
+long shGetObject(char **buf, tokenDesc *tokens, char **name, char **data);
+/// Get a command from the buffer.
+long shGetCommand(char **buf, tokenDesc *tokens, char **params);
+
+extern std::vector<SPair> g_Macros;
+
+long fxGetObject(char **buf, tokenDesc *tokens, char **name, char **data, int &nIndex);
+long fxGetObject(char **buf, SFXTokenDesc *tokens, char **name, char **value, char **data, char **assign, char **annotations, std::vector<SFXStruct>& Structs);
+void fxGetParams(char *annot, std::vector<SFXParam>& prms);
+void fxParserInit(void);
+void fxStart(void);
+void fxIncrLevel();
+void fxDecrLevel();
+int fxFill(char **buf, char *dst);
+
+void fxTranslate(char **buf);
+char *fxGetAssignmentText(char **buf);
+char *fxGetAssignmentText2(char **buf);
+
+char *GetSubText(char **buf, char open, char close);
+void SkipCharacters(char **buf, const char *toSkip);
+char *GetAssignmentText(char **buf);
+void SkipComments(char **buf, bool bSkipWhiteSpace);
+char *RemoveComments(char *buf);
+void RemoveCR(char *buf);
+
+bool shGetBool(char *buf);
+float shGetFloat(char *buf);
+void shGetFloat(char *buf, float *v1, float *v2);
+int shGetInt(char *buf);
+int shGetHex(const char *buf);
+uint64 shGetHex64(const char *buf);
+void shGetVector(char *buf, Vec3d& v);
+void shGetVector(char *buf, float v[3]);
+void shGetVector4(char *buf, vec4_t& v);
+void shGetColor(char *buf, CFColor& v);
+void shGetColor(char *buf, float v[4]);
+int shGetVar (char **buf, char **vr, char **val);
+
+char *fxReplaceInText(char *pText, const char *pSubStr, const char *pReplace);
+char *fxReplaceInText2(char *pText, const char *pSubStr, const char *pReplace);
+
+#endif
+