You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3103 lines
91 KiB
3103 lines
91 KiB
5 years ago
|
//========= 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;
|
||
|
}
|
||
|
|