409 lines
14 KiB
C++
409 lines
14 KiB
C++
|
|
#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__
|