RomkaZVO/FC1
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
34d6c5d489611da93eb41d9afd4744c00da9f517
FC1/RenderDll/Common/Textures/TexMan.h
romkazvo 34d6c5d489 123
2023-08-07 19:29:24 +08:00

1052 lines
27 KiB
C++
Raw Blame History

/*=============================================================================
TexMan.h : Common texture manager declarations.
Copyright (c) 2001 Crytek Studios. All Rights Reserved.
Revision history:
* Created by Khonich Andrey
=============================================================================*/
#ifndef TEXMAN_INCLUDED
#define TEXMAN_INCLUDED
#include "Image/CImage.h"
#include <Names.h>
#include "../ResFile.h"
#define TX_FIRSTBIND 0x1000
#define TX_LASTBIND 0x4000
#define TO_NORMALIZE_CUBE_MAP 0xfff
#define TO_GLARE 0xffe
#define TO_ENVIRONMENT_LIGHTCUBE_MAP 0xffd
#define TO_ENVIRONMENT_CUBE_MAP 0xffc
#define TO_TEXTURE_WATERMAP 0xffb
#define TO_ENVIRONMENT_TEX 0xff9
#define TO_FROMLIGHT 0xff8
#define TO_LIGHTMAP 0xfeb
#define TO_ENVIRONMENT_SCR 0xfea
#define TO_FOG 0xfe9
#define TO_FROMOBJ 0xfe8
#define TO_FROMRE0 0xff0
#define TO_FROMRE1 0xff1
#define TO_FROMRE2 0xff2
#define TO_FROMRE3 0xff3
#define TO_FROMRE4 0xff4
#define TO_FROMRE5 0xff5
#define TO_FROMRE6 0xff6
#define TO_FROMRE7 0xff7
#define TO_CUSTOM_CUBE_MAP_FIRST 0xfe0 // 8 environment cube textures
#define TO_CUSTOM_CUBE_MAP_LAST 0xfe7
#define TO_LIGHT_CUBE_MAP 0xfef
#define TO_CUSTOM_TEXTURE_FIRST 0xfb0
#define TO_CUSTOM_TEXTURE_LAST 0xfbf
#define TO_RAINMAP 0xfa0 // Rain texture map
#define TO_FLASHBANGMAP 0xfa1 // FlashBang texture map
#define TO_GHOST 0xfa2 // Ghost texture map
#define TO_SCREENMAP 0xfa3 // Screen texture map
#define TO_PREVSCREENMAP 0xfa4 // Previous screen texture map
#define TO_SCREENLUMINOSITYMAP 0xfa5 // Screen luminosity map
#define TO_SCREENCURRLUMINOSITYMAP 0xfa6 // Screen luminosity map
#define TO_SCREENLOWMAP 0xfc0 // lowres - screen size /4
#define TO_SCREENAVGMAP 0xfc1 // average screen color, 2x2
#define TO_DOFMAP 0xfc2 // dof map - contains focal distance
#define TO_REFRACTMAP 0xfa8
#define TO_REFRACTSCREENMAP 0xfa9
#define TO_ENVIRONMENT_LIGHTCUBE_MAP_REAL 0xf00
#define TO_ENVIRONMENT_LIGHTCUBE_MAP_REAL_MAX TO_ENVIRONMENT_LIGHTCUBE_MAP_REAL + MAX_ENVLIGHTCUBEMAPS
#define TO_ENVIRONMENT_CUBE_MAP_REAL 0xf40
#define TO_ENVIRONMENT_CUBE_MAP_REAL_MAX TO_ENVIRONMENT_CUBE_MAP_REAL + MAX_ENVCUBEMAPS
#define TO_ENVIRONMENT_TEX_MAP_REAL 0xf80
#define TO_ENVIRONMENT_TEX_MAP_REAL_MAX 0xf80 + MAX_ENVTEXTURES
#define TF_USEPAL 1
#define NUM_HDR_TONEMAP_TEXTURES 4
#define NUM_HDR_BLOOM_TEXTURES 3
#define NUM_HDR_STAR_TEXTURES 12
_inline int ilog2( int n )
{
int k, c;
if (n<=0)
return 0;
k = c = 0;
while (true)
{
if (n & 1)
c++;
if (!(n>>=1))
break;
k++;
}
if (c <= 1)
return 1<<k;
else
return 1<<(k+1);
}
////////////////////////////////////////////////////////////////////////////////////
// CBaseMap: Base class so that different implementations can be stored together //
////////////////////////////////////////////////////////////////////////////////////
class CBaseMap
{
protected:
uint m_dwWidth, m_dwHeight;
uint m_dwLevels;
public:
STexPic *m_pTex;
CBaseMap()
{
m_dwWidth = m_dwHeight = 1;
m_dwLevels = 0;
m_pTex = NULL;
}
~CBaseMap()
{
m_pTex = NULL;
}
virtual HRESULT Initialize() = 0;
};
struct SBoxCol
{
UCol m_Colors[6];
};
struct SRefTex
{
SRefTex()
{
memset(this, 0, sizeof(SRefTex));
#ifndef _XBOX
m_Pal = -1;
#endif
}
void *m_VidTex;
int m_Type;
byte bRepeats, bProjected;
int m_MipFilter;
int m_MinFilter;
int m_MagFilter;
int m_AnisLevel;
#ifndef _XBOX
int m_Pal;
#else
D3DPalette* m_pPal;
#endif
};
struct STexLoaded
{
int m_NumTextures;
STexPic * m_Textures[7];
};
typedef std::map<long,STexLoaded*> LoadedTexsMap;
typedef LoadedTexsMap::iterator LoadedTexsMapItor;
#define TEXTGT_2D 0
#define TEXTGT_CUBEMAP 1
#define TEXTGT_3D 2
struct SDtex
{
char m_Name[32];
int m_Width, m_Height;
int m_Offset; // source data stored
char m_AnimName[32]; // next frame in animation chain
ETEX_Format m_ETF;
int m_Flags;
int m_InFlags;
int m_Contents;
int m_Value;
int m_Color[3];
};
struct STexPool;
struct STexPoolItem
{
STexPic *m_pTex;
STexPool *m_pOwner;
STexPoolItem *m_Next;
STexPoolItem *m_Prev;
STexPoolItem *m_NextFree;
STexPoolItem *m_PrevFree;
void *m_pAPITexture;
float m_fLastTimeUsed;
STexPoolItem ()
{
m_pTex = NULL;
m_pAPITexture = NULL;
m_pOwner = NULL;
m_Next = NULL;
m_Prev = NULL;
m_NextFree = NULL;
m_PrevFree = NULL;
}
_inline void Unlink()
{
if (!m_Next || !m_Prev)
return;
m_Next->m_Prev = m_Prev;
m_Prev->m_Next = m_Next;
m_Next = m_Prev = NULL;
}
_inline void Link( STexPoolItem* Before )
{
if (m_Next || m_Prev)
return;
m_Next = Before->m_Next;
Before->m_Next->m_Prev = this;
Before->m_Next = this;
m_Prev = Before;
}
_inline void UnlinkFree()
{
if (!m_NextFree || !m_PrevFree)
return;
m_NextFree->m_PrevFree = m_PrevFree;
m_PrevFree->m_NextFree = m_NextFree;
m_NextFree = m_PrevFree = NULL;
}
_inline void LinkFree( STexPoolItem* Before )
{
if (m_NextFree || m_PrevFree)
return;
m_NextFree = Before->m_NextFree;
Before->m_NextFree->m_PrevFree = this;
Before->m_NextFree = this;
m_PrevFree = Before;
}
};
struct STexPool
{
int m_Width;
int m_Height;
int m_Format;
ETexType m_eTT;
int m_nMips;
int m_Size;
void *m_pSysTexture; // System texture for updating
TArray <void *> m_SysSurfaces; // List of system surfaces for updating
STexPoolItem m_ItemsList;
};
struct STexUploadInfo
{
int nStartMip;
int nEndMip;
int m_TexId;
STexPic *m_pTex;
int m_LoadedSize;
};
#define TEXCACHE_VERSION 1
struct STexCacheFileHeader
{
int m_Version;
int m_SizeOf;
byte m_nSides;
byte m_nMips;
char m_sExt[6];
char m_sETF[16];
int m_DstFormat;
bool m_bPolyBump;
bool m_bCloneSpace;
FILETIME m_WriteTime[2];
};
struct STexCacheMipHeader
{
int m_SizeOf;
short m_USize;
short m_VSize;
int m_Size;
int m_SizeWithMips;
};
//
// Base mipmap.
//
struct SMipmapBase
{
public:
byte* DataPtr; // Pointer to data, valid only when locked.
int USize, VSize; // Power of two tile dimensions.
int DXTSize;
SMipmapBase(int InUSize, int InVSize) : DataPtr(0), USize(InUSize), VSize(InVSize) {}
SMipmapBase() {}
virtual ~SMipmapBase() { DataPtr = NULL; }
};
//
// Texture mipmap.
//
struct SMipmap : public SMipmapBase
{
public:
TArray<byte> DataArray; // Data.
bool m_bUploaded;
bool m_bLoading;
SMipmap()
{
m_bUploaded = false;
m_bLoading = false;
}
SMipmap(int InUSize, int InVSize) : SMipmapBase(InUSize, InVSize), m_bUploaded(false), m_bLoading(false) {}
SMipmap(int InUSize, int InVSize, int InSize) : SMipmapBase(InUSize, InVSize), DataArray(InSize), m_bUploaded(false), m_bLoading(false) {}
virtual ~SMipmap() { DataArray.Free(); }
void Clear()
{
DataArray.Clear();
m_bUploaded = false;
m_bLoading = false;
}
void Init(int InUSize, int InVSize, int InSize)
{
DataArray.Reserve(InSize);
USize = InUSize;
VSize = InVSize;
DataPtr = NULL;
m_bUploaded = false;
m_bLoading = false;
}
};
struct STexShadow
{
STexShadow();
~STexShadow();
bool Init(byte *pHeightMap, int Width, int Height, bool bHeightmap);
void BuildBasisMap(byte *pBasis, float PrimAngle, float fAngle2);
void BuildHorizonMap_FromHeightmap(BYTE *pHor, byte* pHeight, FLOAT dx, FLOAT dy, INT iStepLength, INT iWidth,INT iHeight,BOOL bWrapU,BOOL bWrapV);
void BuildHorizonMap_FromNormalmap(BYTE *pHor, byte* pHeight, FLOAT dx, FLOAT dy, INT iStepLength, INT iWidth,INT iHeight,BOOL bWrapU,BOOL bWrapV);
bool BuildInterleavedMap(UCol *newTex, BYTE *r, BYTE *g, BYTE *b, BYTE *a, INT width, INT height);
// scratch space for loading/computing the textures
static STexPic *m_pBasisTex[2];
STexPic *m_pHorizonTex[2];
};
class CTextureStreamCallback : public IStreamCallback
{
virtual void StreamOnComplete (IReadStream* pStream, unsigned nError);
};
struct STexCacheInfo
{
CTextureStreamCallback m_Callback;
int m_TexId;
int m_nStartLoadMip;
int m_nEndLoadMip;
int m_nSizeToLoad;
int m_nCubeSide;
void *m_pTempBufferToStream;
float m_fStartTime;
STexCacheInfo()
{
memset(&m_TexId, 0, sizeof(*this)-sizeof(CTextureStreamCallback));
}
~STexCacheInfo()
{
SAFE_DELETE_ARRAY(m_pTempBufferToStream);
}
};
#ifdef WIN64
#pragma warning( push ) //AMD Port
#pragma warning( disable : 4267 ) // conversion from 'size_t' to 'int', possible loss of data
#endif
struct STexPic : ITexPic
{
STexPic()
{
if (!m_Root.m_Next)
{
m_Root.m_Next = &m_Root;
m_Root.m_Prev = &m_Root;
}
m_CacheID = -1;
m_Depth = 1;
}
int Size(int Flags)
{
int nSize = sizeof(*this);
nSize += m_SourceName.size();
nSize += m_Name.size();
if (m_pPalette)
nSize += sizeof(SRGBPixel) * 256;
if (m_pData32)
nSize += m_Width * m_Height * 4;
if (m_p8to24table)
nSize += 256 * sizeof(uint);
if (m_p15to8table)
nSize += 32768;
return nSize;
}
virtual void AddRef()
{
m_nRefCounter++;
}
virtual void Release(int bForce);
virtual void ReleaseDriverTexture();
virtual void SetClamp(bool bEnable);
virtual void SetFilter();
virtual void SetWrapping();
virtual const char *GetName();
virtual void Set(int nTexSlot=-1);
virtual int GetWidth();
virtual int GetHeight();
virtual int GetOriginalWidth()
{
return m_WidthOriginal;
}
virtual int GetOriginalHeight()
{
return m_HeightOriginal;
}
virtual int GetTextureID();
virtual bool IsTextureLoaded();
virtual int GetFlags()
{
return m_Flags;
}
virtual int GetFlags2()
{
return m_Flags2;
}
virtual byte *GetData32();
virtual void SaveTGA(const char *name, bool bMips);
virtual void SaveJPG(const char *name, bool bMips);
virtual void PrecacheAsynchronously(float fDist, int Flags);
virtual void Preload (int Flags);
virtual int DstFormatFromTexFormat(ETEX_Format eTF);
virtual int TexSize(int Width, int Height, int DstFormat);
virtual bool SetFilter(int nFilter);
void Unload();
void Restore();
int GetFileNames(char *name0, char *name1, int nLen);
void GetCacheName(char *name);
void SaveToCache();
void LoadFromCache(int Flags, float fDist);
void CreateMips();
void RemoveMips(int nFromEnd);
bool AddToPool(int nStartMip, int nMips);
void RemoveFromPool();
void RemoveFromSearchHash();
void AddToSearchHash();
STexPic *LoadFromCache(STexPic *ti, int flags, int flags2, char *texName, const char *szModelName);
bool CreateCacheFile();
virtual void BuildMips();
virtual bool UploadMips(int nStartMip, int nEndMip);
void FakeUploadMips(int nStartMip, int nEndMip);
_inline void Relink(STexPic* Before)
{
if (!IsStreamed())
return;
if (m_Next && m_Prev)
{
m_Next->m_Prev = m_Prev;
m_Prev->m_Next = m_Next;
}
m_Next = Before->m_Next;
Before->m_Next->m_Prev = this;
Before->m_Next = this;
m_Prev = Before;
}
_inline void Unlink()
{
if (!m_Next || !m_Prev)
return;
m_Next->m_Prev = m_Prev;
m_Prev->m_Next = m_Next;
m_Next = m_Prev = NULL;
}
_inline void Link( STexPic* Before )
{
if (m_Next || m_Prev)
return;
m_Next = Before->m_Next;
Before->m_Next->m_Prev = this;
Before->m_Next = this;
m_Prev = Before;
}
_inline bool IsStreamed()
{
if (m_ETF == eTF_Index || m_ETF == eTF_DSDT_MAG)
return false;
if (!m_Size || !m_Id || (m_Flags & FT_NOSTREAM))
return false;
return true;
}
int UpdateMip(float fDist);
bool ValidateMipsData(int nStartMip, int nEndMip);
STexPic *m_Next;
STexPic *m_Prev;
uint m_Bind;
uint m_TargetType;
int m_AccessFrame;
SRefTex m_RefTex;
uint m_Flags;
uint m_Flags2;
int m_Size;
ETexType m_eTT;
int m_nMips;
CBaseMap *m_pFuncMap;
STexLoaded *m_TL;
STexShadow *m_pSH;
int m_Id;
bool m_bBusy;
string m_SourceName;
string m_Name;
CName m_SearchName;
int m_DXTSize;
int m_CubeSide;
int m_Width;
int m_Height;
int m_Depth;
int m_WidthOriginal;
int m_HeightOriginal;
float m_fAnimSpeed;
float m_fAmount1;
float m_fAmount2;
int m_DstFormat;
ETEX_Format m_ETF;
STexPic *m_NextTxt;
STexPic *m_NextCMSide;
float *m_Matrix;
byte *m_pData32;
int m_nRefCounter;
// Used for Caching/Streaming
int m_nFrameCache;
float m_fMinDistance;
STexPoolItem *m_pPoolItem;
int m_CacheID;
short m_nBaseMip;
short m_nCustomMip;
FILETIME m_WriteTime;
int m_LoadFrame;
int m_LoadedSize;
SMipmap **m_Mips[6]; // Mipmaps in native format.
STexCacheFileHeader m_CacheFileHeader;
STexCacheMipHeader *m_pFileTexMips;
// For paletted textures
SRGBPixel *m_pPalette;
byte *m_pData;
bool m_bAlphaPal;
uint *m_p8to24table;
uchar *m_p15to8table;
static STexPic m_Root;
#ifdef DEBUGALLOC
#undef new
#endif
void* operator new( size_t Size )
{
void *ptr = malloc(Size);
memset(ptr, 0, Size);
return ptr;
}
void operator delete( void *ptr )
{
free (ptr);
}
static bool SaveTga(unsigned char *sourcedata,int sourceformat,int w,int h,const char *filename,bool flip);
};
struct STexGrid
{
int m_Width;
int m_Height;
STexPic *m_TP;
};
class CTexMan
{
friend struct STexPic;
protected:
int m_MinFilter;
int m_MagFilter;
int m_MipFilter;
int m_CurTexMaxSize;
int m_CurTexMinSize;
int m_CurTexSkyResolution;
int m_CurTexSkyQuality;
int m_CurTexResolution;
int m_CurTexQuality;
int m_CurTexBumpResolution;
int m_CurTexBumpQuality;
int m_CurTexNormalMapCompressed;
LoadedTexsMap m_TexsMap;
int m_CurCubemapBind;
int m_CurMotionId;
int m_CurMotionTexSize;
private:
_inline void FillRGBA_32to32(byte *dst, byte *src, int width, int height)
{
int Size = width*height;
for(int i=0; i<Size; i++)
{
dst[0] = src[2];
dst[1] = src[1];
dst[2] = src[0];
dst[3] = src[3];
src += 4;
dst += 4;
}
}
_inline void FillRGBA_32to32(byte *dst, byte *src, int Size)
{
for(int i=0; i<Size; i++)
{
dst[0] = src[2];
dst[1] = src[1];
dst[2] = src[0];
dst[3] = src[3];
src += 4;
dst += 4;
}
}
_inline void FillBGRA_32to32(byte *dst, byte *src, int width, int height)
{
int Size = width*height;
for(int i=0; i<Size; i++)
{
dst[0] = src[2];
dst[1] = src[1];
dst[2] = src[0];
dst[3] = src[3];
src += 4;
dst += 4;
}
}
_inline void FillBGRA_32to32(byte *dst, byte *src, int Size)
{
for(int i=0; i<Size; i++)
{
dst[0] = src[2];
dst[1] = src[1];
dst[2] = src[0];
dst[3] = src[3];
src += 4;
dst += 4;
}
}
_inline void FillRGBA_24to32(byte *dst, byte *src, int width, int height)
{
int Size = width*height;
for(int i=0; i<Size; i++)
{
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = 255;
src += 3;
dst += 4;
}
}
_inline void FillRGBA_24to32(byte *dst, byte *src, int Size)
{
for(int i=0; i<Size; i++)
{
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = 255;
src += 3;
dst += 4;
}
}
_inline void FillBGRA_24to32(byte *dst, byte *src, int width, int height)
{
int Size = width*height;
for(int i=0; i<Size; i++)
{
dst[0] = src[2];
dst[1] = src[1];
dst[2] = src[0];
dst[3] = 255;
src += 3;
dst += 4;
}
}
_inline void FillBGRA_24to32(byte *dst, byte *src, int Size)
{
for(int i=0; i<Size; i++)
{
dst[0] = src[2];
dst[1] = src[1];
dst[2] = src[0];
dst[3] = 255;
src += 3;
dst += 4;
}
}
_inline void FillRGBA_8to32(byte *dst, byte *src, byte pal[256][4], int width, int height, STexPic *ti)
{
int l;
int a = 255;
int Size = width*height;
for(int i=0; i<Size; i++)
{
l = src[i];
dst[0] = pal[l][0];
dst[1] = pal[l][1];
dst[2] = pal[l][2];
dst[3] = pal[l][3];
a &= pal[l][3];
dst += 4;
}
if (a != 255)
ti->m_Flags |= FT_HASALPHA;
}
_inline void FillRGBA_8to32(byte *dst, byte *src, byte pal[256][4], int Size, STexPic *ti)
{
int l;
int a = 255;
for(int i=0; i<Size; i++)
{
l = src[i];
dst[0] = pal[l][0];
dst[1] = pal[l][1];
dst[2] = pal[l][2];
dst[3] = pal[l][3];
a &= pal[l][3];
dst += 4;
}
if (a != 255)
ti->m_Flags |= FT_HASALPHA;
}
_inline void FillBGRA_8to32(byte *dst, byte *src, byte pal[256][4], int width, int height, STexPic *ti)
{
int l;
int a = 255;
int Size = width*height;
for(int i=0; i<Size; i++)
{
l = src[i];
dst[0] = pal[l][2];
dst[1] = pal[l][1];
dst[2] = pal[l][0];
dst[3] = pal[l][3];
a &= pal[l][3];
dst += 4;
}
if (a != 255)
ti->m_Flags |= FT_HASALPHA;
}
_inline void FillBGRA_8to32(byte *dst, byte *src, byte pal[256][4], int Size, STexPic *ti)
{
int l;
int a = 255;
for(int i=0; i<Size; i++)
{
l = src[i];
dst[0] = pal[l][2];
dst[1] = pal[l][1];
dst[2] = pal[l][0];
dst[3] = pal[l][3];
a &= pal[l][3];
dst += 4;
}
if (a != 255)
ti->m_Flags |= FT_HASALPHA;
}
protected:
void MipMap8Bit (STexPic *ti, byte *in, byte *out, int width, int height);
void MipMap32Bit (STexPic *ti, byte *in, byte *out, int width, int height);
void ImgResample(uint *out, int ox, int oy, uint *in, int ix, int iy);
void ImgResample8(byte *out, int ox, int oy, byte *in, int ix, int iy);
void ImagePreprocessing(CImageFile* im, uint flags, uint flags2, byte eTT, STexPic *ti);
void GenerateNormalMap(CImageFile** im, uint flags, uint flags2, byte eTT, float fAmount1, float fAmount2, STexPic *ti);
byte *GenerateNormalMap(byte *src, int width, int height, uint flags, uint flags2, byte eTT, float fAmount, STexPic *ti, int& nMips, int& nSize, ETEX_Format eTF);
void MergeNormalMaps(byte *src[2], CImageFile *im[2], int nMips[2]);
STexPic *TextureInfoForName(const char *nameTex, int numT, byte eTT, uint flags, uint flags2, int bind);
STexPic *LoadFromImage (const char *name, uint flags, uint flags2, byte eTT, int bind, STexPic *ti, float fAmount1=-1.0f, float fAmount2=-1.0f);
STexPic *UploadImage(CImageFile* im, const char *name, uint flags, uint flags2, byte eTT, int bind, STexPic *ti, float fAmount1=-1.0f, float fAmount2=-1.0f);
byte *ConvertRGB_Gray(byte *src, STexPic *ti, int flags, ETEX_Format eTF);
void BuildImageGamma(int wdt, int hgt, byte *dst, bool bHasAlpha);
public:
CTexMan();
virtual ~CTexMan() {};
int GetMinFilter() {return m_MinFilter;}
int GetMagFilter() {return m_MagFilter;}
int GetMipFilter() {return m_MipFilter;}
byte *ImgConvertDXT_RGBA(byte *dst, STexPic *ti, int DXTSize);
byte *ImgConvertRGBA_DXT(byte *dst, STexPic *ti, int& DXTSize, int& nMips, int bits, bool bUseExistingMips);
void Shutdown(void);
virtual bool GetCubeColor(Vec3 *Pos, CFColor *cols);
virtual bool SetFilter(char *filt)=0;
virtual void UpdateTextureData(STexPic *pic, byte *data, int USize, int VSize, bool bProc, int State, bool bPal)=0;
virtual void UpdateTextureRegion(STexPic *pic, byte *data, int X, int Y, int USize, int VSize)=0;
virtual STexPic *CreateTexture()=0;
virtual STexPic *CreateTexture(const char *name, int wdt, int hgt, int depth, uint flags, uint flags2, byte *dst, ETexType eTT, float fAmount1=-1.0f, float fAmount2=-1.0f, int DXTSize=0, STexPic *ti=NULL, int bind=0, ETEX_Format eTF=eTF_8888, const char *szSourceName=NULL)=0;
virtual STexPic *CopyTexture(const char *name, STexPic *ti, int CubeSide=-1)=0;
virtual byte *GenerateDXT_HW(STexPic *ti, EImFormat eF, byte *dst, int *numMips, int *DXTSize, bool bMips=true) = 0;
virtual bool IsTextureLoaded(const char *pName);
virtual void ReloadTextures ();
virtual void PreloadTextures (int Flags);
virtual void DrawToTexture(Plane& Pl, STexPic *Tex, int RendFlags)=0;
virtual void DrawToTextureForGlare(int Id)=0;
virtual void DrawToTextureForRainMap(int Id)=0;
virtual void StartHeatMap(int Id)=0;
virtual void EndHeatMap()=0;
virtual void StartRefractMap(int Id)=0;
virtual void EndRefractMap()=0;
virtual void StartNightMap(int Id)=0;
virtual void EndNightMap()=0;
virtual void DrawFlashBangMap(int Id, int RendFlags, CREFlashBang *pRE)=0;
virtual void StartScreenMap(int Id)=0;
virtual void EndScreenMap()=0;
virtual void StartScreenTexMap(int Id)=0;
virtual void EndScreenTexMap()=0;
virtual void DrawToTextureForDof(int Id)=0;
virtual bool PreloadScreenFxMaps(void)=0;
virtual bool ScanEnvironmentCM (const char *name, int size, Vec3d& Pos)=0;
virtual void GetAverageColor(SEnvTexture *cm, int nSide)=0;
virtual void ScanEnvironmentCube(SEnvTexture *cm, int RendFlags, int Size, bool bLightCube)=0;
virtual void ScanEnvironmentTexture(SEnvTexture *cm, SShader *pSH, SRenderShaderResources *pRes, int RendFlags, bool bUseExistingREs)=0;
virtual void EndCubeSide(CCObject *obj, bool bNeedClear)=0;
virtual void StartCubeSide(CCObject *obj)=0;
virtual void Update()=0;
virtual void SetGridTexture(STexPic *tp);
void UnloadOldTextures(STexPic *pExclude);
bool CreateCacheFile();
STexPic *LoadFromCache(STexPic *ti, int flags, int flags2, char *texName, const char *szModelName, ETexType eTT);
void CreatePools();
STexPool *CreatePool(int nWidth, int nHeight, int nMips, int nFormat, ETexType eTT);
virtual STexPic *GetByID(int Id)=0;
virtual STexPic *GetByName(const char *szName);
virtual STexPic *AddToHash(int Id, STexPic *ti) {return NULL;}
virtual void RemoveFromHash(int Id, STexPic *ti) {};
virtual void SetTexture(int Id, ETexType eTT) {};
virtual void GenerateFuncTextures()=0;
virtual void LoadDefaultTextures();
STexPic *LoadTexture(const char* nameTex, uint flags, uint flags2, byte eTT=eTT_Base, float fAmount1=-1.0f, float fAmount2=-1.0f, int bind=0, int numT=-1);
STexPic *LoadCubeTex(const char *mapname, uint flags, uint flags2, int State, byte eTT, int RState, int Id, int BindId, float fAmount=-1.0f);
void ClearAll(int nFlags);
void ReloadAll(int nFlags);
bool ReloadFile(const char *fileName, int nFlags);
_inline int GetCurTMU() { return m_CurStage; }
void ValidateTexSize();
void CheckTexLimits(STexPic *pExclude);
byte *ConvertNMToPalettedFormat(byte *src, STexPic *ti, ETEX_Format eTF=eTF_0888);
void GenerateNMPalette();
public:
static bool m_bRGBA;
static int m_CurStage;
static int m_nCurStages;
short m_nEnvCX, m_nEnvCY, m_nEnvCZ;
SBoxCol *m_EnvGridColors;
STexPic *m_LastTex;
char m_CurTexFilter[128];
int m_CurAnisotropic;
SRGBPixel m_NMPalette[16][16];
byte m_NMPaletteLookup[256];
bool m_bPaletteWasLoaded;
void *m_pCurCubeTexture;
STexPic *m_CurCubeFaces[6];
TArray<STexGrid> m_TGrids;
int m_nTexSizeHistory;
int m_TexSizeHistory[8];
int m_nProcessedTextureID1;
STexPic *m_pProcessedTexture1;
int m_nProcessedTextureID2;
STexPic *m_pProcessedTexture2;
int m_nPhaseProcessingTextures;
int m_nCustomMip;
byte m_TexData[256*256*4];
int m_StatsCurTexMem;
TArray<STexPic *>m_Textures;
TArray<int> m_FreeSlots;
STexPic *m_FirstCMSide;
STexPic *m_LastCMSide;
STexPic *m_LastCMStreamed;
CResFile *m_TexCache;
int m_LoadBytes;
int m_UpLoadBytes;
int m_Streamed;
float m_fStreamDistFactor;
STexPic *m_Text_White;
STexPic *m_Text_WhiteShadow;
STexPic *m_Text_WhiteBump;
STexPic *m_Text_Gradient;
STexPic *m_Text_Depth;
STexPic *m_Text_Atten2D;
STexPic *m_Text_Atten1D;
STexPic *m_Text_Edge;
STexPic *m_Text_NoTexture;
STexPic *m_Text_NoiseVolumeMap;
STexPic *m_Text_NormalizeCMap;
STexPic *m_Text_EnvLCMap; // Use for scan environment to CubeMap
STexPic *m_Text_EnvCMap; // Use for scan environment to CubeMap
STexPic *m_Text_EnvTex; // Use for scan environment to Texture
STexPic *m_Text_EnvScr; // Use for scan environment to Texture
STexPic *m_Text_Glare;
STexPic *m_Text_HeatMap;
STexPic *m_Text_FurNormalMap;
STexPic *m_Text_FurLightMap;
STexPic *m_Text_Fur;
STexPic *m_Text_RefractMap;
STexPic *m_Text_WaterMap;
STexPic *m_Text_MotionBlurMap;
STexPic *m_Text_NightVisMap;
STexPic *m_Text_FlashBangMap;
STexPic *m_Text_RainMap;
STexPic *m_Text_LightCMap;
STexPic *m_Text_FromRE[8];
STexPic *m_Text_FromObj;
STexPic *m_Text_FromLight;
STexPic *m_Text_Fog;
STexPic *m_Text_Fog_Enter;
STexPic *m_Text_VFog;
STexPic *m_Text_Flare;
STexPic *m_Text_Ghost;
STexPic *m_Text_DepthLookup;
STexPic *m_Text_FlashBangFlash; // flash texture used in flasgbang fx
STexPic *m_Text_ScreenNoise; // screen noise texture
STexPic *m_Text_HeatPalete; // heat vision pallete texture
STexPic *m_Text_ScreenMap; // screen buffer
STexPic *m_Text_ScreenMap_HDR; // screen buffer
STexPic *m_Text_PrevScreenMap; // previous screen buffer
STexPic *m_Text_ScreenLuminosityMap; // screen luminosity map
STexPic *m_Text_ScreenCurrLuminosityMap; // current screen luminosity map
STexPic *m_Text_ScreenLowMap; // screen buffer size/4
STexPic *m_Text_ScreenAvg1x1; // average screen buffer 2x2
STexPic *m_Text_DofMap; // depth of field texture
STexPic *m_Text_Gray;
STexPic *m_Text_HDRTarget;
//STexPic *m_Text_HDRTarget_K;
STexPic *m_Text_HDRTarget_Temp;
STexPic *m_Text_HDRTargetScaled[2];
STexPic *m_Text_HDRBrightPass;
STexPic *m_Text_HDRStarSource;
STexPic *m_Text_HDRBloomSource;
STexPic *m_Text_HDRAdaptedLuminanceCur;
STexPic *m_Text_HDRAdaptedLuminanceLast;
STexPic *m_Text_HDRToneMaps[NUM_HDR_TONEMAP_TEXTURES];
STexPic *m_Text_HDRBloomMaps[NUM_HDR_BLOOM_TEXTURES];
STexPic *m_Text_HDRStarMaps[NUM_HDR_STAR_TEXTURES][2];
SEnvTexture m_EnvLCMaps[MAX_ENVLIGHTCUBEMAPS];
SEnvTexture m_EnvCMaps[MAX_ENVCUBEMAPS];
SEnvTexture m_EnvTexts[MAX_ENVTEXTURES];
SEnvTexture m_CustomCMaps[16];
SEnvTexture m_CustomTextures[16];
TArray<STexPool *> m_TexPools;
STexPoolItem m_FreeTexPoolItems;
STexPic m_Templates[EFTT_MAX];
#ifdef DEBUGALLOC
#undef new
#endif
void* operator new( size_t Size ) { void *ptr = malloc(Size); memset(ptr, 0, Size); return ptr; }
void operator delete( void *Ptr ) { free(Ptr); }
#ifdef DEBUGALLOC
#define new DEBUG_CLIENTBLOCK
#endif
};
void WriteJPG(byte *dat, int wdt, int hgt, char *name);
void WriteTGA(byte *dat, int wdt, int hgt, char *name, int dest_bits_per_pixel=24);
_inline void WriteTGA32(byte *dat, int wdt, int hgt, char *name)
{
WriteTGA(dat, wdt, hgt, name, 32);
}
void WriteDDS(byte *dat, int wdt, int hgt, int Size, const char *name, EImFormat eF, int NumMips);
ETEX_Format sImageFormat2TexFormat(EImFormat eImF);
#ifdef WIN64
#pragma warning( pop ) //AMD Port
#endif
#endif
Reference in New Issue View Git Blame Copy Permalink