BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/materialsystem/texturemanager.cpp

3103 lines
91 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//===========================================================================//
#include <stdlib.h>
#include <malloc.h>
#include "materialsystem_global.h"
#include "string.h"
#include "shaderapi/ishaderapi.h"
#include "materialsystem/materialsystem_config.h"
#include "IHardwareConfigInternal.h"
#include "texturemanager.h"
#include "materialsystem/imaterialvar.h"
#include "materialsystem/IColorCorrection.h"
#include "tier1/strtools.h"
#include "utlvector.h"
#include "utldict.h"
#include "itextureinternal.h"
#include "vtf/vtf.h"
#include "pixelwriter.h"
#include "basetypes.h"
#include "utlbuffer.h"
#include "filesystem.h"
#include "materialsystem/imesh.h"
#include "materialsystem/ishaderapi.h"
#include "vstdlib/random.h"
#include "imorphinternal.h"
#include "tier1/utlrbtree.h"
#include "tier1/utlpair.h"
#include "ctype.h"
#include "utlqueue.h"
#include "tier0/icommandline.h"
#include "ctexturecompositor.h"
#include "vprof_telemetry.h"
// Need lightmaps access here
#define MATSYS_INTERNAL
#include "cmatlightmaps.h"
#include "cmaterialsystem.h"
#undef MATSYS_INTERNAL
#include "tier0/memdbgon.h"
#define ERROR_TEXTURE_SIZE 32
#define WHITE_TEXTURE_SIZE 1
#define BLACK_TEXTURE_SIZE 1
#define GREY_TEXTURE_SIZE 1
#define NORMALIZATION_CUBEMAP_SIZE 32
struct AsyncLoadJob_t;
struct AsyncReadJob_t;
class AsyncLoader;
class AsyncReader;
#define MAX_READS_OUTSTANDING 2
static ImageFormat GetImageFormatRawReadback( ImageFormat fmt );
#ifdef STAGING_ONLY
static ConVar mat_texture_list_dump( "mat_texture_list_dump", "0" );
#endif
const char* cTextureCachePathDir = "__texture_cache";
// TODO: Relocate this somewhere else. It works like python's "strip" function,
// removing leading and trailing whitespace, including newlines. Whitespace between
// non-whitespace characters is preserved.
void V_StripWhitespace( char* pBuffer )
{
Assert( pBuffer );
char* pSrc = pBuffer;
char* pDst = pBuffer;
char* pDstFirstTrailingWhitespace = NULL;
// Remove leading whitespace
bool leading = true;
while ( *pSrc )
{
if ( leading )
{
if ( V_isspace( *pSrc ) )
{
++pSrc;
continue;
}
else
{
leading = false;
// Drop through
}
}
if ( pDst != pSrc )
*pDst = *pSrc;
if ( !leading && V_isspace( *pDst ) && pDstFirstTrailingWhitespace == NULL )
pDstFirstTrailingWhitespace = pDst;
else if ( !leading && !V_isspace( *pDst ) && pDstFirstTrailingWhitespace != NULL )
pDstFirstTrailingWhitespace = NULL;
++pSrc;
++pDst;
}
(*pDst) = 0;
if ( pDstFirstTrailingWhitespace )
( *pDstFirstTrailingWhitespace ) = 0;
}
//-----------------------------------------------------------------------------
//
// Various procedural texture regeneration classes
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Creates a checkerboard texture
//-----------------------------------------------------------------------------
class CCheckerboardTexture : public ITextureRegenerator
{
public:
CCheckerboardTexture( int nCheckerSize, color32 color1, color32 color2 ) :
m_nCheckerSize( nCheckerSize ), m_Color1(color1), m_Color2(color2)
{
}
virtual ~CCheckerboardTexture() { }
virtual void RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pSubRect )
{
for (int iFrame = 0; iFrame < pVTFTexture->FrameCount(); ++iFrame )
{
for (int iFace = 0; iFace < pVTFTexture->FaceCount(); ++iFace )
{
int nWidth = pVTFTexture->Width();
int nHeight = pVTFTexture->Height();
int nDepth = pVTFTexture->Depth();
for (int z = 0; z < nDepth; ++z)
{
// Fill mip 0 with a checkerboard
CPixelWriter pixelWriter;
pixelWriter.SetPixelMemory( pVTFTexture->Format(),
pVTFTexture->ImageData( iFrame, iFace, 0, 0, 0, z ), pVTFTexture->RowSizeInBytes( 0 ) );
for (int y = 0; y < nHeight; ++y)
{
pixelWriter.Seek( 0, y );
for (int x = 0; x < nWidth; ++x)
{
if ( ((x & m_nCheckerSize) ^ (y & m_nCheckerSize)) ^ (z & m_nCheckerSize) )
{
pixelWriter.WritePixel( m_Color1.r, m_Color1.g, m_Color1.b, m_Color1.a );
}
else
{
pixelWriter.WritePixel( m_Color2.r, m_Color2.g, m_Color2.b, m_Color2.a );
}
}
}
}
}
}
}
virtual void Release()
{
delete this;
}
private:
int m_nCheckerSize;
color32 m_Color1;
color32 m_Color2;
};
static void CreateCheckerboardTexture( ITextureInternal *pTexture, int nCheckerSize, color32 color1, color32 color2 )
{
ITextureRegenerator *pRegen = new CCheckerboardTexture( nCheckerSize, color1, color2 );
pTexture->SetTextureRegenerator( pRegen );
}
//-----------------------------------------------------------------------------
// Creates a solid texture
//-----------------------------------------------------------------------------
class CSolidTexture : public ITextureRegenerator
{
public:
CSolidTexture( color32 color ) : m_Color(color)
{
}
virtual ~CSolidTexture() { }
virtual void RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pSubRect )
{
int nMipCount = pTexture->IsMipmapped() ? pVTFTexture->MipCount() : 1;
for (int iFrame = 0; iFrame < pVTFTexture->FrameCount(); ++iFrame )
{
for (int iFace = 0; iFace < pVTFTexture->FaceCount(); ++iFace )
{
for (int iMip = 0; iMip < nMipCount; ++iMip )
{
int nWidth, nHeight, nDepth;
pVTFTexture->ComputeMipLevelDimensions( iMip, &nWidth, &nHeight, &nDepth );
for (int z = 0; z < nDepth; ++z)
{
CPixelWriter pixelWriter;
pixelWriter.SetPixelMemory( pVTFTexture->Format(),
pVTFTexture->ImageData( iFrame, iFace, iMip, 0, 0, z ), pVTFTexture->RowSizeInBytes( iMip ) );
for (int y = 0; y < nHeight; ++y)
{
pixelWriter.Seek( 0, y );
for (int x = 0; x < nWidth; ++x)
{
pixelWriter.WritePixel( m_Color.r, m_Color.g, m_Color.b, m_Color.a );
}
}
}
}
}
}
}
virtual void Release()
{
delete this;
}
private:
color32 m_Color;
};
static void CreateSolidTexture( ITextureInternal *pTexture, color32 color )
{
ITextureRegenerator *pRegen = new CSolidTexture( color );
pTexture->SetTextureRegenerator( pRegen );
}
//-----------------------------------------------------------------------------
// Creates a normalization cubemap texture
//-----------------------------------------------------------------------------
class CNormalizationCubemap : public ITextureRegenerator
{
public:
virtual void RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pSubRect )
{
// Normalization cubemap doesn't make sense on low-end hardware
// So we won't construct a spheremap out of this
CPixelWriter pixelWriter;
Vector direction;
for (int iFace = 0; iFace < 6; ++iFace)
{
pixelWriter.SetPixelMemory( pVTFTexture->Format(),
pVTFTexture->ImageData( 0, iFace, 0 ), pVTFTexture->RowSizeInBytes( 0 ) );
int nWidth = pVTFTexture->Width();
int nHeight = pVTFTexture->Height();
float flInvWidth = 2.0f / (float)(nWidth-1);
float flInvHeight = 2.0f / (float)(nHeight-1);
for (int y = 0; y < nHeight; ++y)
{
float v = y * flInvHeight - 1.0f;
pixelWriter.Seek( 0, y );
for (int x = 0; x < nWidth; ++x)
{
float u = x * flInvWidth - 1.0f;
float oow = 1.0f / sqrt( 1.0f + u*u + v*v );
int ix = (int)(255.0f * 0.5f * (u*oow + 1.0f) + 0.5f);
ix = clamp( ix, 0, 255 );
int iy = (int)(255.0f * 0.5f * (v*oow + 1.0f) + 0.5f);
iy = clamp( iy, 0, 255 );
int iz = (int)(255.0f * 0.5f * (oow + 1.0f) + 0.5f);
iz = clamp( iz, 0, 255 );
switch (iFace)
{
case CUBEMAP_FACE_RIGHT:
pixelWriter.WritePixel( iz, 255 - iy, 255 - ix, 255 );
break;
case CUBEMAP_FACE_LEFT:
pixelWriter.WritePixel( 255 - iz, 255 - iy, ix, 255 );
break;
case CUBEMAP_FACE_BACK:
pixelWriter.WritePixel( ix, iz, iy, 255 );
break;
case CUBEMAP_FACE_FRONT:
pixelWriter.WritePixel( ix, 255 - iz, 255 - iy, 255 );
break;
case CUBEMAP_FACE_UP:
pixelWriter.WritePixel( ix, 255 - iy, iz, 255 );
break;
case CUBEMAP_FACE_DOWN:
pixelWriter.WritePixel( 255 - ix, 255 - iy, 255 - iz, 255 );
break;
default:
break;
}
}
}
}
}
// NOTE: The normalization cubemap regenerator is stateless
// so there's no need to allocate + deallocate them
virtual void Release() {}
};
//-----------------------------------------------------------------------------
// Creates a normalization cubemap texture
//-----------------------------------------------------------------------------
class CSignedNormalizationCubemap : public ITextureRegenerator
{
public:
virtual void RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pSubRect )
{
// Normalization cubemap doesn't make sense on low-end hardware
// So we won't construct a spheremap out of this
CPixelWriter pixelWriter;
Vector direction;
for (int iFace = 0; iFace < 6; ++iFace)
{
pixelWriter.SetPixelMemory( pVTFTexture->Format(),
pVTFTexture->ImageData( 0, iFace, 0 ), pVTFTexture->RowSizeInBytes( 0 ) );
int nWidth = pVTFTexture->Width();
int nHeight = pVTFTexture->Height();
float flInvWidth = 2.0f / (float)(nWidth-1);
float flInvHeight = 2.0f / (float)(nHeight-1);
for (int y = 0; y < nHeight; ++y)
{
float v = y * flInvHeight - 1.0f;
pixelWriter.Seek( 0, y );
for (int x = 0; x < nWidth; ++x)
{
float u = x * flInvWidth - 1.0f;
float oow = 1.0f / sqrt( 1.0f + u*u + v*v );
#ifdef DX_TO_GL_ABSTRACTION
float flX = (255.0f * 0.5 * (u*oow + 1.0f) + 0.5f);
float flY = (255.0f * 0.5 * (v*oow + 1.0f) + 0.5f);
float flZ = (255.0f * 0.5 * (oow + 1.0f) + 0.5f);
switch (iFace)
{
case CUBEMAP_FACE_RIGHT:
flX = 255.0f - flX;
flY = 255.0f - flY;
break;
case CUBEMAP_FACE_LEFT:
flY = 255.0f - flY;
flZ = 255.0f - flZ;
break;
case CUBEMAP_FACE_BACK:
break;
case CUBEMAP_FACE_FRONT:
flY = 255.0f - flY;
flZ = 255.0f - flZ;
break;
case CUBEMAP_FACE_UP:
flY = 255.0f - flY;
break;
case CUBEMAP_FACE_DOWN:
flX = 255.0f - flX;
flY = 255.0f - flY;
flZ = 255.0f - flZ;
break;
default:
break;
}
flX -= 128.0f;
flY -= 128.0f;
flZ -= 128.0f;
flX /= 128.0f;
flY /= 128.0f;
flZ /= 128.0f;
switch ( iFace )
{
case CUBEMAP_FACE_RIGHT:
pixelWriter.WritePixelF( flZ, flY, flX, 0.0f );
break;
case CUBEMAP_FACE_LEFT:
pixelWriter.WritePixelF( flZ, flY, flX, 0.0f );
break;
case CUBEMAP_FACE_BACK:
pixelWriter.WritePixelF( flX, flZ, flY, 0.0f );
break;
case CUBEMAP_FACE_FRONT:
pixelWriter.WritePixelF( flX, flZ, flY, 0.0f );
break;
case CUBEMAP_FACE_UP:
pixelWriter.WritePixelF( flX, flY, flZ, 0.0f );
break;
case CUBEMAP_FACE_DOWN:
pixelWriter.WritePixelF( flX, flY, flZ, 0.0f );
break;
default:
break;
}
#else
int ix = (int)(255 * 0.5 * (u*oow + 1.0f) + 0.5f);
ix = clamp( ix, 0, 255 );
int iy = (int)(255 * 0.5 * (v*oow + 1.0f) + 0.5f);
iy = clamp( iy, 0, 255 );
int iz = (int)(255 * 0.5 * (oow + 1.0f) + 0.5f);
iz = clamp( iz, 0, 255 );
switch (iFace)
{
case CUBEMAP_FACE_RIGHT:
ix = 255 - ix;
iy = 255 - iy;
break;
case CUBEMAP_FACE_LEFT:
iy = 255 - iy;
iz = 255 - iz;
break;
case CUBEMAP_FACE_BACK:
break;
case CUBEMAP_FACE_FRONT:
iy = 255 - iy;
iz = 255 - iz;
break;
case CUBEMAP_FACE_UP:
iy = 255 - iy;
break;
case CUBEMAP_FACE_DOWN:
ix = 255 - ix;
iy = 255 - iy;
iz = 255 - iz;
break;
default:
break;
}
ix -= 128;
iy -= 128;
iz -= 128;
Assert( ix >= -128 && ix <= 127 );
Assert( iy >= -128 && iy <= 127 );
Assert( iz >= -128 && iz <= 127 );
switch (iFace)
{
case CUBEMAP_FACE_RIGHT:
// correct
// pixelWriter.WritePixelSigned( -128, -128, -128, 0 );
pixelWriter.WritePixelSigned( iz, iy, ix, 0 );
break;
case CUBEMAP_FACE_LEFT:
// correct
// pixelWriter.WritePixelSigned( -128, -128, -128, 0 );
pixelWriter.WritePixelSigned( iz, iy, ix, 0 );
break;
case CUBEMAP_FACE_BACK:
// wrong
// pixelWriter.WritePixelSigned( -128, -128, -128, 0 );
pixelWriter.WritePixelSigned( ix, iz, iy, 0 );
// pixelWriter.WritePixelSigned( -127, -127, 127, 0 );
break;
case CUBEMAP_FACE_FRONT:
// wrong
// pixelWriter.WritePixelSigned( -128, -128, -128, 0 );
pixelWriter.WritePixelSigned( ix, iz, iy, 0 );
break;
case CUBEMAP_FACE_UP:
// correct
// pixelWriter.WritePixelSigned( -128, -128, -128, 0 );
pixelWriter.WritePixelSigned( ix, iy, iz, 0 );
break;
case CUBEMAP_FACE_DOWN:
// correct
// pixelWriter.WritePixelSigned( -128, -128, -128, 0 );
pixelWriter.WritePixelSigned( ix, iy, iz, 0 );
break;
default:
break;
}
#endif
} // x
} // y
} // iFace
}
// NOTE: The normalization cubemap regenerator is stateless
// so there's no need to allocate + deallocate them
virtual void Release() {}
};
static void CreateNormalizationCubemap( ITextureInternal *pTexture )
{
// NOTE: The normalization cubemap regenerator is stateless
// so there's no need to allocate + deallocate them
static CNormalizationCubemap s_NormalizationCubemap;
pTexture->SetTextureRegenerator( &s_NormalizationCubemap );
}
static void CreateSignedNormalizationCubemap( ITextureInternal *pTexture )
{
// NOTE: The normalization cubemap regenerator is stateless
// so there's no need to allocate + deallocate them
static CSignedNormalizationCubemap s_SignedNormalizationCubemap;
pTexture->SetTextureRegenerator( &s_SignedNormalizationCubemap );
}
//-----------------------------------------------------------------------------
// Creates a color correction texture
//-----------------------------------------------------------------------------
class CColorCorrectionTexture : public ITextureRegenerator
{
public:
CColorCorrectionTexture( ColorCorrectionHandle_t handle ) : m_ColorCorrectionHandle(handle)
{
}
virtual ~CColorCorrectionTexture() { }
virtual void RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pSubRect )
{
int nWidth = pVTFTexture->Width();
int nHeight = pVTFTexture->Height();
int nDepth = pVTFTexture->Depth();
Assert( nWidth == COLOR_CORRECTION_TEXTURE_SIZE && nHeight == COLOR_CORRECTION_TEXTURE_SIZE && nDepth == COLOR_CORRECTION_TEXTURE_SIZE );
for ( int z = 0; z < nDepth; ++z )
{
CPixelWriter pixelWriter;
pixelWriter.SetPixelMemory( pVTFTexture->Format(),
pVTFTexture->ImageData( 0, 0, 0, 0, 0, z ), pVTFTexture->RowSizeInBytes( 0 ) );
for ( int y = 0; y < nHeight; ++y )
{
pixelWriter.Seek( 0, y );
for (int x = 0; x < nWidth; ++x)
{
RGBX5551_t inColor;
inColor.r = x;
inColor.g = y;
inColor.b = z;
color24 col = ColorCorrectionSystem()->GetLookup( m_ColorCorrectionHandle, inColor );
pixelWriter.WritePixel( col.r, col.g, col.b, 255 );
}
}
}
}
virtual void Release()
{
delete this;
}
private:
ColorCorrectionHandle_t m_ColorCorrectionHandle;
};
void CreateColorCorrectionTexture( ITextureInternal *pTexture, ColorCorrectionHandle_t handle )
{
ITextureRegenerator *pRegen = new CColorCorrectionTexture( handle );
pTexture->SetTextureRegenerator( pRegen );
}
//-----------------------------------------------------------------------------
// Implementation of the texture manager
//-----------------------------------------------------------------------------
class CTextureManager : public ITextureManager
{
public:
CTextureManager( void );
// Initialization + shutdown
virtual void Init( int nFlags ) OVERRIDE;
virtual void Shutdown();
virtual void AllocateStandardRenderTargets( );
virtual void FreeStandardRenderTargets();
virtual void CacheExternalStandardRenderTargets();
virtual ITextureInternal *CreateProceduralTexture( const char *pTextureName, const char *pTextureGroupName, int w, int h, int d, ImageFormat fmt, int nFlags, ITextureRegenerator* generator = NULL );
virtual ITextureInternal *FindOrLoadTexture( const char *textureName, const char *pTextureGroupName, int nAdditionalCreationFlags = 0 );
virtual bool IsTextureLoaded( const char *pTextureName );
virtual void AddTextureAlias( const char *pAlias, const char *pRealName );
virtual void RemoveTextureAlias( const char *pAlias );
virtual void SetExcludedTextures( const char *pScriptName );
virtual void UpdateExcludedTextures();
virtual void ResetTextureFilteringState();
void ReloadTextures( void );
// These are used when we lose our video memory due to a mode switch etc
void ReleaseTextures( void );
void RestoreNonRenderTargetTextures( void );
void RestoreRenderTargets( void );
// Suspend or resume texture streaming requests
void SuspendTextureStreaming( void );
void ResumeTextureStreaming( void );
// delete any texture that has a refcount <= 0
void RemoveUnusedTextures( void );
void DebugPrintUsedTextures( void );
// Request a texture ID
virtual int RequestNextTextureID();
// Get at a couple standard textures
virtual ITextureInternal *ErrorTexture();
virtual ITextureInternal *NormalizationCubemap();
virtual ITextureInternal *SignedNormalizationCubemap();
virtual ITextureInternal *ShadowNoise2D();
virtual ITextureInternal *IdentityLightWarp();
virtual ITextureInternal *ColorCorrectionTexture( int i );
virtual ITextureInternal *FullFrameDepthTexture();
virtual ITextureInternal *DebugLuxels2D();
// Generates an error texture pattern
virtual void GenerateErrorTexture( ITexture *pTexture, IVTFTexture *pVTFTexture );
// Updates the color correction state
virtual void SetColorCorrectionTexture( int i, ITextureInternal *pTexture );
virtual void ForceAllTexturesIntoHardware( void );
virtual ITextureInternal *CreateRenderTargetTexture(
const char *pRTName, // NULL for auto-generated name
int w,
int h,
RenderTargetSizeMode_t sizeMode,
ImageFormat fmt,
RenderTargetType_t type,
unsigned int textureFlags,
unsigned int renderTargetFlags );
virtual bool HasPendingTextureDestroys() const;
virtual void MarkUnreferencedTextureForCleanup( ITextureInternal *pTexture );
virtual void RemoveTexture( ITextureInternal *pTexture );
virtual void ReloadFilesInList( IFileList *pFilesToReload );
// start with -1, list terminates with -1
virtual int FindNext( int iIndex, ITextureInternal **ppTexture );
virtual void ReleaseTempRenderTargetBits( void );
// Called once per frame by material system "somewhere."
virtual void Update();
// Load a texture asynchronously and then call the provided callback.
virtual void AsyncFindOrLoadTexture( const char *pTextureName, const char *pTextureGroupName, IAsyncTextureOperationReceiver* pRecipient, void* pExtraArgs, bool bComplain, int nAdditionalCreationFlags );
void CompleteAsyncLoad( AsyncLoadJob_t* pJob );
virtual void AsyncCreateTextureFromRenderTarget( ITexture* pSrcRt, const char* pDstName, ImageFormat dstFmt, bool bGenMips, int nAdditionalCreationFlags, IAsyncTextureOperationReceiver* pRecipient, void* pExtraArgs );
void CompleteAsyncRead( AsyncReadJob_t* pJob );
ITextureInternal* AcquireReadbackTexture( int w, int h, ImageFormat fmt );
void ReleaseReadbackTexture( ITextureInternal* pTex );
void WarmTextureCache();
void CoolTextureCache();
virtual void RequestAllMipmaps( ITextureInternal* pTex );
virtual void EvictAllTextures();
virtual void UpdatePostAsync();
virtual void ReleaseAsyncScratchVTF( IVTFTexture* pScratchVTF );
virtual bool ThreadInAsyncLoadThread() const;
virtual bool ThreadInAsyncReadThread() const;
virtual bool AddTextureCompositorTemplate( const char* pName, KeyValues* pTmplDesc ) OVERRIDE;
virtual bool VerifyTextureCompositorTemplates() OVERRIDE;
virtual CTextureCompositorTemplate* FindTextureCompositorTemplate( const char* pName ) OVERRIDE;
protected:
ITextureInternal *FindTexture( const char *textureName );
ITextureInternal *LoadTexture( const char *textureName, const char *pTextureGroupName, int nAdditionalCreationFlags = 0, bool bDownload = true );
void AsyncLoad( const AsyncLoadJob_t& job );
void AsyncReadTexture( AsyncReadJob_t* job );
// Restores a single texture
void RestoreTexture( ITextureInternal* pTex );
void CleanupPossiblyUnreferencedTextures();
#ifdef STAGING_ONLY
void DumpTextureList( );
#endif
void FindFilesToLoad( CUtlDict< int >* pOutFilesToLoad, const char* pFilename );
void ReadFilesToLoad( CUtlDict< int >* pOutFilesToLoad, const char* pFilename );
CUtlDict< ITextureInternal *, unsigned short > m_TextureList;
CUtlDict< const char *, unsigned short > m_TextureAliases;
CUtlDict< int, unsigned short > m_TextureExcludes;
CUtlDict< CCopyableUtlVector<AsyncLoadJob_t> > m_PendingAsyncLoads;
CUtlVector< ITextureInternal* > m_ReadbackTextures;
CUtlVector< ITextureInternal* > m_preloadedTextures;
CUtlMap< ITextureInternal*, int > m_textureStreamingRequests;
CTSQueue< ITextureInternal* > m_asyncStreamingRequests;
CTSQueue< ITextureInternal * > m_PossiblyUnreferencedTextures;
CUtlDict< CTextureCompositorTemplate *, unsigned short > m_TexCompTemplates;
int m_iNextTexID;
int m_nFlags;
ITextureInternal *m_pErrorTexture;
ITextureInternal *m_pBlackTexture;
ITextureInternal *m_pWhiteTexture;
ITextureInternal *m_pGreyTexture;
ITextureInternal *m_pGreyAlphaZeroTexture;
ITextureInternal *m_pNormalizationCubemap;
ITextureInternal *m_pFullScreenTexture;
ITextureInternal *m_pSignedNormalizationCubemap;
ITextureInternal *m_pShadowNoise2D;
ITextureInternal *m_pIdentityLightWarp;
ITextureInternal *m_pColorCorrectionTextures[ COLOR_CORRECTION_MAX_TEXTURES ];
ITextureInternal *m_pFullScreenDepthTexture;
ITextureInternal *m_pDebugLuxels2D;
// Used to generate various error texture patterns when necessary
CCheckerboardTexture *m_pErrorRegen;
friend class AsyncLoader;
AsyncLoader* m_pAsyncLoader;
friend class AsyncReader;
AsyncReader* m_pAsyncReader;
uint m_nAsyncLoadThread;
uint m_nAsyncReadThread;
int m_iSuspendTextureStreaming;
};
//-----------------------------------------------------------------------------
// Singleton instance
//-----------------------------------------------------------------------------
static CTextureManager s_TextureManager;
ITextureManager *g_pTextureManager = &s_TextureManager;
struct AsyncLoadJob_t
{
CUtlString m_TextureName;
CUtlString m_TextureGroupName;
IAsyncTextureOperationReceiver* m_pRecipient;
void* m_pExtraArgs;
bool m_bComplain;
int m_nAdditionalCreationFlags;
ITextureInternal* m_pResultData;
AsyncLoadJob_t()
: m_pRecipient( NULL )
, m_pExtraArgs( NULL )
, m_bComplain( false )
, m_nAdditionalCreationFlags( 0 )
, m_pResultData( NULL )
{ }
AsyncLoadJob_t( const char *pTextureName, const char *pTextureGroupName, IAsyncTextureOperationReceiver* pRecipient, void* pExtraArgs, bool bComplain, int nAdditionalCreationFlags )
: m_TextureName( pTextureName )
, m_TextureGroupName( pTextureGroupName )
, m_pRecipient( pRecipient )
, m_pExtraArgs( pExtraArgs )
, m_bComplain( bComplain )
, m_nAdditionalCreationFlags( nAdditionalCreationFlags )
, m_pResultData( NULL )
{
}
};
class CAsyncCopyRequest : public IAsyncTextureOperationReceiver
{
public:
CAsyncCopyRequest()
: m_nReferenceCount( 0 )
, m_bSignalled( false )
{ }
virtual ~CAsyncCopyRequest() { }
virtual int AddRef() OVERRIDE{ return ++m_nReferenceCount; }
virtual int Release() OVERRIDE
{
int retVal = --m_nReferenceCount;
if ( retVal == 0 )
delete this;
return retVal;
}
virtual int GetRefCount() const OVERRIDE{ return m_nReferenceCount; }
virtual void OnAsyncCreateComplete( ITexture* pTex, void* pExtraArgs ) OVERRIDE { }
virtual void OnAsyncFindComplete( ITexture* pTex, void* pExtraArgs ) OVERRIDE { }
virtual void OnAsyncMapComplete( ITexture* pTex, void* pExtraArgs, void* pMemory, int nPitch ) OVERRIDE { }
virtual void OnAsyncReadbackBegin( ITexture* pDst, ITexture* pSrc, void* pExtraArgs ) OVERRIDE
{
m_bSignalled = true;
}
bool IsSignalled() const { return m_bSignalled; }
private:
CInterlockedInt m_nReferenceCount;
volatile bool m_bSignalled;
};
class CAsyncMapResult : public IAsyncTextureOperationReceiver
{
public:
CAsyncMapResult( ITextureInternal* pTex )
: m_pTexToMap( pTex )
, m_nReferenceCount( 0 )
, m_pMemory( NULL )
, m_nPitch( 0 )
, m_bSignalled( false )
{ }
virtual ~CAsyncMapResult() { }
virtual int AddRef() OVERRIDE { return ++m_nReferenceCount; }
virtual int Release() OVERRIDE
{
int retVal = --m_nReferenceCount;
if ( retVal == 0 )
delete this;
return retVal;
}
virtual int GetRefCount() const OVERRIDE{ return m_nReferenceCount; }
virtual void OnAsyncCreateComplete( ITexture* pTex, void* pExtraArgs ) OVERRIDE { }
virtual void OnAsyncFindComplete( ITexture* pTex, void* pExtraArgs ) OVERRIDE { }
virtual void OnAsyncMapComplete( ITexture* pTex, void* pExtraArgs, void* pMemory, int nPitch ) OVERRIDE
{
Assert( pTex == m_pTexToMap );
m_pMemory = pMemory;
m_nPitch = nPitch;
m_bSignalled = true;
}
virtual void OnAsyncReadbackBegin( ITexture* pDst, ITexture* pSrc, void* pExtraArgs ) OVERRIDE { }
bool IsSignalled() const { return m_bSignalled; }
ITextureInternal* const m_pTexToMap;
CInterlockedInt m_nReferenceCount;
volatile void* m_pMemory;
volatile int m_nPitch;
private:
volatile bool m_bSignalled;
};
struct AsyncReadJob_t
{
ITexture* m_pSrcRt;
ITextureInternal* m_pSysmemTex;
CAsyncCopyRequest* m_pAsyncRead;
CAsyncMapResult* m_pAsyncMap;
const char* m_pDstName;
ImageFormat m_dstFmt;
bool m_bGenMips;
int m_nAdditionalCreationFlags;
IAsyncTextureOperationReceiver* m_pRecipient;
void* m_pExtraArgs;
CUtlMemory<unsigned char> m_finalTexelData;
AsyncReadJob_t()
: m_pSrcRt( NULL )
, m_pSysmemTex( NULL )
, m_pAsyncRead( NULL )
, m_pAsyncMap( NULL )
, m_pDstName( NULL )
, m_dstFmt( IMAGE_FORMAT_UNKNOWN )
, m_bGenMips( false )
, m_nAdditionalCreationFlags( 0 )
, m_pRecipient( NULL )
, m_pExtraArgs( NULL )
{ }
AsyncReadJob_t( ITexture* pSrcRt, const char* pDstName, ImageFormat dstFmt, bool bGenMips, int nAdditionalCreationFlags, IAsyncTextureOperationReceiver* pRecipient, void* pExtraArgs )
: m_pSrcRt( pSrcRt )
, m_pSysmemTex( NULL )
, m_pAsyncRead( NULL )
, m_pAsyncMap( NULL )
, m_pDstName( pDstName ) // We take ownership of this string.
, m_dstFmt( dstFmt )
, m_bGenMips( bGenMips )
, m_nAdditionalCreationFlags( nAdditionalCreationFlags )
, m_pRecipient( pRecipient )
, m_pExtraArgs( pExtraArgs )
{
}
~AsyncReadJob_t()
{
Assert( ThreadInMainThread() );
delete [] m_pDstName;
SafeRelease( &m_pRecipient );
if ( m_pSysmemTex )
{
if ( m_pAsyncMap )
{
extern CMaterialSystem g_MaterialSystem;
g_MaterialSystem.GetRenderContextInternal()->AsyncUnmap( m_pSysmemTex );
}
assert_cast< CTextureManager* >( g_pTextureManager )->ReleaseReadbackTexture( m_pSysmemTex );
m_pSysmemTex = NULL;
}
SafeRelease( &m_pAsyncMap );
}
};
bool IsJobCancelled( AsyncReadJob_t* pJob )
{
Assert( pJob != NULL );
// The texture manager holds a reference to the object, so if we're the only one who is holding a ref
// then the job has been abandoned. This gives us the opportunity to cleanup and skip some work.
if ( pJob->m_pRecipient->GetRefCount() == 1 )
{
return true;
}
return false;
}
bool IsJobCancelled( AsyncLoadJob_t* pJob )
{
Assert( pJob != NULL );
// The texture manager holds a reference to the object, so if we're the only one who is holding a ref
// then the job has been abandoned. This gives us the opportunity to cleanup and skip some work.
if ( pJob->m_pRecipient->GetRefCount() == 1 )
{
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Functions can be called from any thread, unless they are prefixed with a thread name.
class AsyncLoader
{
public:
AsyncLoader()
: m_bQuit( false )
{
for ( int i = 0; i < MAX_READS_OUTSTANDING; ++i )
{
m_asyncScratchVTFs.PushItem( CreateVTFTexture() );
}
// Do this after everything else.
m_LoaderThread = CreateSimpleThread( AsyncLoader::LoaderMain, this );
}
~AsyncLoader()
{
Assert( m_asyncScratchVTFs.Count() == MAX_READS_OUTSTANDING );
while ( m_asyncScratchVTFs.Count() > 0 )
{
IVTFTexture* pScratchVTF = NULL;
m_asyncScratchVTFs.PopItem( &pScratchVTF );
delete pScratchVTF;
}
}
void AsyncLoad( const AsyncLoadJob_t& job )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
// TODO: This could be made faster by keeping a pool of these things.
m_pendingJobs.PushItem( new AsyncLoadJob_t( job ) );
}
void Shutdown()
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
m_bQuit = true;
ThreadJoin( m_LoaderThread );
}
void ThreadMain_Update()
{
Assert( ThreadInMainThread() );
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
AsyncLoadJob_t *pJob = NULL;
if ( m_completedJobs.PopItem( &pJob ) )
{
Assert( pJob != NULL );
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - CompleteAsyncLoad", __FUNCTION__ );
// Complete the load, then make the callback.
assert_cast< CTextureManager* >( g_pTextureManager )->CompleteAsyncLoad( pJob );
delete pJob;
pJob = NULL;
}
}
void ReleaseAsyncReadBuffer( IVTFTexture *pScratchVTF )
{
Assert( pScratchVTF != NULL );
m_asyncScratchVTFs.PushItem( pScratchVTF );
}
private:
inline bool ThreadInLoaderThread()
{
return s_TextureManager.ThreadInAsyncLoadThread();
}
void ThreadLoader_Main( )
{
Assert( ThreadInLoaderThread() );
while ( !m_bQuit )
{
AsyncLoadJob_t *pJob = NULL;
IVTFTexture *pScratchVTF = NULL;
while ( !m_pendingJobs.PopItem( &pJob ) )
{
// "awhile"
ThreadSleep( 8 );
if ( m_bQuit )
return;
}
Assert( pJob != NULL );
while ( !m_asyncScratchVTFs.PopItem( &pScratchVTF ) )
{
// Also awhile, but not as long..
ThreadSleep( 4 );
if ( m_bQuit )
return;
}
Assert( pScratchVTF != NULL );
ThreadLoader_ProcessLoad( pJob, pScratchVTF );
}
}
void ThreadLoader_ProcessLoad( AsyncLoadJob_t *pJob, IVTFTexture* pScratchVTF )
{
Assert( ThreadInLoaderThread() );
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
Assert( pJob->m_pResultData );
if ( !pJob->m_pResultData->AsyncReadTextureFromFile( pScratchVTF, pJob->m_nAdditionalCreationFlags ) )
m_asyncScratchVTFs.PushItem( pScratchVTF );
m_completedJobs.PushItem( pJob );
}
static unsigned LoaderMain( void* _this )
{
ThreadSetDebugName( "Loader" );
s_TextureManager.m_nAsyncLoadThread = ThreadGetCurrentId();
( ( AsyncLoader* )_this )->ThreadLoader_Main();
s_TextureManager.m_nAsyncLoadThread = 0xFFFFFFFF;
return 0;
}
ThreadHandle_t m_LoaderThread;
volatile bool m_bQuit;
CTSQueue< AsyncLoadJob_t *> m_pendingJobs;
CTSQueue< AsyncLoadJob_t *> m_completedJobs;
CTSQueue< IVTFTexture *> m_asyncScratchVTFs;
};
//-----------------------------------------------------------------------------
// Functions can be called from any thread, unless they are prefixed with a thread name.
class AsyncReader
{
public:
AsyncReader()
: m_bQuit( false )
{
// Do this after everything else.
m_HelperThread = CreateSimpleThread( AsyncReader::ReaderMain, this );
}
void AsyncReadback( AsyncReadJob_t* job )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
m_requestedCopies.PushItem( job );
}
void Shutdown()
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
m_bQuit = true;
ThreadJoin( m_HelperThread );
}
void ThreadMain_Update()
{
Assert( ThreadInMainThread() );
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
while ( !m_queuedMaps.IsEmpty() )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "CompleteMap" );
AsyncReadJob_t* pMapped = m_queuedMaps.Head();
Assert( pMapped != NULL );
{
if ( IsJobCancelled( pMapped ) )
{
// Remove the head, which is pMapped
m_queuedMaps.RemoveAtHead();
delete pMapped;
continue;
}
if ( pMapped->m_pAsyncMap->IsSignalled() )
{
if ( pMapped->m_pAsyncMap->m_pMemory != 0 && pMapped->m_pAsyncMap->m_nPitch != 0 )
{
// Stick it in the queue for the other thread to work on it.
m_pendingJobs.PushItem( pMapped );
}
else
{
Assert( !"Failed to perform a map that shouldn't fail, need to deal with this if it ever happens." );
DevWarning( "Failed to perform a map that shouldn't fail, need to deal with this if it ever happens." );
}
// Remove the head, which is pMapped
m_queuedMaps.RemoveAtHead();
}
// Stop as soon as we complete one, regardless of success.
break;
}
}
// This is ugly, but basically we need to do map and unmap on the main thread. Other
// stuff can (mostly) happen on the async thread
while ( !m_queuedReads.IsEmpty() )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "CompleteQueuedRead" );
AsyncReadJob_t* pRead = NULL;
if ( m_queuedReads.RemoveAtHead( pRead ) )
{
if ( IsJobCancelled( pRead ) )
{
delete pRead;
continue;
}
SafeAssign( &pRead->m_pAsyncMap, new CAsyncMapResult( pRead->m_pSysmemTex ) );
// Trigger the map.
extern CMaterialSystem g_MaterialSystem;
g_MaterialSystem.GetRenderContextInternal()->AsyncMap( pRead->m_pSysmemTex, pRead->m_pAsyncMap, NULL );
m_queuedMaps.Insert( pRead );
// Stop as soon as we complete one successfully.
break;
}
}
if ( !m_scheduledReads.IsEmpty() )
{
if ( m_scheduledReads.Head()->m_pAsyncRead->IsSignalled() )
{
AsyncReadJob_t* pScheduledRead = m_scheduledReads.RemoveAtHead();
SafeRelease( &pScheduledRead->m_pAsyncRead );
m_queuedReads.Insert( pScheduledRead );
}
}
AsyncReadJob_t* pRequestCopy = NULL;
if ( m_requestedCopies.PopItem( &pRequestCopy ) )
{
SafeAssign( &pRequestCopy->m_pAsyncRead, new CAsyncCopyRequest );
extern CMaterialSystem g_MaterialSystem;
g_MaterialSystem.GetRenderContextInternal()->AsyncCopyRenderTargetToStagingTexture( pRequestCopy->m_pSysmemTex, pRequestCopy->m_pSrcRt, pRequestCopy->m_pAsyncRead, NULL );
m_scheduledReads.Insert( pRequestCopy );
}
while ( m_completedJobs.Count() > 0 )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "CreateTextureFromBits" );
AsyncReadJob_t* pCreate = NULL;
if ( m_completedJobs.PopItem( &pCreate ) )
{
// Check after we do the unmap, we need to do that here.
if ( IsJobCancelled( pCreate ) )
{
delete pCreate;
continue;
}
extern CMaterialSystem g_MaterialSystem;
g_MaterialSystem.GetRenderContextInternal()->AsyncUnmap( pCreate->m_pSysmemTex );
SafeRelease( &pCreate->m_pAsyncMap );
assert_cast< CTextureManager* >( g_pTextureManager )->CompleteAsyncRead( pCreate );
delete pCreate;
pCreate = NULL;
// Stop as soon as we complete one successfully.
break;
}
}
}
private:
inline bool ThreadInReaderThread()
{
return s_TextureManager.ThreadInAsyncReadThread();
}
void ThreadReader_Main()
{
Assert( ThreadInReaderThread() );
while ( !m_bQuit )
{
AsyncReadJob_t *pJob = NULL;
if ( m_pendingJobs.PopItem( &pJob ) )
{
Assert( pJob != NULL );
ThreadReader_ProcessRead( pJob );
}
else
{
// "awhile"
ThreadSleep( 8 );
}
}
}
void ThreadReader_ProcessRead( AsyncReadJob_t *pJob )
{
Assert( ThreadInReaderThread() );
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
// This code does a few things:
// 1. Reads from a previously mapped scratch buffer texture and performs byte swapping (if necessary).
// 2. Uses byteswapped data to generate mipmaps
// 3. Encodes mipmapped data into the destination format.
const int h = pJob->m_pSysmemTex->GetActualHeight();
const int w = pJob->m_pSysmemTex->GetActualWidth();
const ImageFormat srcFmt = pJob->m_pSysmemTex->GetImageFormat();
// Convert the data
CUtlMemory< unsigned char > srcBufferFinestMip;
CUtlMemory< unsigned char > srcBufferAllMips;
const int srcFinestMemRequired = ImageLoader::GetMemRequired( w, h, 1, srcFmt, false );
const int srcAllMemRequired = ImageLoader::GetMemRequired( w, h, 1, srcFmt, pJob->m_bGenMips );
const int srcPitch = ImageLoader::GetMemRequired( w, 1, 1, srcFmt, false );
const ImageFormat dstFmt = pJob->m_dstFmt;
CUtlMemory< unsigned char > dstBufferAllMips;
const int dstMemRequried = ImageLoader::GetMemRequired( w, h, 1, dstFmt, pJob->m_bGenMips );
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s-Allocations", __FUNCTION__ );
srcBufferFinestMip.EnsureCapacity( srcFinestMemRequired );
if ( srcFinestMemRequired != srcAllMemRequired )
{
srcBufferAllMips.EnsureCapacity( srcAllMemRequired );
}
else
{
Assert( !pJob->m_bGenMips );
}
if ( srcFmt != dstFmt )
{
dstBufferAllMips.EnsureCapacity( dstMemRequried );
}
}
// If this fires, you will get data corruption below. We can fix this case, it just doesn't seem
// to be needed right now.
Assert( pJob->m_pAsyncMap->m_nPitch == srcPitch );
srcPitch; // Hush compiler.
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s-ByteSwapInPlace", __FUNCTION__ );
ImageLoader::ConvertImageFormat( (unsigned char*) pJob->m_pAsyncMap->m_pMemory, GetImageFormatRawReadback( srcFmt ), srcBufferFinestMip.Base(), srcFmt, w, h );
}
if ( pJob->m_bGenMips )
{
GenerateMipmaps( &srcBufferAllMips, srcBufferFinestMip.Base(), w, h, srcFmt );
}
else
{
// If we're not generating mips, then allmips == finest mip, but the code below expects everything to
// be in all mips.
srcBufferAllMips.Swap( srcBufferFinestMip );
}
// Code below expects that the data is here one way or another.
Assert( srcBufferAllMips.Count() == srcAllMemRequired );
if ( srcFmt != dstFmt )
{
ConvertTexelData( &dstBufferAllMips, dstFmt, srcBufferAllMips, w, h, srcFmt, pJob->m_bGenMips );
pJob->m_finalTexelData.Swap( dstBufferAllMips );
}
else
{
// Just swap out the buffers.
pJob->m_finalTexelData.Swap( srcBufferAllMips );
}
// At this point, the data should be ready to go. Quick sanity check.
Assert( pJob->m_finalTexelData.Count() == dstMemRequried );
m_completedJobs.PushItem( pJob );
}
void GenerateMipmaps( CUtlMemory< unsigned char >* outBuffer, unsigned char* pSrc, int w, int h, ImageFormat fmt ) const
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
ImageLoader::GenerateMipmapLevelsLQ( pSrc, outBuffer->Base(), w, h, fmt, 0 );
}
void ConvertTexelData( CUtlMemory< unsigned char > *outBuffer, ImageFormat dstFmt, /* const */ CUtlMemory< unsigned char > &inBuffer, int w, int h, ImageFormat srcFmt, bool bGenMips )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
const int mipmapCount = bGenMips ? ImageLoader::GetNumMipMapLevels( w, h ) : 1;
unsigned char* pSrc = inBuffer.Base();
unsigned char* pDst = (*outBuffer).Base();
int mip_w = w;
int mip_h = h;
for ( int i = 0; i < mipmapCount; ++i )
{
ImageLoader::ConvertImageFormat( pSrc, srcFmt, pDst, dstFmt, mip_w, mip_h );
pSrc += ImageLoader::GetMemRequired( mip_w, mip_h, 1, srcFmt, false );
pDst += ImageLoader::GetMemRequired( mip_w, mip_h, 1, dstFmt, false );
mip_w = Max( 1, mip_w >> 1 );
mip_h = Max( 1, mip_h >> 1 );
}
}
static unsigned ReaderMain( void* _this )
{
ThreadSetDebugName( "Helper" );
s_TextureManager.m_nAsyncReadThread = ThreadGetCurrentId();
( ( AsyncReader* ) _this )->ThreadReader_Main();
s_TextureManager.m_nAsyncReadThread = 0xFFFFFFFF;
return 0;
}
ThreadHandle_t m_HelperThread;
volatile bool m_bQuit;
CTSQueue< AsyncReadJob_t*> m_requestedCopies;
CUtlQueue< AsyncReadJob_t* > m_queuedReads;
CUtlQueue< AsyncReadJob_t* > m_scheduledReads;
CUtlQueue< AsyncReadJob_t* > m_queuedMaps;
CTSQueue< AsyncReadJob_t* > m_pendingJobs;
CTSQueue< AsyncReadJob_t* > m_completedJobs;
};
//-----------------------------------------------------------------------------
// Texture manager
//-----------------------------------------------------------------------------
CTextureManager::CTextureManager( void )
: m_TextureList( true )
, m_TextureAliases( true )
, m_TextureExcludes( true )
, m_PendingAsyncLoads( true )
, m_textureStreamingRequests( DefLessFunc( ITextureInternal* ) )
, m_nAsyncLoadThread( 0xFFFFFFFF )
, m_nAsyncReadThread( 0xFFFFFFFF )
{
m_pErrorTexture = NULL;
m_pBlackTexture = NULL;
m_pWhiteTexture = NULL;
m_pGreyTexture = NULL;
m_pGreyAlphaZeroTexture = NULL;
m_pNormalizationCubemap = NULL;
m_pErrorRegen = NULL;
m_pFullScreenTexture = NULL;
m_pSignedNormalizationCubemap = NULL;
m_pShadowNoise2D = NULL;
m_pIdentityLightWarp = NULL;
m_pFullScreenDepthTexture = NULL;
m_pDebugLuxels2D = NULL;
m_pAsyncLoader = new AsyncLoader;
m_pAsyncReader = new AsyncReader;
m_iSuspendTextureStreaming = 0;
}
//-----------------------------------------------------------------------------
// Initialization + shutdown
//-----------------------------------------------------------------------------
void CTextureManager::Init( int nFlags )
{
m_nFlags = nFlags;
color32 color, color2;
m_iNextTexID = 4096;
// setup the checkerboard generator for failed texture loading
color.r = color.g = color.b = 0; color.a = 128;
color2.r = color2.b = color2.a = 255; color2.g = 0;
m_pErrorRegen = new CCheckerboardTexture( 4, color, color2 );
// Create an error texture
m_pErrorTexture = CreateProceduralTexture( "error", TEXTURE_GROUP_OTHER,
ERROR_TEXTURE_SIZE, ERROR_TEXTURE_SIZE, 1, IMAGE_FORMAT_BGRA8888, TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_SINGLECOPY );
CreateCheckerboardTexture( m_pErrorTexture, 4, color, color2 );
m_pErrorTexture->SetErrorTexture( true );
// Create a white texture
m_pWhiteTexture = CreateProceduralTexture( "white", TEXTURE_GROUP_OTHER,
WHITE_TEXTURE_SIZE, WHITE_TEXTURE_SIZE, 1, IMAGE_FORMAT_BGRX8888, TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_SINGLECOPY );
color.r = color.g = color.b = color.a = 255;
CreateSolidTexture( m_pWhiteTexture, color );
// Create a black texture
m_pBlackTexture = CreateProceduralTexture( "black", TEXTURE_GROUP_OTHER,
BLACK_TEXTURE_SIZE, BLACK_TEXTURE_SIZE, 1, IMAGE_FORMAT_BGRX8888, TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_SINGLECOPY );
color.r = color.g = color.b = 0;
CreateSolidTexture( m_pBlackTexture, color );
// Create a grey texture
m_pGreyTexture = CreateProceduralTexture( "grey", TEXTURE_GROUP_OTHER,
GREY_TEXTURE_SIZE, GREY_TEXTURE_SIZE, 1, IMAGE_FORMAT_BGRA8888, TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_SINGLECOPY );
color.r = color.g = color.b = 128;
color.a = 255;
CreateSolidTexture( m_pGreyTexture, color );
// Create a grey texture
m_pGreyAlphaZeroTexture = CreateProceduralTexture( "greyalphazero", TEXTURE_GROUP_OTHER,
GREY_TEXTURE_SIZE, GREY_TEXTURE_SIZE, 1, IMAGE_FORMAT_BGRA8888, TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_SINGLECOPY );
color.r = color.g = color.b = 128;
color.a = 0;
CreateSolidTexture( m_pGreyAlphaZeroTexture, color );
if ( HardwareConfig()->GetMaxDXSupportLevel() >= 80 )
{
// Create a normalization cubemap
m_pNormalizationCubemap = CreateProceduralTexture( "normalize", TEXTURE_GROUP_CUBE_MAP,
NORMALIZATION_CUBEMAP_SIZE, NORMALIZATION_CUBEMAP_SIZE, 1, IMAGE_FORMAT_BGRX8888,
TEXTUREFLAGS_ENVMAP | TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_SINGLECOPY |
TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_CLAMPU );
CreateNormalizationCubemap( m_pNormalizationCubemap );
}
if ( HardwareConfig()->GetMaxDXSupportLevel() >= 90 )
{
// In GL, we have poor format support, so we ask for signed float
ImageFormat fmt = IsOpenGL() ? IMAGE_FORMAT_RGBA16161616F : IMAGE_FORMAT_UVWQ8888;
int nTextureFlags = TEXTUREFLAGS_ENVMAP | TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_NOLOD | TEXTUREFLAGS_SINGLECOPY | TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_CLAMPU;
#ifdef OSX
// JasonM - ridiculous hack around R500 lameness...we never use this texture on OSX anyways (right?)
// Now assuming this was an OSX specific workaround.
nTextureFlags |= TEXTUREFLAGS_POINTSAMPLE;
#endif
// Create a normalization cubemap
m_pSignedNormalizationCubemap = CreateProceduralTexture( "normalizesigned", TEXTURE_GROUP_CUBE_MAP,
NORMALIZATION_CUBEMAP_SIZE, NORMALIZATION_CUBEMAP_SIZE, 1, fmt, nTextureFlags );
CreateSignedNormalizationCubemap( m_pSignedNormalizationCubemap );
m_pIdentityLightWarp = FindOrLoadTexture( "dev/IdentityLightWarp", TEXTURE_GROUP_OTHER );
m_pIdentityLightWarp->IncrementReferenceCount();
}
// High end hardware needs this texture for shadow mapping
if ( HardwareConfig()->ActuallySupportsPixelShaders_2_b() )
{
m_pShadowNoise2D = FindOrLoadTexture( "engine/NormalizedRandomDirections2D", TEXTURE_GROUP_OTHER );
m_pShadowNoise2D->IncrementReferenceCount();
}
m_pDebugLuxels2D = FindOrLoadTexture( "debug/debugluxelsnoalpha", TEXTURE_GROUP_OTHER );
m_pDebugLuxels2D->IncrementReferenceCount();
}
void CTextureManager::Shutdown()
{
// Clean up any textures we have hanging around that are waiting to go.
CleanupPossiblyUnreferencedTextures();
// Cool the texture cache first to drop all the refs back to 0 for the streamable things.
CoolTextureCache();
if ( m_pAsyncLoader )
{
m_pAsyncLoader->Shutdown();
delete m_pAsyncLoader;
m_pAsyncLoader = NULL;
}
if ( m_pAsyncReader )
{
m_pAsyncReader->Shutdown();
delete m_pAsyncReader;
m_pAsyncReader = NULL;
}
FreeStandardRenderTargets();
FOR_EACH_VEC( m_ReadbackTextures, i )
{
m_ReadbackTextures[ i ]->Release();
}
if ( m_pDebugLuxels2D )
{
m_pDebugLuxels2D->DecrementReferenceCount();
m_pDebugLuxels2D = NULL;
}
// These checks added because it's possible for shutdown to be called before the material system is
// fully initialized.
if ( m_pWhiteTexture )
{
m_pWhiteTexture->DecrementReferenceCount();
m_pWhiteTexture = NULL;
}
if ( m_pBlackTexture )
{
m_pBlackTexture->DecrementReferenceCount();
m_pBlackTexture = NULL;
}
if ( m_pGreyTexture )
{
m_pGreyTexture->DecrementReferenceCount();
m_pGreyTexture = NULL;
}
if ( m_pGreyAlphaZeroTexture )
{
m_pGreyAlphaZeroTexture->DecrementReferenceCount();
m_pGreyAlphaZeroTexture = NULL;
}
if ( m_pNormalizationCubemap )
{
m_pNormalizationCubemap->DecrementReferenceCount();
m_pNormalizationCubemap = NULL;
}
if ( m_pSignedNormalizationCubemap )
{
m_pSignedNormalizationCubemap->DecrementReferenceCount();
m_pSignedNormalizationCubemap = NULL;
}
if ( m_pShadowNoise2D )
{
m_pShadowNoise2D->DecrementReferenceCount();
m_pShadowNoise2D = NULL;
}
if ( m_pIdentityLightWarp )
{
m_pIdentityLightWarp->DecrementReferenceCount();
m_pIdentityLightWarp = NULL;
}
if ( m_pErrorTexture )
{
m_pErrorTexture->DecrementReferenceCount();
m_pErrorTexture = NULL;
}
ReleaseTextures();
if ( m_pErrorRegen )
{
m_pErrorRegen->Release();
m_pErrorRegen = NULL;
}
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = m_TextureList.Next( i ) )
{
ITextureInternal::Destroy( m_TextureList[i], true );
}
m_TextureList.RemoveAll();
for( int i = m_TextureAliases.First(); i != m_TextureAliases.InvalidIndex(); i = m_TextureAliases.Next( i ) )
{
delete []m_TextureAliases[i];
}
m_TextureAliases.RemoveAll();
m_TextureExcludes.RemoveAll();
}
//-----------------------------------------------------------------------------
// Allocate, free standard render target textures
//-----------------------------------------------------------------------------
void CTextureManager::AllocateStandardRenderTargets( )
{
bool bAllocateFullscreenTexture = ( m_nFlags & MATERIAL_INIT_ALLOCATE_FULLSCREEN_TEXTURE ) != 0;
bool bAllocateMorphAccumTexture = g_pMorphMgr->ShouldAllocateScratchTextures();
if ( IsPC() && ( bAllocateFullscreenTexture || bAllocateMorphAccumTexture ) )
{
MaterialSystem()->BeginRenderTargetAllocation();
// A offscreen render target which is the size + format of the back buffer (*not* HDR format!)
if ( bAllocateFullscreenTexture )
{
m_pFullScreenTexture = CreateRenderTargetTexture( "_rt_FullScreen", 1, 1, RT_SIZE_FULL_FRAME_BUFFER_ROUNDED_UP,
MaterialSystem()->GetBackBufferFormat(), RENDER_TARGET, TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT, 0 );
m_pFullScreenTexture->IncrementReferenceCount();
}
// This texture is the one we accumulate morph deltas into
if ( bAllocateMorphAccumTexture )
{
g_pMorphMgr->AllocateScratchTextures();
g_pMorphMgr->AllocateMaterials();
}
MaterialSystem()->EndRenderTargetAllocation();
}
}
void CTextureManager::FreeStandardRenderTargets()
{
if ( m_pFullScreenTexture )
{
m_pFullScreenTexture->DecrementReferenceCount();
m_pFullScreenTexture = NULL;
}
g_pMorphMgr->FreeMaterials();
g_pMorphMgr->FreeScratchTextures();
}
void CTextureManager::CacheExternalStandardRenderTargets()
{
m_pFullScreenDepthTexture = FindTexture( "_rt_FullFrameDepth" ); //created/destroyed in engine/matsys_interface.cpp to properly track hdr changes
}
//-----------------------------------------------------------------------------
// Generates an error texture pattern
//-----------------------------------------------------------------------------
void CTextureManager::GenerateErrorTexture( ITexture *pTexture, IVTFTexture *pVTFTexture )
{
m_pErrorRegen->RegenerateTextureBits( pTexture, pVTFTexture, NULL );
}
//-----------------------------------------------------------------------------
// Updates the color correction state
//-----------------------------------------------------------------------------
ITextureInternal *CTextureManager::ColorCorrectionTexture( int i )
{
Assert( i<COLOR_CORRECTION_MAX_TEXTURES );
return m_pColorCorrectionTextures[ i ];
}
void CTextureManager::SetColorCorrectionTexture( int i, ITextureInternal *pTexture )
{
Assert( i<COLOR_CORRECTION_MAX_TEXTURES );
if( m_pColorCorrectionTextures[i] )
{
m_pColorCorrectionTextures[i]->DecrementReferenceCount();
}
m_pColorCorrectionTextures[i] = pTexture;
if( pTexture )
pTexture->IncrementReferenceCount();
}
//-----------------------------------------------------------------------------
// Releases all textures (cause we've lost video memory)
//-----------------------------------------------------------------------------
void CTextureManager::ReleaseTextures( void )
{
g_pShaderAPI->SetFullScreenTextureHandle( INVALID_SHADERAPI_TEXTURE_HANDLE );
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = m_TextureList.Next( i ) )
{
// Release the texture...
m_TextureList[i]->ReleaseMemory();
}
}
//-----------------------------------------------------------------------------
// Request a texture ID
//-----------------------------------------------------------------------------
int CTextureManager::RequestNextTextureID()
{
// FIXME: Deal better with texture ids
// The range between 19000 and 21000 are used for standard textures + lightmaps
if (m_iNextTexID == 19000)
{
m_iNextTexID = 21000;
}
return m_iNextTexID++;
}
//-----------------------------------------------------------------------------
// Restores a single texture
//-----------------------------------------------------------------------------
void CTextureManager::RestoreTexture( ITextureInternal* pTexture )
{
// Put the texture back onto the board
pTexture->OnRestore(); // Give render targets a chance to reinitialize themselves if necessary (due to AA changes).
pTexture->Download();
}
//-----------------------------------------------------------------------------
// Purges our complete list of textures that might currently be unreferenced
//-----------------------------------------------------------------------------
void CTextureManager::CleanupPossiblyUnreferencedTextures()
{
if ( !ThreadInMainThread() || MaterialSystem()->GetRenderThreadId() != 0xFFFFFFFF )
{
Assert( !"CTextureManager::CleanupPossiblyUnreferencedTextures should never be called here" );
// This is catastrophically bad, don't do this. Someone needs to fix this. See JohnS or McJohn
DebuggerBreakIfDebugging_StagingOnly();
return;
}
// It is perfectly valid for a texture to become referenced again (it lives on in our texture list, and can be
// re-loaded) and then free'd again, so ensure we don't have any duplicates in queue.
CUtlVector< ITextureInternal * > texturesToDelete( /* growSize */ 0, /* initialSize */ m_PossiblyUnreferencedTextures.Count() );
ITextureInternal *pMaybeUnreferenced = NULL;
while ( m_PossiblyUnreferencedTextures.PopItem( &pMaybeUnreferenced ) )
{
Assert( pMaybeUnreferenced->GetReferenceCount() >= 0 );
if ( pMaybeUnreferenced->GetReferenceCount() == 0 && texturesToDelete.Find( pMaybeUnreferenced ) == texturesToDelete.InvalidIndex() )
{
texturesToDelete.AddToTail( pMaybeUnreferenced );
}
}
// Free them
FOR_EACH_VEC( texturesToDelete, i )
{
RemoveTexture( texturesToDelete[ i ] );
}
}
//-----------------------------------------------------------------------------
// Restore all textures (cause we've got video memory again)
//-----------------------------------------------------------------------------
void CTextureManager::RestoreNonRenderTargetTextures( )
{
// 360 should not have gotten here
Assert( !IsX360() );
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = m_TextureList.Next( i ) )
{
if ( !m_TextureList[i]->IsRenderTarget() )
{
RestoreTexture( m_TextureList[i] );
}
}
}
//-----------------------------------------------------------------------------
// Restore just the render targets (cause we've got video memory again)
//-----------------------------------------------------------------------------
void CTextureManager::RestoreRenderTargets()
{
// 360 should not have gotten here
Assert( !IsX360() );
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = m_TextureList.Next( i ) )
{
if ( m_TextureList[i]->IsRenderTarget() )
{
RestoreTexture( m_TextureList[i] );
}
}
if ( m_pFullScreenTexture )
{
g_pShaderAPI->SetFullScreenTextureHandle( m_pFullScreenTexture->GetTextureHandle( 0 ) );
}
CacheExternalStandardRenderTargets();
}
//-----------------------------------------------------------------------------
// Reloads all textures
//-----------------------------------------------------------------------------
void CTextureManager::ReloadTextures()
{
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = m_TextureList.Next( i ) )
{
// Put the texture back onto the board
m_TextureList[i]->Download();
}
}
static void ForceTextureIntoHardware( ITexture *pTexture, IMaterial *pMaterial, IMaterialVar *pBaseTextureVar )
{
if ( IsX360() )
return;
pBaseTextureVar->SetTextureValue( pTexture );
CMatRenderContextPtr pRenderContext( MaterialSystem()->GetRenderContext() );
pRenderContext->Bind( pMaterial );
IMesh* pMesh = pRenderContext->GetDynamicMesh( true );
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, 1 );
meshBuilder.Position3f( 0.0f, 0.0f, 0.0f );
meshBuilder.TangentS3f( 0.0f, 1.0f, 0.0f );
meshBuilder.TangentT3f( 1.0f, 0.0f, 0.0f );
meshBuilder.Normal3f( 0.0f, 0.0f, 1.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( 0.0f, 0.0f, 0.0f );
meshBuilder.TangentS3f( 0.0f, 1.0f, 0.0f );
meshBuilder.TangentT3f( 1.0f, 0.0f, 0.0f );
meshBuilder.Normal3f( 0.0f, 0.0f, 1.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.AdvanceVertex();
meshBuilder.Position3f( 0.0f, 0.0f, 0.0f );
meshBuilder.TangentS3f( 0.0f, 1.0f, 0.0f );
meshBuilder.TangentT3f( 1.0f, 0.0f, 0.0f );
meshBuilder.Normal3f( 0.0f, 0.0f, 1.0f );
meshBuilder.TexCoord2f( 0, 0.0f, 0.0f );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
}
//-----------------------------------------------------------------------------
// Reloads all textures
//-----------------------------------------------------------------------------
void CTextureManager::ForceAllTexturesIntoHardware( void )
{
if ( IsX360() )
return;
IMaterial *pMaterial = MaterialSystem()->FindMaterial( "engine/preloadtexture", "texture preload" );
pMaterial = ((IMaterialInternal *)pMaterial)->GetRealTimeVersion(); //always work with the realtime material internally
pMaterial->IncrementReferenceCount();
bool bFound;
IMaterialVar *pBaseTextureVar = pMaterial->FindVar( "$basetexture", &bFound );
if( !bFound )
{
return;
}
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = m_TextureList.Next( i ) )
{
// Put the texture back onto the board
ForceTextureIntoHardware( m_TextureList[i], pMaterial, pBaseTextureVar );
}
pMaterial->DecrementReferenceCount();
}
//-----------------------------------------------------------------------------
// Get at a couple standard textures
//-----------------------------------------------------------------------------
ITextureInternal *CTextureManager::ErrorTexture()
{
return m_pErrorTexture;
}
ITextureInternal *CTextureManager::NormalizationCubemap()
{
return m_pNormalizationCubemap;
}
ITextureInternal *CTextureManager::SignedNormalizationCubemap()
{
return m_pSignedNormalizationCubemap;
}
ITextureInternal *CTextureManager::ShadowNoise2D()
{
return m_pShadowNoise2D;
}
ITextureInternal *CTextureManager::IdentityLightWarp()
{
return m_pIdentityLightWarp;
}
ITextureInternal *CTextureManager::FullFrameDepthTexture()
{
return m_pFullScreenDepthTexture;
}
ITextureInternal *CTextureManager::DebugLuxels2D()
{
return m_pDebugLuxels2D;
}
//-----------------------------------------------------------------------------
// Creates a procedural texture
//-----------------------------------------------------------------------------
ITextureInternal *CTextureManager::CreateProceduralTexture(
const char *pTextureName,
const char *pTextureGroupName,
int w,
int h,
int d,
ImageFormat fmt,
int nFlags,
ITextureRegenerator *generator )
{
ITextureInternal *pNewTexture = ITextureInternal::CreateProceduralTexture( pTextureName, pTextureGroupName, w, h, d, fmt, nFlags, generator );
if ( !pNewTexture )
return NULL;
// Add it to the list of textures so it can be restored, etc.
m_TextureList.Insert( pNewTexture->GetName(), pNewTexture );
// NOTE: This will download the texture only if the shader api is ready
pNewTexture->Download();
return pNewTexture;
}
//-----------------------------------------------------------------------------
// FIXME: Need some better understanding of when textures should be added to
// the texture dictionary here. Is it only for files, for example?
// Texture dictionary...
//-----------------------------------------------------------------------------
ITextureInternal *CTextureManager::LoadTexture( const char *pTextureName, const char *pTextureGroupName, int nAdditionalCreationFlags /* = 0 */, bool bDownload /* = true */ )
{
ITextureInternal *pNewTexture = ITextureInternal::CreateFileTexture( pTextureName, pTextureGroupName );
if ( pNewTexture )
{
int iIndex = m_TextureExcludes.Find( pNewTexture->GetName() );
if ( m_TextureExcludes.IsValidIndex( iIndex ) )
{
// mark the new texture as excluded
int nDimensionsLimit = m_TextureExcludes[iIndex];
pNewTexture->MarkAsExcluded( ( nDimensionsLimit == 0 ), nDimensionsLimit );
}
// Stick the texture onto the board
if ( bDownload )
pNewTexture->Download( NULL, nAdditionalCreationFlags );
// FIXME: If there's been an error loading, we don't also want this error...
}
return pNewTexture;
}
ITextureInternal *CTextureManager::FindTexture( const char *pTextureName )
{
if ( !pTextureName || pTextureName[0] == 0 )
return NULL;
char szCleanName[MAX_PATH];
NormalizeTextureName( pTextureName, szCleanName, sizeof( szCleanName ) );
int i = m_TextureList.Find( szCleanName );
if ( i != m_TextureList.InvalidIndex() )
{
return m_TextureList[i];
}
i = m_TextureAliases.Find( szCleanName );
if ( i != m_TextureAliases.InvalidIndex() )
{
return FindTexture( m_TextureAliases[i] );
}
// Special handling: lightmaps
if ( char const *szLightMapNum = StringAfterPrefix( szCleanName, "[lightmap" ) )
{
int iLightMapNum = atoi( szLightMapNum );
extern CMaterialSystem g_MaterialSystem;
CMatLightmaps *plm = g_MaterialSystem.GetLightmaps();
if ( iLightMapNum >= 0 &&
iLightMapNum < plm->GetNumLightmapPages() )
{
ShaderAPITextureHandle_t hTex = plm->GetLightmapPageTextureHandle( iLightMapNum );
if ( hTex != INVALID_SHADERAPI_TEXTURE_HANDLE )
{
// Establish the lookup linking in the dictionary
ITextureInternal *pTxInt = ITextureInternal::CreateReferenceTextureFromHandle( pTextureName, TEXTURE_GROUP_LIGHTMAP, hTex );
m_TextureList.Insert( pTextureName, pTxInt );
return pTxInt;
}
}
}
return NULL;
}
void CTextureManager::AddTextureAlias( const char *pAlias, const char *pRealName )
{
if ( (pAlias == NULL) || (pRealName == NULL) )
return; //invalid alias
char szCleanName[MAX_PATH];
int index = m_TextureAliases.Find( NormalizeTextureName( pAlias, szCleanName, sizeof( szCleanName ) ) );
if ( index != m_TextureAliases.InvalidIndex() )
{
AssertMsg( Q_stricmp( pRealName, m_TextureAliases[index] ) == 0, "Trying to use one name to alias two different textures." );
RemoveTextureAlias( pAlias ); //remove the old alias to make room for the new one.
}
size_t iRealNameLength = strlen( pRealName ) + 1;
char *pRealNameCopy = new char [iRealNameLength];
memcpy( pRealNameCopy, pRealName, iRealNameLength );
m_TextureAliases.Insert( szCleanName, pRealNameCopy );
}
void CTextureManager::RemoveTextureAlias( const char *pAlias )
{
if ( pAlias == NULL )
return;
char szCleanName[MAX_PATH];
int index = m_TextureAliases.Find( NormalizeTextureName( pAlias, szCleanName, sizeof( szCleanName ) ) );
if ( index == m_TextureAliases.InvalidIndex() )
return; //not found
delete []m_TextureAliases[index];
m_TextureAliases.RemoveAt( index );
}
void CTextureManager::SetExcludedTextures( const char *pScriptName )
{
// clear all exisiting texture's exclusion
for ( int i = m_TextureExcludes.First(); i != m_TextureExcludes.InvalidIndex(); i = m_TextureExcludes.Next( i ) )
{
ITextureInternal *pTexture = FindTexture( m_TextureExcludes.GetElementName( i ) );
if ( pTexture )
{
pTexture->MarkAsExcluded( false, 0 );
}
}
m_TextureExcludes.RemoveAll();
MEM_ALLOC_CREDIT();
// get optional script
CUtlBuffer excludeBuffer( 0, 0, CUtlBuffer::TEXT_BUFFER );
if ( g_pFullFileSystem->ReadFile( pScriptName, NULL, excludeBuffer ) )
{
char szToken[MAX_PATH];
while ( 1 )
{
// must support spaces in names without quotes
// have to brute force parse up to a valid line
while ( 1 )
{
excludeBuffer.EatWhiteSpace();
if ( !excludeBuffer.EatCPPComment() )
{
// not a comment
break;
}
}
excludeBuffer.GetLine( szToken, sizeof( szToken ) );
int tokenLength = strlen( szToken );
if ( !tokenLength )
{
// end of list
break;
}
// remove all trailing whitespace
while ( tokenLength > 0 )
{
tokenLength--;
if ( isgraph( szToken[tokenLength] ) )
{
break;
}
szToken[tokenLength] = '\0';
}
// first optional token may be a dimension limit hint
int nDimensionsLimit = 0;
char *pTextureName = szToken;
if ( pTextureName[0] != 0 && isdigit( pTextureName[0] ) )
{
nDimensionsLimit = atoi( pTextureName );
// skip forward to name
for ( ;; )
{
char ch = *pTextureName;
if ( !ch || ( !isdigit( ch ) && !isspace( ch ) ) )
{
break;
}
pTextureName++;
}
}
char szCleanName[MAX_PATH];
NormalizeTextureName( pTextureName, szCleanName, sizeof( szCleanName ) );
if ( m_TextureExcludes.Find( szCleanName ) != m_TextureExcludes.InvalidIndex() )
{
// avoid duplicates
continue;
}
m_TextureExcludes.Insert( szCleanName, nDimensionsLimit );
// set any existing texture's exclusion
// textures that don't exist yet will get caught during their creation path
ITextureInternal *pTexture = FindTexture( szCleanName );
if ( pTexture )
{
pTexture->MarkAsExcluded( ( nDimensionsLimit == 0 ), nDimensionsLimit );
}
}
}
}
void CTextureManager::UpdateExcludedTextures( void )
{
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = m_TextureList.Next( i ) )
{
m_TextureList[i]->UpdateExcludedState();
}
}
ITextureInternal *CTextureManager::FindOrLoadTexture( const char *pTextureName, const char *pTextureGroupName, int nAdditionalCreationFlags /* = 0 */ )
{
ITextureInternal *pTexture = FindTexture( pTextureName );
if ( !pTexture )
{
pTexture = LoadTexture( pTextureName, pTextureGroupName, nAdditionalCreationFlags );
if ( pTexture )
{
// insert into the dictionary using the processed texture name
m_TextureList.Insert( pTexture->GetName(), pTexture );
}
}
return pTexture;
}
bool CTextureManager::IsTextureLoaded( const char *pTextureName )
{
ITextureInternal *pTexture = FindTexture( pTextureName );
return ( pTexture != NULL );
}
//-----------------------------------------------------------------------------
// Creates a texture that's a render target
//-----------------------------------------------------------------------------
ITextureInternal *CTextureManager::CreateRenderTargetTexture(
const char *pRTName, // NULL for auto-generated name
int w,
int h,
RenderTargetSizeMode_t sizeMode,
ImageFormat fmt,
RenderTargetType_t type,
unsigned int textureFlags,
unsigned int renderTargetFlags )
{
MEM_ALLOC_CREDIT_( __FILE__ ": Render target" );
ITextureInternal *pTexture;
if ( pRTName )
{
// caller is re-initing or changing
pTexture = FindTexture( pRTName );
if ( pTexture )
{
// Changing the underlying render target, but leaving the pointer and refcount
// alone fixes callers that have exisiting references to this object.
ITextureInternal::ChangeRenderTarget( pTexture, w, h, sizeMode, fmt, type,
textureFlags, renderTargetFlags );
// download if ready
pTexture->Download();
return pTexture;
}
}
pTexture = ITextureInternal::CreateRenderTarget( pRTName, w, h, sizeMode, fmt, type,
textureFlags, renderTargetFlags );
if ( !pTexture )
return NULL;
// Add the render target to the list of textures
// that way it'll get cleaned up correctly in case of a task switch
m_TextureList.Insert( pTexture->GetName(), pTexture );
// NOTE: This will download the texture only if the shader api is ready
pTexture->Download();
return pTexture;
}
void CTextureManager::ResetTextureFilteringState( )
{
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = m_TextureList.Next( i ) )
{
m_TextureList[i]->SetFilteringAndClampingMode();
}
}
void CTextureManager::SuspendTextureStreaming( void )
{
m_iSuspendTextureStreaming++;
}
void CTextureManager::ResumeTextureStreaming( void )
{
AssertMsg( m_iSuspendTextureStreaming, "Mismatched Suspend/Resume texture streaming calls" );
if ( m_iSuspendTextureStreaming )
{
m_iSuspendTextureStreaming--;
}
}
void CTextureManager::RemoveUnusedTextures( void )
{
// First, need to flush all of our textures that are pending cleanup.
CleanupPossiblyUnreferencedTextures();
int iNext;
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = iNext )
{
iNext = m_TextureList.Next( i );
#ifdef _DEBUG
if ( m_TextureList[i]->GetReferenceCount() < 0 )
{
Warning( "RemoveUnusedTextures: pTexture->m_referenceCount < 0 for %s\n", m_TextureList[i]->GetName() );
}
#endif
if ( m_TextureList[i]->GetReferenceCount() <= 0 )
{
ITextureInternal::Destroy( m_TextureList[i] );
m_TextureList.RemoveAt( i );
}
}
}
void CTextureManager::MarkUnreferencedTextureForCleanup( ITextureInternal *pTexture )
{
Assert( pTexture->GetReferenceCount() == 0 );
m_PossiblyUnreferencedTextures.PushItem( pTexture );
}
void CTextureManager::RemoveTexture( ITextureInternal *pTexture )
{
TM_ZONE_DEFAULT( TELEMETRY_LEVEL0 );
Assert( pTexture->GetReferenceCount() <= 0 );
if ( !ThreadInMainThread() || MaterialSystem()->GetRenderThreadId() != 0xFFFFFFFF )
{
Assert( !"CTextureManager::RemoveTexture should never be called here");
// This is catastrophically bad, don't do this. Someone needs to fix this.
DebuggerBreakIfDebugging_StagingOnly();
return;
}
bool bTextureFound = false;
// If the queue'd rendering thread is running, RemoveTexture() is going to explode. If it isn't, calling
// RemoveTexture while still dealing with immediate removal textures seems fishy, but could be legit, in which case
// this assert could be softened.
int nUnreferencedQueue = m_PossiblyUnreferencedTextures.Count();
if ( nUnreferencedQueue )
{
Assert( !"RemoveTexture() being called while textures sitting in possibly unreferenced queue" );
// Assuming that this is all a wholesome main-thread misunderstanding, we can try to continue after filtering
// this texture from the queue.
ITextureInternal *pPossiblyUnreferenced = NULL;
for ( int i = 0; i < nUnreferencedQueue && m_PossiblyUnreferencedTextures.PopItem( &pPossiblyUnreferenced ); i++ )
{
m_PossiblyUnreferencedTextures.PushItem( pPossiblyUnreferenced );
if ( pPossiblyUnreferenced == pTexture )
{
bTextureFound = true;
break;
}
}
}
if ( bTextureFound )
{
Assert( !"CTextureManager::RemoveTexture has been called for a texture that has already requested cleanup. That's a paddlin'." );
// This is catastrophically bad, don't do this. Someone needs to fix this.
DebuggerBreakIfDebugging_StagingOnly();
return;
}
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = m_TextureList.Next( i ) )
{
// search by object
if ( m_TextureList[i] == pTexture )
{
// This code is always sure that the texture we're tryign to clean up is no longer in the the possibly unreferenced list,
// So let Destroy work without checking.
ITextureInternal::Destroy( m_TextureList[i], true );
m_TextureList.RemoveAt( i );
break;
}
}
}
void CTextureManager::ReloadFilesInList( IFileList *pFilesToReload )
{
if ( !IsPC() )
return;
for ( int i=m_TextureList.First(); i != m_TextureList.InvalidIndex(); i=m_TextureList.Next( i ) )
{
ITextureInternal *pTex = m_TextureList[i];
pTex->ReloadFilesInList( pFilesToReload );
}
}
void CTextureManager::ReleaseTempRenderTargetBits( void )
{
if( IsX360() ) //only sane on 360
{
int iNext;
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = iNext )
{
iNext = m_TextureList.Next( i );
if ( m_TextureList[i]->IsTempRenderTarget() )
{
m_TextureList[i]->ReleaseMemory();
}
}
}
}
void CTextureManager::DebugPrintUsedTextures( void )
{
for ( int i = m_TextureList.First(); i != m_TextureList.InvalidIndex(); i = m_TextureList.Next( i ) )
{
ITextureInternal *pTexture = m_TextureList[i];
Msg( "Texture: '%s' RefCount: %d\n", pTexture->GetName(), pTexture->GetReferenceCount() );
}
if ( m_TextureExcludes.Count() )
{
Msg( "\nExcluded Textures: (%d)\n", m_TextureExcludes.Count() );
for ( int i = m_TextureExcludes.First(); i != m_TextureExcludes.InvalidIndex(); i = m_TextureExcludes.Next( i ) )
{
char buff[256];
const char *pName = m_TextureExcludes.GetElementName( i );
V_snprintf( buff, sizeof( buff ), "Excluded: %d '%s' \n", m_TextureExcludes[i], pName );
// an excluded texture is valid, but forced tiny
if ( IsTextureLoaded( pName ) )
{
Msg( "%s", buff );
}
else
{
// warn as unknown, could be a spelling error
Warning( "%s", buff );
}
}
}
}
int CTextureManager::FindNext( int iIndex, ITextureInternal **pTexInternal )
{
if ( iIndex == -1 && m_TextureList.Count() )
{
iIndex = m_TextureList.First();
}
else if ( !m_TextureList.Count() || !m_TextureList.IsValidIndex( iIndex ) )
{
*pTexInternal = NULL;
return -1;
}
*pTexInternal = m_TextureList[iIndex];
iIndex = m_TextureList.Next( iIndex );
if ( iIndex == m_TextureList.InvalidIndex() )
{
// end of list
iIndex = -1;
}
return iIndex;
}
void CTextureManager::Update()
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
#ifdef STAGING_ONLY
if ( mat_texture_list_dump.GetBool() )
{
DumpTextureList();
mat_texture_list_dump.SetValue( 0 );
}
#endif
if ( m_pAsyncReader )
m_pAsyncReader->ThreadMain_Update();
}
// Load a texture asynchronously and then call the provided callback.
void CTextureManager::AsyncFindOrLoadTexture( const char *pTextureName, const char *pTextureGroupName, IAsyncTextureOperationReceiver* pRecipient, void* pExtraArgs, bool bComplain, int nAdditionalCreationFlags )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
bool bStreamingRequest = ( nAdditionalCreationFlags & TEXTUREFLAGS_STREAMABLE ) != 0;
ITextureInternal* pLoadedTex = FindTexture( pTextureName );
// It'd be weird to indicate that we're streaming and not actually have a texture that already exists.
Assert( !bStreamingRequest || pLoadedTex != NULL );
if ( pLoadedTex )
{
if ( !bStreamingRequest )
{
if ( pLoadedTex->IsError() && bComplain )
DevWarning( "Texture '%s' not found.\n", pTextureName );
pRecipient->OnAsyncFindComplete( pLoadedTex, pExtraArgs );
SafeRelease( pRecipient );
return;
}
}
AsyncLoadJob_t asyncLoad( pTextureName, pTextureGroupName, pRecipient, pExtraArgs, bComplain, nAdditionalCreationFlags );
// If this is the first person asking to load this, then remember so we don't load the same thing over and over again.
int pendingIndex = m_PendingAsyncLoads.Find( pTextureName );
if ( pendingIndex == m_PendingAsyncLoads.InvalidIndex() )
{
// Create the texture here, we'll load the data in the async thread. Load is a misnomer, because it doesn't actually
// load the data--Download does.
if ( bStreamingRequest )
asyncLoad.m_pResultData = pLoadedTex;
else
asyncLoad.m_pResultData = LoadTexture( pTextureName, pTextureGroupName, nAdditionalCreationFlags, false );
AsyncLoad( asyncLoad );
pendingIndex = m_PendingAsyncLoads.Insert( pTextureName );
}
else
{
// If this is a thing we've seen before, just note that we also need it.
m_PendingAsyncLoads[ pendingIndex ].AddToTail( asyncLoad );
}
}
void CTextureManager::CompleteAsyncLoad( AsyncLoadJob_t* pJob )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
Assert( pJob );
bool bDownloaded = false;
if ( !IsJobCancelled( pJob ) )
{
// Perform the download. We did the read already.
pJob->m_pResultData->Download( NULL, pJob->m_nAdditionalCreationFlags );
bDownloaded = true;
}
// Then notify the caller that they're finished.
pJob->m_pRecipient->OnAsyncFindComplete( pJob->m_pResultData, pJob->m_pExtraArgs );
// Finally, deal with any other stragglers that asked for the same surface we did.
int pendingIndex = m_PendingAsyncLoads.Find( pJob->m_TextureName.Get() );
Assert( pendingIndex != m_PendingAsyncLoads.InvalidIndex() );
FOR_EACH_VEC( m_PendingAsyncLoads[ pendingIndex ], i )
{
AsyncLoadJob_t& straggler = m_PendingAsyncLoads[ pendingIndex ][ i ];
straggler.m_pResultData = pJob->m_pResultData;
if ( !bDownloaded && !IsJobCancelled( &straggler ) )
{
bDownloaded = true;
straggler.m_pResultData->Download( NULL, straggler.m_nAdditionalCreationFlags );
}
straggler.m_pRecipient->OnAsyncFindComplete( straggler.m_pResultData, straggler.m_pExtraArgs );
SafeRelease( &straggler.m_pRecipient );
}
// Add ourselves to the list of loaded things.
if ( bDownloaded )
{
// The texture list has to be protected by the materials lock.
MaterialLock_t hMaterialLock = materials->Lock();
// It's possible that the texture wasn't actually unloaded, so we may have reloaded something unnecessarily.
// If so, just don't re-add it.
if ( m_TextureList.Find( pJob->m_pResultData->GetName() ) == m_TextureList.InvalidIndex() )
m_TextureList.Insert( pJob->m_pResultData->GetName(), pJob->m_pResultData );
materials->Unlock( hMaterialLock );
}
else
{
// If we didn't download, need to clean up the leftover file data that we loaded on the other thread
pJob->m_pResultData->AsyncCancelReadTexture();
}
// Can't release the Recipient until after we tell the stragglers, because the recipient may be the only
// ref to the texture, and cleaning it up may clean up the texture but leave us with a seemingly valid pointer.
SafeRelease( &pJob->m_pRecipient );
// Dump out the whole lot.
m_PendingAsyncLoads.RemoveAt( pendingIndex );
}
void CTextureManager::AsyncLoad( const AsyncLoadJob_t& job )
{
Assert( m_pAsyncLoader );
m_pAsyncLoader->AsyncLoad( job );
}
void CTextureManager::AsyncCreateTextureFromRenderTarget( ITexture* pSrcRt, const char* pDstName, ImageFormat dstFmt, bool bGenMips, int nAdditionalCreationFlags, IAsyncTextureOperationReceiver* pRecipient, void* pExtraArgs )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
Assert( pSrcRt );
AsyncReadJob_t* pAsyncRead = new AsyncReadJob_t( pSrcRt, pDstName, dstFmt, bGenMips, nAdditionalCreationFlags, pRecipient, pExtraArgs );
AsyncReadTexture( pAsyncRead );
}
void CTextureManager::CompleteAsyncRead( AsyncReadJob_t* pJob )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
// Release the texture back into the pool.
ReleaseReadbackTexture( pJob->m_pSysmemTex );
pJob->m_pSysmemTex = NULL;
int w = pJob->m_pSrcRt->GetActualWidth();
int h = pJob->m_pSrcRt->GetActualHeight();
int mips = pJob->m_bGenMips ? ImageLoader::GetNumMipMapLevels( w, h ) : 1;
int nFlags = pJob->m_nAdditionalCreationFlags
| TEXTUREFLAGS_SINGLECOPY
| TEXTUREFLAGS_IGNORE_PICMIP
| ( mips > 1
? TEXTUREFLAGS_ALL_MIPS
: TEXTUREFLAGS_NOMIP
)
;
// Create the texture
ITexture* pFinalTex = materials->CreateNamedTextureFromBitsEx( pJob->m_pDstName, TEXTURE_GROUP_RUNTIME_COMPOSITE, w, h, mips, pJob->m_dstFmt, pJob->m_finalTexelData.Count(), pJob->m_finalTexelData.Base(), nFlags );
Assert( pFinalTex );
// Make the callback!
pJob->m_pRecipient->OnAsyncCreateComplete( pFinalTex, pJob->m_pExtraArgs );
SafeRelease( &pJob->m_pSrcRt );
SafeRelease( &pJob->m_pRecipient );
SafeRelease( &pFinalTex );
}
void CTextureManager::AsyncReadTexture( AsyncReadJob_t* pJob )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
Assert( m_pAsyncReader );
Assert( pJob );
pJob->m_pSysmemTex = AcquireReadbackTexture( pJob->m_pSrcRt->GetActualWidth(), pJob->m_pSrcRt->GetActualHeight(), pJob->m_pSrcRt->GetImageFormat() );
Assert( pJob->m_pSysmemTex );
if ( !pJob->m_pSysmemTex )
{
Assert( !"Need to deal with this error case" ); // TODOERROR
return;
}
m_pAsyncReader->AsyncReadback( pJob );
}
ITextureInternal* CTextureManager::AcquireReadbackTexture( int w, int h, ImageFormat fmt )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s-TryExisting", __FUNCTION__ );
MaterialLock_t hMaterialLock = materials->Lock();
FOR_EACH_VEC( m_ReadbackTextures, i )
{
ITextureInternal* pTex = m_ReadbackTextures[ i ];
Assert( pTex );
if ( pTex->GetActualWidth() == w
&& pTex->GetActualHeight() == h
&& pTex->GetImageFormat() == fmt )
{
// Found one in the cache already
pTex->AddRef();
m_ReadbackTextures.Remove( i );
materials->Unlock( hMaterialLock );
return pTex;
}
}
materials->Unlock( hMaterialLock );
}
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s-CreateNew", __FUNCTION__ );
ITextureInternal* stagingTex = CreateProceduralTexture( "readbacktex", TEXTURE_GROUP_OTHER, w, h, 1, fmt, TEXTUREFLAGS_STAGING_MEMORY | TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_SINGLECOPY | TEXTUREFLAGS_IMMEDIATE_CLEANUP );
// AddRef here for caller.
stagingTex->AddRef();
return stagingTex;
}
void CTextureManager::ReleaseReadbackTexture( ITextureInternal* pTex )
{
Assert( pTex );
MaterialLock_t hMaterialLock = materials->Lock();
// Release matching AddRef in AcquireReadbackTexture
pTex->Release();
m_ReadbackTextures.AddToTail( pTex );
materials->Unlock( hMaterialLock );
}
#ifdef STAGING_ONLY
static int SortTexturesForDump( const CUtlPair< CUtlString, void* >* sz1, const CUtlPair< CUtlString, void* >* sz2 )
{
int sortVal = CUtlString::SortCaseSensitive( &sz1->first, &sz2->first );
if ( sortVal != 0 )
return sortVal;
return int( ( int ) sz1->second - ( int ) sz2->second );
}
void CTextureManager::DumpTextureList()
{
CUtlVector< CUtlPair< CUtlString, void* > > textures;
MaterialLock_t hMaterialLock = materials->Lock();
FOR_EACH_DICT( m_TextureList, i )
{
textures.AddToTail( MakeUtlPair( CUtlString( m_TextureList[i]->GetName() ), (void*) m_TextureList[i] ) );
}
materials->Unlock( hMaterialLock );
// Now dump them out, sorted first by the texture name, then by address.
textures.Sort( SortTexturesForDump );
FOR_EACH_VEC( textures, i )
{
CUtlPair< CUtlString, void* >& pair = textures[i];
Warning( "[%p]: %s\n", pair.second, pair.first.Get() ) ;
}
}
#endif
//-----------------------------------------------------------------------------
// Warms the texture cache from a vpk. This will cause coarse mipmaps to be
// available all the time, starting with mipmap level 3. This allows us to have
// all the textures available all the time, but we only pay for fine levels when
// we actually need them.
//-----------------------------------------------------------------------------
void CTextureManager::WarmTextureCache()
{
// Disable cache for osx/linux for now.
if ( CommandLine()->CheckParm( "-no_texture_stream" ) )
return;
MemoryInformation memInfo;
if ( GetMemoryInformation( &memInfo ) )
{
if ( memInfo.m_nPhysicalRamMbTotal <= 3584 )
return;
}
COM_TimestampedLog( "WarmTextureCache() - Begin" );
// If this fires, we need to relocate this elsewhere--there's no point in doing the loading
// if we're not going to be able to download them right now.
Assert( g_pShaderAPI->CanDownloadTextures() );
g_pFullFileSystem->AddSearchPath( "tf2_texture_cache.vpk", cTextureCachePathDir, PATH_ADD_TO_TAIL );
CUtlDict< int > filesToLoad( k_eDictCompareTypeCaseSensitive );
// TODO: Maybe work directly with VPK (still need to add to the filesystem for LoadTexture)?
// CPackFile
// Add the pak and then walk through the contents.
FindFilesToLoad( &filesToLoad, "*.*" );
// Then add the list of files from the cache, which will deal with running without a VPK and also
// allow us to add late stragglers.
ReadFilesToLoad( &filesToLoad, "texture_preload_list.txt" );
if ( filesToLoad.Count() == 0 )
{
COM_TimestampedLog( "WarmTextureCache() - End (No files loaded)" );
return;
}
Assert( filesToLoad.Count() > 0 );
// Now read all of the files.
// TODO: This needs to read in specific order to ensure peak performance.
FOR_EACH_DICT( filesToLoad, i )
{
const char* pFilename = filesToLoad.GetElementName( i );
// Load the texture. This will only load the lower mipmap levels because that's the file we'll find now.
ITextureInternal* pTex = LoadTexture( pFilename, TEXTURE_GROUP_PRECACHED, TEXTUREFLAGS_STREAMABLE_COARSE );
COM_TimestampedLog( "WarmTextureCache(): LoadTexture( %s ): Complete", pFilename );
if ( ( pTex->GetFlags() & TEXTUREFLAGS_STREAMABLE ) == 0 )
{
STAGING_ONLY_EXEC( Warning( "%s is listed in texture_preload_list.txt or is otherwise marked for streaming. It cannot be streamed and should be removed from the streaming system.\n", pFilename ) );
ITextureInternal::Destroy( pTex );
continue;
}
if ( !pTex->IsError() )
{
m_TextureList.Insert( pTex->GetName(), pTex );
pTex->AddRef();
m_preloadedTextures.AddToTail( pTex );
}
else
{
// Don't preload broken textures
ITextureInternal::Destroy( pTex );
}
}
g_pFullFileSystem->RemoveSearchPath( "tf2_texture_cache.vpk", cTextureCachePathDir );
COM_TimestampedLog( "WarmTextureCache() - End" );
}
//-----------------------------------------------------------------------------
// Reads the list of files contained in the vpk loaded above, and adds them to the
// list of files we need to load (passing in as pOutFilesToLoad). The map contains
// the
//-----------------------------------------------------------------------------
void CTextureManager::FindFilesToLoad( CUtlDict< int >* pOutFilesToLoad, const char* pFilename )
{
Assert( pOutFilesToLoad != NULL );
FileFindHandle_t fh;
pFilename = g_pFullFileSystem->FindFirstEx( pFilename, cTextureCachePathDir, &fh );
while ( pFilename != NULL )
{
if ( g_pFullFileSystem->FindIsDirectory( fh ) )
{
if ( pFilename[0] != '.' )
{
char childFilename[_MAX_PATH];
V_sprintf_safe( childFilename, "%s/*.*", pFilename );
FindFilesToLoad( pOutFilesToLoad, childFilename );
}
}
else
{
char filenameNoExtension[_MAX_PATH];
V_StripExtension( pFilename, filenameNoExtension, _MAX_PATH );
// Add the file to the list, which we will later traverse in order to ensure we're hitting these in the expected order for the VPK.
( *pOutFilesToLoad ).Insert( CUtlString( filenameNoExtension ), 0 );
}
pFilename = g_pFullFileSystem->FindNext( fh );
}
}
//-----------------------------------------------------------------------------
// Read the contents of pFilename, which should just be a list of texture names
// that we should load.
//-----------------------------------------------------------------------------
void CTextureManager::ReadFilesToLoad( CUtlDict< int >* pOutFilesToLoad, const char* pFilename )
{
Assert( pOutFilesToLoad != NULL );
FileHandle_t fh = g_pFullFileSystem->Open( pFilename, "r" );
if ( !fh )
return;
CUtlBuffer fileContents( 0, 0, CUtlBuffer::TEXT_BUFFER );
if ( !g_pFullFileSystem->ReadToBuffer( fh, fileContents ) )
goto cleanup;
char buffer[_MAX_PATH + 1];
while ( 1 )
{
fileContents.GetLine( buffer, _MAX_PATH );
if ( buffer[ 0 ] == 0 )
break;
V_StripWhitespace( buffer );
if ( buffer[ 0 ] == 0 )
continue;
// If it's not in the map already, add it.
if ( pOutFilesToLoad->Find( buffer ) == pOutFilesToLoad->InvalidIndex() )
( *pOutFilesToLoad ).Insert( buffer, 0 );
}
cleanup:
g_pFullFileSystem->Close( fh );
}
void CTextureManager::UpdatePostAsync()
{
TM_ZONE_DEFAULT( TELEMETRY_LEVEL0 );
// Update the async loader, which affects streaming in (streaming out is handled below).
// Both stream in and stream out have to happen while the async job is not running because
// they muck with shaderapi texture handles which could be in use if the async job is currently
// being run
if ( m_pAsyncLoader )
m_pAsyncLoader->ThreadMain_Update();
// First, move everything from the async request queue to active list
ITextureInternal* pRequest = NULL;
while ( m_asyncStreamingRequests.PopItem( &pRequest ) )
{
Assert( pRequest != NULL );
// Update the LOD bias to smoothly stream the texture in. We only need to do this on frames that
// we actually have been requested to draw--other frames it doesn't matter (see, because we're not drawing?)
pRequest->UpdateLodBias();
m_textureStreamingRequests.InsertOrReplace( pRequest, g_FrameNum );
}
// Then update streaming
const int cThirtySecondsOrSoInFrames = 2000;
// First, remove old stuff.
FOR_EACH_MAP_FAST( m_textureStreamingRequests, i )
{
if ( m_textureStreamingRequests[ i ] + cThirtySecondsOrSoInFrames < g_FrameNum )
{
ITextureInternal* pTex = m_textureStreamingRequests.Key( i );
// It's been awhile since we were asked to full res this texture, so let's evict
// if it's still full res.
if ( pTex->GetTargetResidence() == RESIDENT_FULL )
pTex->MakeResident( RESIDENT_PARTIAL );
m_textureStreamingRequests.RemoveAt( i );
}
}
// Then, start allowing new stuff to ask for data.
FOR_EACH_MAP_FAST( m_textureStreamingRequests, i )
{
int requestFrame = m_textureStreamingRequests[ i ];
if ( g_FrameNum == requestFrame )
{
ITextureInternal* pTex = m_textureStreamingRequests.Key( i );
if ( pTex->GetTargetResidence() == RESIDENT_FULL )
continue;
// TODO: What to do if this fails? Auto-reask next frame?
pTex->MakeResident( RESIDENT_FULL );
}
}
// Finally, flush any immediate release textures marked for cleanup that are still unreferenced.
CleanupPossiblyUnreferencedTextures();
}
void CTextureManager::ReleaseAsyncScratchVTF( IVTFTexture *pScratchVTF )
{
Assert( m_pAsyncLoader != NULL && pScratchVTF != NULL );
m_pAsyncLoader->ReleaseAsyncReadBuffer( pScratchVTF );
}
bool CTextureManager::ThreadInAsyncLoadThread() const
{
return ThreadGetCurrentId() == m_nAsyncLoadThread;
}
bool CTextureManager::ThreadInAsyncReadThread() const
{
return ThreadGetCurrentId() == m_nAsyncReadThread;
}
bool CTextureManager::AddTextureCompositorTemplate( const char* pName, KeyValues* pTmplDesc )
{
Assert( pName && pTmplDesc );
int ndx = m_TexCompTemplates.Find( pName );
if ( ndx != m_TexCompTemplates.InvalidIndex() )
{
// Later definitions stomp earlier ones. This lets the GC win.
delete m_TexCompTemplates[ ndx ];
m_TexCompTemplates.RemoveAt( ndx );
}
CTextureCompositorTemplate* pNewTmpl = CTextureCompositorTemplate::Create( pName, pTmplDesc );
// If this is the case, the logging has already been done.
if ( pNewTmpl == NULL )
return false;
m_TexCompTemplates.Insert( pName, pNewTmpl );
return true;
}
bool CTextureManager::VerifyTextureCompositorTemplates()
{
TM_ZONE_DEFAULT( TELEMETRY_LEVEL1 );
bool allSuccess = true;
FOR_EACH_DICT_FAST( m_TexCompTemplates, i )
{
if ( m_TexCompTemplates[ i ]->ResolveDependencies() )
{
if ( m_TexCompTemplates[ i ]->HasDependencyCycles() )
{
allSuccess = false;
}
}
else
{
allSuccess = false;
}
}
return allSuccess;
}
CTextureCompositorTemplate* CTextureManager::FindTextureCompositorTemplate( const char* pName )
{
unsigned short i = m_TexCompTemplates.Find( pName );
if ( m_TexCompTemplates.IsValidIndex( i ) )
return m_TexCompTemplates[ i ];
return NULL;
}
bool CTextureManager::HasPendingTextureDestroys() const
{
return m_PossiblyUnreferencedTextures.Count() != 0;
}
void CTextureManager::CoolTextureCache()
{
FOR_EACH_VEC( m_preloadedTextures, i )
{
m_preloadedTextures[ i ]->Release();
}
m_preloadedTextures.RemoveAll();
}
void CTextureManager::RequestAllMipmaps( ITextureInternal* pTex )
{
Assert( pTex );
// Don't mark these for load if suspended
if ( m_iSuspendTextureStreaming )
return;
unsigned int nTexFlags = pTex->GetFlags();
// If this isn't a streamable texture or if there are no mipmaps, there's nothing to do.
if ( !( nTexFlags & TEXTUREFLAGS_STREAMABLE ) || ( nTexFlags & TEXTUREFLAGS_NOMIP ) )
return;
m_asyncStreamingRequests.PushItem( pTex );
}
void CTextureManager::EvictAllTextures()
{
FOR_EACH_DICT_FAST( m_TextureList, i )
{
ITextureInternal* pTex = m_TextureList[ i ];
if ( !pTex )
continue;
// If the fine mipmaps are present
if ( ( ( pTex->GetFlags() & TEXTUREFLAGS_STREAMABLE ) != 0 ) && pTex->GetTargetResidence() == RESIDENT_FULL )
pTex->MakeResident( RESIDENT_PARTIAL );
}
}
CON_COMMAND( mat_evict_all, "Evict all fine mipmaps from the gpu" )
{
TextureManager()->EvictAllTextures();
}
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
static ImageFormat GetImageFormatRawReadback( ImageFormat fmt )
{
switch ( fmt )
{
case IMAGE_FORMAT_RGBA8888:
return IMAGE_FORMAT_BGRA8888;
case IMAGE_FORMAT_BGRA8888:
return IMAGE_FORMAT_BGRA8888;
default:
Assert( !"Unsupported format in GetImageFormatRawReadback, this will likely result in color-swapped textures" );
};
return fmt;
}
Reference in New Issue View Git Blame Copy Permalink