//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=====================================================================================//
#ifdef PROTECTED_THINGS_ENABLE
#undef PROTECTED_THINGS_ENABLE
#endif
#include "platform.h"
// HACK: Need ShellExecute for PSD updates
#ifdef IS_WINDOWS_PC
#include <windows.h>
#include <shellapi.h>
#pragma comment ( lib, "shell32" )
#endif
#include "materialsystem_global.h"
#include "shaderapi/ishaderapi.h"
#include "itextureinternal.h"
#include "utlsymbol.h"
#include "time.h"
#include <sys/types.h>
#include <sys/stat.h>
#include "bitmap/imageformat.h"
#include "bitmap/tgaloader.h"
#include "bitmap/tgawriter.h"
#ifdef _WIN32
#include "direct.h"
#endif
#include "colorspace.h"
#include "string.h"
#include <stdlib.h>
#include "utlmemory.h"
#include "IHardwareConfigInternal.h"
#include "filesystem.h"
#include "tier1/strtools.h"
#include "vtf/vtf.h"
#include "materialsystem/materialsystem_config.h"
#include "mempool.h"
#include "texturemanager.h"
#include "utlbuffer.h"
#include "pixelwriter.h"
#include "tier1/callqueue.h"
#include "tier1/UtlStringMap.h"
#include "filesystem/IQueuedLoader.h"
#include "tier2/fileutils.h"
#include "filesystem.h"
#include "tier2/p4helpers.h"
#include "tier2/tier2.h"
#include "p4lib/ip4.h"
#include "ctype.h"
#include "ifilelist.h"
#include "tier0/icommandline.h"
#include "tier0/vprof.h"
// NOTE: This must be the last file included!!!
#include "tier0/memdbgon.h"
// this allows the command line to force the "all mips" flag to on for all textures
bool g_bForceTextureAllMips = false;
#if defined(IS_WINDOWS_PC)
static void ConVarChanged_mat_managedtextures( IConVar *var, const char *pOldValue, float flOldValue );
static ConVar mat_managedtextures( "mat_managedtextures", "1", FCVAR_ARCHIVE, "If set, allows Direct3D to manage texture uploading at the cost of extra system memory", &ConVarChanged_mat_managedtextures );
static void ConVarChanged_mat_managedtextures( IConVar *var, const char *pOldValue, float flOldValue )
{
if ( mat_managedtextures.GetBool() != (flOldValue != 0) )
{
materials->ReleaseResources();
materials->ReacquireResources();
}
}
#endif
static ConVar mat_spew_on_texture_size( "mat_spew_on_texture_size", "0", 0, "Print warnings about vtf content that isn't of the expected size" );
static ConVar mat_lodin_time( "mat_lodin_time", "5.0", FCVAR_DEVELOPMENTONLY );
static ConVar mat_lodin_hidden_pop( "mat_lodin_hidden_pop", "1", FCVAR_DEVELOPMENTONLY );
#define TEXTURE_FNAME_EXTENSION ".vtf"
#define TEXTURE_FNAME_EXTENSION_LEN 4
#define TEXTURE_FNAME_EXTENSION_NORMAL "_normal.vtf"
#ifdef STAGING_ONLY
ConVar mat_spewalloc( "mat_spewalloc", "0" );
#else
ConVar mat_spewalloc( "mat_spewalloc", "0", FCVAR_ARCHIVE | FCVAR_DEVELOPMENTONLY );
#endif
struct TexDimensions_t
{
uint16 m_nWidth;
uint16 m_nHeight;
uint16 m_nMipCount;
uint16 m_nDepth;
TexDimensions_t( uint16 nWidth = 0, uint nHeight = 0, uint nMipCount = 0, uint16 nDepth = 1 )
: m_nWidth( nWidth )
, m_nHeight( nHeight )
, m_nMipCount( nMipCount )
, m_nDepth( nDepth )
{ }
};
#ifdef STAGING_ONLY
struct TexInfo_t
{
CUtlString m_Name;
unsigned short m_nWidth;
unsigned short m_nHeight;
unsigned short m_nDepth;
unsigned short m_nMipCount;
unsigned short m_nFrameCount;
unsigned short m_nCopies;
ImageFormat m_Format;
uint64 ComputeTexSize() const
{
uint64 total = 0;
unsigned short width = m_nWidth;
unsigned short height = m_nHeight;
unsigned short depth = m_nDepth;
for ( int mip = 0; mip < m_nMipCount; ++mip )
{
// Make sure that mip count lines up with the count
Assert( width > 1 || height > 1 || depth > 1 || ( mip == ( m_nMipCount - 1 ) ) );
total += ImageLoader::GetMemRequired( width, height, depth, m_Format, false );
width = Max( 1, width >> 1 );
height = Max( 1, height >> 1 );
depth = Max( 1, depth >> 1 );
}
return total * Min( (unsigned short) 1, m_nFrameCount ) * Min( (unsigned short) 1, m_nCopies );
}
TexInfo_t( const char* name = "", unsigned short w = 0, unsigned short h = 0, unsigned short d = 0, unsigned short mips = 0, unsigned short frames = 0, unsigned short copies = 0, ImageFormat fmt = IMAGE_FORMAT_UNKNOWN )
: m_nWidth( w )
, m_nHeight( h )
, m_nDepth( d )
, m_nMipCount( mips )
, m_nFrameCount( frames )
, m_nCopies( copies )
, m_Format( fmt )
{
if ( name && name[0] )
m_Name = name;
else
m_Name = "<unnamed>";
}
};
CUtlMap< ITexture*, TexInfo_t > g_currentTextures( DefLessFunc( ITexture* ) );
#endif
//-----------------------------------------------------------------------------
// Internal texture flags
//-----------------------------------------------------------------------------
enum InternalTextureFlags
{
TEXTUREFLAGSINTERNAL_ERROR = 0x00000001,
TEXTUREFLAGSINTERNAL_ALLOCATED = 0x00000002,
TEXTUREFLAGSINTERNAL_PRELOADED = 0x00000004, // 360: textures that went through the preload process
TEXTUREFLAGSINTERNAL_QUEUEDLOAD = 0x00000008, // 360: load using the queued loader
TEXTUREFLAGSINTERNAL_EXCLUDED = 0x00000020, // actual exclusion state
TEXTUREFLAGSINTERNAL_SHOULDEXCLUDE = 0x00000040, // desired exclusion state
TEXTUREFLAGSINTERNAL_TEMPRENDERTARGET = 0x00000080, // 360: should only allocate texture bits upon first resolve, destroy at level end
};
static int GetThreadId();
static bool SLoadTextureBitsFromFile( IVTFTexture **ppOutVtfTexture, FileHandle_t hFile, unsigned int nFlags, TextureLODControlSettings_t* pInOutCachedFileLodSettings, int nDesiredDimensionLimit, unsigned short* pOutStreamedMips, const char* pName, const char* pCacheFileName, TexDimensions_t* pOptOutMappingDims = NULL, TexDimensions_t* pOptOutActualDims = NULL, TexDimensions_t* pOptOutAllocatedDims = NULL, unsigned int* pOptOutStripFlags = NULL );
static int ComputeActualMipCount( const TexDimensions_t& actualDims, unsigned int nFlags );
static int ComputeMipSkipCount( const char* pName, const TexDimensions_t& mappingDims, bool bIgnorePicmip, IVTFTexture *pOptVTFTexture, unsigned int nFlags, int nDesiredDimensionLimit, unsigned short* pOutStreamedMips, TextureLODControlSettings_t* pInOutCachedFileLodSettings, TexDimensions_t* pOptOutActualDims, TexDimensions_t* pOptOutAllocatedDims, unsigned int* pOptOutStripFlags );
static int GetOptimalReadBuffer( CUtlBuffer *pOutOptimalBuffer, FileHandle_t hFile, int nFileSize );
static void FreeOptimalReadBuffer( int nMaxSize );
//-----------------------------------------------------------------------------
// Use Warning to show texture flags.
//-----------------------------------------------------------------------------
static void PrintFlags( unsigned int flags )
{
if ( flags & TEXTUREFLAGS_NOMIP )
{
Warning( "TEXTUREFLAGS_NOMIP|" );
}
if ( flags & TEXTUREFLAGS_NOLOD )
{
Warning( "TEXTUREFLAGS_NOLOD|" );
}
if ( flags & TEXTUREFLAGS_SRGB )
{
Warning( "TEXTUREFLAGS_SRGB|" );
}
if ( flags & TEXTUREFLAGS_POINTSAMPLE )
{
Warning( "TEXTUREFLAGS_POINTSAMPLE|" );
}
if ( flags & TEXTUREFLAGS_TRILINEAR )
{
Warning( "TEXTUREFLAGS_TRILINEAR|" );
}
if ( flags & TEXTUREFLAGS_CLAMPS )
{
Warning( "TEXTUREFLAGS_CLAMPS|" );
}
if ( flags & TEXTUREFLAGS_CLAMPT )
{
Warning( "TEXTUREFLAGS_CLAMPT|" );
}
if ( flags & TEXTUREFLAGS_HINT_DXT5 )
{
Warning( "TEXTUREFLAGS_HINT_DXT5|" );
}
if ( flags & TEXTUREFLAGS_ANISOTROPIC )
{
Warning( "TEXTUREFLAGS_ANISOTROPIC|" );
}
if ( flags & TEXTUREFLAGS_PROCEDURAL )
{
Warning( "TEXTUREFLAGS_PROCEDURAL|" );
}
if ( flags & TEXTUREFLAGS_ALL_MIPS )
{
Warning( "TEXTUREFLAGS_ALL_MIPS|" );
}
if ( flags & TEXTUREFLAGS_SINGLECOPY )
{
Warning( "TEXTUREFLAGS_SINGLECOPY|" );
}
if ( flags & TEXTUREFLAGS_STAGING_MEMORY )
{
Warning( "TEXTUREFLAGS_STAGING_MEMORY|" );
}
if ( flags & TEXTUREFLAGS_IGNORE_PICMIP )
{
Warning( "TEXTUREFLAGS_IGNORE_PICMIP|" );
}
if ( flags & TEXTUREFLAGS_IMMEDIATE_CLEANUP )
{
Warning( "TEXTUREFLAGS_IMMEDIATE_CLEANUP|" );
}
}
namespace TextureLodOverride
{
struct OverrideInfo
{
OverrideInfo() : x( 0 ), y( 0 ) {}
OverrideInfo( int8 x_, int8 y_ ) : x( x_ ), y( y_ ) {}
int8 x, y;
};
// Override map
typedef CUtlStringMap< OverrideInfo > OverrideMap_t;
OverrideMap_t s_OverrideMap;
// Retrieves the override info adjustments
OverrideInfo Get( char const *szName )
{
UtlSymId_t idx = s_OverrideMap.Find( szName );
if ( idx != s_OverrideMap.InvalidIndex() )
return s_OverrideMap[ idx ];
else
return OverrideInfo();
}
// Combines the existing override info adjustments with the given one
void Add( char const *szName, OverrideInfo oi )
{
OverrideInfo oiex = Get( szName );
oiex.x += oi.x;
oiex.y += oi.y;
s_OverrideMap[ szName ] = oiex;
}
}; // end namespace TextureLodOverride
class CTextureStreamingJob;
//-----------------------------------------------------------------------------
// Base texture class
//-----------------------------------------------------------------------------
class CTexture : public ITextureInternal
{
public:
CTexture();
virtual ~CTexture();
virtual const char *GetName( void ) const;
const char *GetTextureGroupName( void ) const;
// Stats about the texture itself
virtual ImageFormat GetImageFormat() const;
NormalDecodeMode_t GetNormalDecodeMode() const { return NORMAL_DECODE_NONE; }
virtual int GetMappingWidth() const;
virtual int GetMappingHeight() const;
virtual int GetActualWidth() const;
virtual int GetActualHeight() const;
virtual int GetNumAnimationFrames() const;
virtual bool IsTranslucent() const;
virtual void GetReflectivity( Vector& reflectivity );
// Reference counting
virtual void IncrementReferenceCount( );
virtual void DecrementReferenceCount( );
virtual int GetReferenceCount( );
// Used to modify the texture bits (procedural textures only)
virtual void SetTextureRegenerator( ITextureRegenerator *pTextureRegen );
// Little helper polling methods
virtual bool IsNormalMap( ) const;
virtual bool IsCubeMap( void ) const;
virtual bool IsRenderTarget( ) const;
virtual bool IsTempRenderTarget( void ) const;
virtual bool IsProcedural() const;
virtual bool IsMipmapped() const;
virtual bool IsError() const;
// For volume textures
virtual bool IsVolumeTexture() const;
virtual int GetMappingDepth() const;
virtual int GetActualDepth() const;
// Various ways of initializing the texture
void InitFileTexture( const char *pTextureFile, const char *pTextureGroupName );
void InitProceduralTexture( const char *pTextureName, const char *pTextureGroupName, int w, int h, int d, ImageFormat fmt, int nFlags, ITextureRegenerator* generator = NULL );
// Releases the texture's hw memory
void ReleaseMemory();
virtual void OnRestore();
// Sets the filtering modes on the texture we're modifying
void SetFilteringAndClampingMode( bool bOnlyLodValues = false );
void Download( Rect_t *pRect = NULL, int nAdditionalCreationFlags = 0 );
// Loads up information about the texture
virtual void Precache();
// FIXME: Bogus methods... can we please delete these?
virtual void GetLowResColorSample( float s, float t, float *color ) const;
// Gets texture resource data of the specified type.
// Params:
// eDataType type of resource to retrieve.
// pnumBytes on return is the number of bytes available in the read-only data buffer or is undefined
// Returns:
// pointer to the resource data, or NULL. Note that the data from this pointer can disappear when
// the texture goes away - you want to copy this data!
virtual void *GetResourceData( uint32 eDataType, size_t *pNumBytes ) const;
virtual int GetApproximateVidMemBytes( void ) const;
// Stretch blit the framebuffer into this texture.
virtual void CopyFrameBufferToMe( int nRenderTargetID = 0, Rect_t *pSrcRect = NULL, Rect_t *pDstRect = NULL );
virtual void CopyMeToFrameBuffer( int nRenderTargetID = 0, Rect_t *pSrcRect = NULL, Rect_t *pDstRect = NULL );
virtual ITexture *GetEmbeddedTexture( int nIndex );
// Get the shaderapi texture handle associated w/ a particular frame
virtual ShaderAPITextureHandle_t GetTextureHandle( int nFrame, int nChannel = 0 );
// Sets the texture as the render target
virtual void Bind( Sampler_t sampler );
virtual void Bind( Sampler_t sampler1, int nFrame, Sampler_t sampler2 = (Sampler_t) -1 );
virtual void BindVertexTexture( VertexTextureSampler_t stage, int nFrame );
// Set this texture as a render target
bool SetRenderTarget( int nRenderTargetID );
// Set this texture as a render target (optionally set depth texture as depth buffer as well)
bool SetRenderTarget( int nRenderTargetID, ITexture *pDepthTexture);
virtual void MarkAsPreloaded( bool bSet );
virtual bool IsPreloaded() const;
virtual void MarkAsExcluded( bool bSet, int nDimensionsLimit );
virtual bool UpdateExcludedState( void );
// Retrieve the vtf flags mask
virtual unsigned int GetFlags( void ) const;
virtual void ForceLODOverride( int iNumLodsOverrideUpOrDown );
void GetFilename( char *pOut, int maxLen ) const;
virtual void ReloadFilesInList( IFileList *pFilesToReload );
// Save texture to a file.
virtual bool SaveToFile( const char *fileName );
// Load the texture from a file.
bool AsyncReadTextureFromFile( IVTFTexture* pVTFTexture, unsigned int nAdditionalCreationFlags );
void AsyncCancelReadTexture( );
virtual void Map( void** pOutBits, int* pOutPitch );
virtual void Unmap();
virtual ResidencyType_t GetCurrentResidence() const { return m_residenceCurrent; }
virtual ResidencyType_t GetTargetResidence() const { return m_residenceTarget; }
virtual bool MakeResident( ResidencyType_t newResidence );
virtual void UpdateLodBias();
protected:
bool IsDepthTextureFormat( ImageFormat fmt );
void ReconstructTexture( bool bCopyFromCurrent );
void GetCacheFilename( char* pOutBuffer, int bufferSize ) const;
bool GetFileHandle( FileHandle_t *pOutFileHandle, char *pCacheFilename, char **ppResolvedFilename ) const;
void ReconstructPartialTexture( const Rect_t *pRect );
bool HasBeenAllocated() const;
void WriteDataToShaderAPITexture( int nFrameCount, int nFaceCount, int nFirstFace, int nMipCount, IVTFTexture *pVTFTexture, ImageFormat fmt );
// Initializes/shuts down the texture
void Init( int w, int h, int d, ImageFormat fmt, int iFlags, int iFrameCount );
void Shutdown();
// Sets the texture name
void SetName( const char* pName );
// Assigns/releases texture IDs for our animation frames
void AllocateTextureHandles( );
void ReleaseTextureHandles( );
// Calculates info about whether we can make the texture smaller and by how much
// Returns the number of skipped mip levels
int ComputeActualSize( bool bIgnorePicmip = false, IVTFTexture *pVTFTexture = NULL, bool bTextureMigration = false );
// Computes the actual format of the texture given a desired src format
ImageFormat ComputeActualFormat( ImageFormat srcFormat );
// Creates/releases the shader api texture
bool AllocateShaderAPITextures();
void FreeShaderAPITextures();
void MigrateShaderAPITextures();
void NotifyUnloadedFile();
// Download bits
void DownloadTexture( Rect_t *pRect, bool bCopyFromCurrent = false );
void ReconstructTextureBits(Rect_t *pRect);
// Gets us modifying a particular frame of our texture
void Modify( int iFrame );
// Sets the texture clamping state on the currently modified frame
void SetWrapState( );
// Sets the texture filtering state on the currently modified frame
void SetFilterState();
// Sets the lod state on the currently modified frame
void SetLodState();
// Loads the texture bits from a file. Optionally provides absolute path
IVTFTexture *LoadTextureBitsFromFile( char *pCacheFileName, char **pResolvedFilename );
IVTFTexture *HandleFileLoadFailedTexture( IVTFTexture *pVTFTexture );
// Generates the procedural bits
IVTFTexture *ReconstructProceduralBits( );
IVTFTexture *ReconstructPartialProceduralBits( const Rect_t *pRect, Rect_t *pActualRect );
// Sets up debugging texture bits, if appropriate
bool SetupDebuggingTextures( IVTFTexture *pTexture );
// Generate a texture that shows the various mip levels
void GenerateShowMipLevelsTextures( IVTFTexture *pTexture );
void Cleanup( void );
// Converts a source image read from disk into its actual format
bool ConvertToActualFormat( IVTFTexture *pTexture );
// Builds the low-res image from the texture
void LoadLowResTexture( IVTFTexture *pTexture );
void CopyLowResImageToTexture( IVTFTexture *pTexture );
void GetDownloadFaceCount( int &nFirstFace, int &nFaceCount );
void ComputeMipLevelSubRect( const Rect_t* pSrcRect, int nMipLevel, Rect_t *pSubRect );
IVTFTexture *GetScratchVTFTexture( );
void ReleaseScratchVTFTexture( IVTFTexture* tex );
void ApplyRenderTargetSizeMode( int &width, int &height, ImageFormat fmt );
virtual void CopyToStagingTexture( ITexture* pDstTex );
virtual void SetErrorTexture( bool _isErrorTexture );
// Texture streaming
void MakeNonResident();
void MakePartiallyResident();
bool MakeFullyResident();
void CancelStreamingJob( bool bJobMustExist = true );
void OnStreamingJobComplete( ResidencyType_t newResidenceCurrent );
protected:
#ifdef _DEBUG
char *m_pDebugName;
#endif
// Reflectivity vector
Vector m_vecReflectivity;
CUtlSymbol m_Name;
// What texture group this texture is in (winds up setting counters based on the group name,
// then the budget panel views the counters).
CUtlSymbol m_TextureGroupName;
unsigned int m_nFlags;
unsigned int m_nInternalFlags;
CInterlockedInt m_nRefCount;
// This is the *desired* image format, which may or may not represent reality
ImageFormat m_ImageFormat;
// mapping dimensions and actual dimensions can/will vary due to user settings, hardware support, etc.
// Allocated is what is physically allocated on the hardware at this instant, and considers texture streaming.
TexDimensions_t m_dimsMapping;
TexDimensions_t m_dimsActual;
TexDimensions_t m_dimsAllocated;
// This is the iWidth/iHeight for whatever is downloaded to the card, ignoring current streaming settings
// Some callers want to know how big the texture is if all data was present, and that's this.
// TODO: Rename this before check in.
unsigned short m_nFrameCount;
// These are the values for what is truly allocated on the card, including streaming settings.
unsigned short m_nStreamingMips;
unsigned short m_nOriginalRTWidth; // The values they initially specified. We generated a different width
unsigned short m_nOriginalRTHeight; // and height based on screen size and the flags they specify.
unsigned char m_LowResImageWidth;
unsigned char m_LowResImageHeight;
unsigned short m_nDesiredDimensionLimit; // part of texture exclusion
unsigned short m_nActualDimensionLimit; // value not necessarily accurate, but mismatch denotes dirty state
// m_pStreamingJob is refcounted, but it is not safe to call SafeRelease directly on it--you must call
// CancelStreamingJob to ensure that releasing it doesn't cause a crash.
CTextureStreamingJob* m_pStreamingJob;
IVTFTexture* m_pStreamingVTF;
ResidencyType_t m_residenceTarget;
ResidencyType_t m_residenceCurrent;
int m_lodClamp;
int m_lastLodBiasAdjustFrame;
float m_lodBiasInitial;
float m_lodBiasCurrent;
double m_lodBiasStartTime;
// If the read failed, this will be true. We can't just return from the function because the call may
// happen in the async thread.
bool m_bStreamingFileReadFailed;
// The set of texture ids for each animation frame
ShaderAPITextureHandle_t *m_pTextureHandles;
TextureLODControlSettings_t m_cachedFileLodSettings;
// lowresimage info - used for getting color data from a texture
// without having a huge system mem overhead.
// FIXME: We should keep this in compressed form. .is currently decompressed at load time.
unsigned char *m_pLowResImage;
ITextureRegenerator *m_pTextureRegenerator;
// Used to help decide whether or not to recreate the render target if AA changes.
RenderTargetType_t m_nOriginalRenderTargetType;
RenderTargetSizeMode_t m_RenderTargetSizeMode;
// Fixed-size allocator
// DECLARE_FIXEDSIZE_ALLOCATOR( CTexture );
public:
void InitRenderTarget( const char *pRTName, int w, int h, RenderTargetSizeMode_t sizeMode,
ImageFormat fmt, RenderTargetType_t type, unsigned int textureFlags,
unsigned int renderTargetFlags );
virtual void DeleteIfUnreferenced();
void FixupTexture( const void *pData, int nSize, LoaderError_t loaderError );
void SwapContents( ITexture *pOther );
protected:
// private data, generally from VTF resource extensions
struct DataChunk
{
void Allocate( unsigned int numBytes )
{
m_pvData = new unsigned char[ numBytes ];
m_numBytes = numBytes;
}
void Deallocate() const { delete [] m_pvData; }
unsigned int m_eType;
unsigned int m_numBytes;
unsigned char *m_pvData;
};
CUtlVector< DataChunk > m_arrDataChunks;
struct ScratchVTF
{
ScratchVTF( CTexture* _tex ) : m_pParent( _tex ), m_pScratchVTF( _tex->GetScratchVTFTexture( ) ) { }
~ScratchVTF( )
{
if ( m_pScratchVTF )
m_pParent->ReleaseScratchVTFTexture( m_pScratchVTF );
m_pScratchVTF = NULL;
}
IVTFTexture* Get() const { return m_pScratchVTF; }
void TakeOwnership() { m_pScratchVTF = NULL; }
CTexture* m_pParent;
IVTFTexture* m_pScratchVTF;
};
friend class CTextureStreamingJob;
};
class CTextureStreamingJob : public IAsyncTextureOperationReceiver
{
public:
CTextureStreamingJob( CTexture* pTex ) : m_referenceCount( 0 ), m_pOwner( pTex ) { Assert( m_pOwner != NULL ); m_pOwner->AddRef(); }
virtual ~CTextureStreamingJob() { SafeRelease( &m_pOwner ); }
virtual int AddRef() OVERRIDE { return ++m_referenceCount; }
virtual int Release() OVERRIDE { int retVal = --m_referenceCount; Assert( retVal >= 0 ); if ( retVal == 0 ) { delete this; } return retVal; }
virtual int GetRefCount() const OVERRIDE { return m_referenceCount; }
virtual void OnAsyncCreateComplete( ITexture* pTex, void* pExtraArgs ) OVERRIDE { Assert( !"unimpl" ); }
virtual void OnAsyncFindComplete( ITexture* pTex, void* pExtraArgs ) OVERRIDE;
virtual void OnAsyncMapComplete( ITexture* pTex, void* pExtraArgs, void* pMemory, int nPitch ) { Assert( !"unimpl" ); }
virtual void OnAsyncReadbackBegin( ITexture* pDst, ITexture* pSrc, void* pExtraArgs ) OVERRIDE { Assert( !"unimpl" ); }
void ForgetOwner( ITextureInternal* pTex ) { Assert( pTex == m_pOwner ); SafeRelease( &m_pOwner ); }
private:
CInterlockedInt m_referenceCount;
CTexture* m_pOwner;
};
//////////////////////////////////////////////////////////////////////////
//
// CReferenceToHandleTexture is a special implementation of ITexture
// to be used solely for binding the texture handle when rendering.
// It is used when a D3D texture handle is available, but should be used
// at a higher level of abstraction requiring an ITexture or ITextureInternal.
//
//////////////////////////////////////////////////////////////////////////
class CReferenceToHandleTexture : public ITextureInternal
{
public:
CReferenceToHandleTexture();
virtual ~CReferenceToHandleTexture();
virtual const char *GetName( void ) const { return m_Name.String(); }
const char *GetTextureGroupName( void ) const { return m_TextureGroupName.String(); }
// Stats about the texture itself
virtual ImageFormat GetImageFormat() const { return IMAGE_FORMAT_UNKNOWN; }
virtual NormalDecodeMode_t GetNormalDecodeMode() const { return NORMAL_DECODE_NONE; }
virtual int GetMappingWidth() const { return 1; }
virtual int GetMappingHeight() const { return 1; }
virtual int GetActualWidth() const { return 1; }
virtual int GetActualHeight() const { return 1; }
virtual int GetNumAnimationFrames() const { return 1; }
virtual bool IsTranslucent() const { return false; }
virtual void GetReflectivity( Vector& reflectivity ) { reflectivity.Zero(); }
// Reference counting
virtual void IncrementReferenceCount( ) { ++ m_nRefCount; }
virtual void DecrementReferenceCount( ) { -- m_nRefCount; }
virtual int GetReferenceCount( ) { return m_nRefCount; }
// Used to modify the texture bits (procedural textures only)
virtual void SetTextureRegenerator( ITextureRegenerator *pTextureRegen ) { NULL; }
// Little helper polling methods
virtual bool IsNormalMap( ) const { return false; }
virtual bool IsCubeMap( void ) const { return false; }
virtual bool IsRenderTarget( ) const { return false; }
virtual bool IsTempRenderTarget( void ) const { return false; }
virtual bool IsProcedural() const { return true; }
virtual bool IsMipmapped() const { return false; }
virtual bool IsError() const { return false; }
// For volume textures
virtual bool IsVolumeTexture() const { return false; }
virtual int GetMappingDepth() const { return 1; }
virtual int GetActualDepth() const { return 1; }
// Releases the texture's hw memory
void ReleaseMemory() { NULL; }
virtual void OnRestore() { NULL; }
// Sets the filtering modes on the texture we're modifying
void SetFilteringAndClampingMode( bool bOnlyLodValues = false ) { NULL; }
void Download( Rect_t *pRect = NULL, int nAdditionalCreationFlags = 0 ) { NULL; }
// Loads up information about the texture
virtual void Precache() { NULL; }
// FIXME: Bogus methods... can we please delete these?
virtual void GetLowResColorSample( float s, float t, float *color ) const { NULL; }
// Gets texture resource data of the specified type.
// Params:
// eDataType type of resource to retrieve.
// pnumBytes on return is the number of bytes available in the read-only data buffer or is undefined
// Returns:
// pointer to the resource data, or NULL. Note that the data from this pointer can disappear when
// the texture goes away - you want to copy this data!
virtual void *GetResourceData( uint32 eDataType, size_t *pNumBytes ) const { return NULL; }
virtual int GetApproximateVidMemBytes( void ) const { return 32; }
// Stretch blit the framebuffer into this texture.
virtual void CopyFrameBufferToMe( int nRenderTargetID = 0, Rect_t *pSrcRect = NULL, Rect_t *pDstRect = NULL ) { NULL; }
virtual void CopyMeToFrameBuffer( int nRenderTargetID = 0, Rect_t *pSrcRect = NULL, Rect_t *pDstRect = NULL ) { NULL; }
virtual ITexture *GetEmbeddedTexture( int nIndex ) { return ( nIndex == 0 ) ? this : NULL; }
// Get the shaderapi texture handle associated w/ a particular frame
virtual ShaderAPITextureHandle_t GetTextureHandle( int nFrame, int nTextureChannel = 0 ) { return m_hTexture; }
// Bind the texture
virtual void Bind( Sampler_t sampler );
virtual void Bind( Sampler_t sampler1, int nFrame, Sampler_t sampler2 = (Sampler_t) -1 );
virtual void BindVertexTexture( VertexTextureSampler_t stage, int nFrame );
// Set this texture as a render target
bool SetRenderTarget( int nRenderTargetID ) { return SetRenderTarget( nRenderTargetID, NULL ); }
// Set this texture as a render target (optionally set depth texture as depth buffer as well)
bool SetRenderTarget( int nRenderTargetID, ITexture *pDepthTexture) { return false; }
virtual void MarkAsPreloaded( bool bSet ) { NULL; }
virtual bool IsPreloaded() const { return true; }
virtual void MarkAsExcluded( bool bSet, int nDimensionsLimit ) { NULL; }
virtual bool UpdateExcludedState( void ) { return true; }
// Retrieve the vtf flags mask
virtual unsigned int GetFlags( void ) const { return 0; }
virtual void ForceLODOverride( int iNumLodsOverrideUpOrDown ) { NULL; }
virtual void ReloadFilesInList( IFileList *pFilesToReload ) {}
// Save texture to a file.
virtual bool SaveToFile( const char *fileName ) { return false; }
virtual bool AsyncReadTextureFromFile( IVTFTexture* pVTFTexture, unsigned int nAdditionalCreationFlags ) { Assert( !"Should never get here." ); return false; }
virtual void AsyncCancelReadTexture() { Assert( !"Should never get here." ); }
virtual void CopyToStagingTexture( ITexture* pDstTex ) { Assert( !"Should never get here." ); };
// Map and unmap. These can fail. And can cause a very significant perf penalty. Be very careful with them.
virtual void Map( void** pOutBits, int* pOutPitch ) { }
virtual void Unmap() { }
virtual ResidencyType_t GetCurrentResidence() const { return RESIDENT_FULL; }
virtual ResidencyType_t GetTargetResidence() const { return RESIDENT_FULL; }
virtual bool MakeResident( ResidencyType_t newResidence ) { Assert( !"Unimpl" ); return true; }
virtual void UpdateLodBias() {}
virtual void SetErrorTexture( bool isErrorTexture ) { }
protected:
#ifdef _DEBUG
char *m_pDebugName;
#endif
CUtlSymbol m_Name;
// What texture group this texture is in (winds up setting counters based on the group name,
// then the budget panel views the counters).
CUtlSymbol m_TextureGroupName;
// The set of texture ids for each animation frame
ShaderAPITextureHandle_t m_hTexture;
// Refcount
int m_nRefCount;
public:
virtual void DeleteIfUnreferenced();
void FixupTexture( const void *pData, int nSize, LoaderError_t loaderError ) { NULL; }
void SwapContents( ITexture *pOther ) { NULL; }
public:
void SetName( char const *szName );
void InitFromHandle(
const char *pTextureName,
const char *pTextureGroupName,
ShaderAPITextureHandle_t hTexture );
};
CReferenceToHandleTexture::CReferenceToHandleTexture() :
m_hTexture( INVALID_SHADERAPI_TEXTURE_HANDLE ),
#ifdef _DEBUG
m_pDebugName( NULL ),
#endif
m_nRefCount( 0 )
{
NULL;
}
CReferenceToHandleTexture::~CReferenceToHandleTexture()
{
#ifdef _DEBUG
if ( m_nRefCount != 0 )
{
Warning( "Reference Count(%d) != 0 in ~CReferenceToHandleTexture for texture \"%s\"\n", m_nRefCount, m_Name.String() );
}
if ( m_pDebugName )
{
delete [] m_pDebugName;
}
#endif
}
void CReferenceToHandleTexture::SetName( char const *szName )
{
// normalize and convert to a symbol
char szCleanName[MAX_PATH];
m_Name = NormalizeTextureName( szName, szCleanName, sizeof( szCleanName ) );
#ifdef _DEBUG
if ( m_pDebugName )
{
delete [] m_pDebugName;
}
int nLen = V_strlen( szCleanName ) + 1;
m_pDebugName = new char[nLen];
V_memcpy( m_pDebugName, szCleanName, nLen );
#endif
}
void CReferenceToHandleTexture::InitFromHandle( const char *pTextureName, const char *pTextureGroupName, ShaderAPITextureHandle_t hTexture )
{
SetName( pTextureName );
m_TextureGroupName = pTextureGroupName;
m_hTexture = hTexture;
}
void CReferenceToHandleTexture::Bind( Sampler_t sampler )
{
if ( g_pShaderDevice->IsUsingGraphics() )
{
g_pShaderAPI->BindTexture( sampler, m_hTexture );
}
}
// TODO: make paired textures work with mat_texture_list
void CReferenceToHandleTexture::Bind( Sampler_t sampler1, int nFrame, Sampler_t sampler2 /* = -1 */ )
{
if ( g_pShaderDevice->IsUsingGraphics() )
{
g_pShaderAPI->BindTexture( sampler1, m_hTexture );
}
}
void CReferenceToHandleTexture::BindVertexTexture( VertexTextureSampler_t sampler, int nFrame )
{
if ( g_pShaderDevice->IsUsingGraphics() )
{
g_pShaderAPI->BindVertexTexture( sampler, m_hTexture );
}
}
void CReferenceToHandleTexture::DeleteIfUnreferenced()
{
if ( m_nRefCount > 0 )
return;
TextureManager()->RemoveTexture( this );
}
//-----------------------------------------------------------------------------
// Fixed-size allocator
//-----------------------------------------------------------------------------
//DEFINE_FIXEDSIZE_ALLOCATOR( CTexture, 1024, true );
//-----------------------------------------------------------------------------
// Static instance of VTF texture
//-----------------------------------------------------------------------------
#define MAX_RENDER_THREADS 4
// For safety's sake, we allow any of the threads that intersect with rendering
// to have their own state vars. In practice, we expect only the matqueue thread
// and the main thread to ever hit s_pVTFTexture.
static IVTFTexture *s_pVTFTexture[ MAX_RENDER_THREADS ] = { NULL };
// We only expect that the main thread or the matqueue thread to actually touch
// these, but we still need a NULL and size of 0 for the other threads.
static void *s_pOptimalReadBuffer[ MAX_RENDER_THREADS ] = { NULL };
static int s_nOptimalReadBufferSize[ MAX_RENDER_THREADS ] = { 0 };
//-----------------------------------------------------------------------------
// Class factory methods
//-----------------------------------------------------------------------------
ITextureInternal *ITextureInternal::CreateFileTexture( const char *pFileName, const char *pTextureGroupName )
{
CTexture *pTex = new CTexture;
pTex->InitFileTexture( pFileName, pTextureGroupName );
return pTex;
}
ITextureInternal *ITextureInternal::CreateReferenceTextureFromHandle(
const char *pTextureName,
const char *pTextureGroupName,
ShaderAPITextureHandle_t hTexture )
{
CReferenceToHandleTexture *pTex = new CReferenceToHandleTexture;
pTex->InitFromHandle( pTextureName, pTextureGroupName, hTexture );
return pTex;
}
ITextureInternal *ITextureInternal::CreateProceduralTexture(
const char *pTextureName,
const char *pTextureGroupName,
int w,
int h,
int d,
ImageFormat fmt,
int nFlags,
ITextureRegenerator *generator)
{
CTexture *pTex = new CTexture;
pTex->InitProceduralTexture( pTextureName, pTextureGroupName, w, h, d, fmt, nFlags, generator );
pTex->IncrementReferenceCount();
return pTex;
}
// GR - named RT
ITextureInternal *ITextureInternal::CreateRenderTarget(
const char *pRTName,
int w,
int h,
RenderTargetSizeMode_t sizeMode,
ImageFormat fmt,
RenderTargetType_t type,
unsigned int textureFlags,
unsigned int renderTargetFlags )
{
CTexture *pTex = new CTexture;
pTex->InitRenderTarget( pRTName, w, h, sizeMode, fmt, type, textureFlags, renderTargetFlags );
return pTex;
}
//-----------------------------------------------------------------------------
// Rebuild and exisiting render target in place.
//-----------------------------------------------------------------------------
void ITextureInternal::ChangeRenderTarget(
ITextureInternal *pTex,
int w,
int h,
RenderTargetSizeMode_t sizeMode,
ImageFormat fmt,
RenderTargetType_t type,
unsigned int textureFlags,
unsigned int renderTargetFlags )
{
pTex->ReleaseMemory();
dynamic_cast< CTexture * >(pTex)->InitRenderTarget( pTex->GetName(), w, h, sizeMode, fmt, type, textureFlags, renderTargetFlags );
}
void ITextureInternal::Destroy( ITextureInternal *pTex, bool bSkipTexMgrCheck )
{
#ifdef STAGING_ONLY
if ( !bSkipTexMgrCheck && TextureManager()->HasPendingTextureDestroys() )
{
// Multithreading badness. This will cause a crash later! Grab JohnS or McJohn know!
DebuggerBreakIfDebugging_StagingOnly();
}
#endif
int iIndex = g_pTextureRefList->Find( static_cast<ITexture*>( pTex ) );
if ( iIndex != g_pTextureRefList->InvalidIndex () )
{
if ( g_pTextureRefList->Element(iIndex) != 0 )
{
int currentCount = g_pTextureRefList->Element( iIndex );
Warning( "Destroying a texture that is in the queue: %s (%p): %d!\n", pTex->GetName(), pTex, currentCount );
}
}
delete pTex;
}
//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
CTexture::CTexture() : m_ImageFormat( IMAGE_FORMAT_UNKNOWN )
{
m_dimsActual.m_nMipCount = 0;
m_dimsMapping.m_nWidth = 0;
m_dimsMapping.m_nHeight = 0;
m_dimsMapping.m_nDepth = 1;
m_dimsActual.m_nWidth = 0;
m_dimsActual.m_nHeight = 0;
m_dimsActual.m_nDepth = 1;
m_dimsAllocated.m_nWidth = 0;
m_dimsAllocated.m_nHeight = 0;
m_dimsAllocated.m_nDepth = 0;
m_dimsAllocated.m_nMipCount = 0;
m_nStreamingMips = 0;
m_nRefCount = 0;
m_nFlags = 0;
m_nInternalFlags = 0;
m_pTextureHandles = NULL;
m_nFrameCount = 0;
VectorClear( m_vecReflectivity );
m_pTextureRegenerator = NULL;
m_nOriginalRenderTargetType = NO_RENDER_TARGET;
m_RenderTargetSizeMode = RT_SIZE_NO_CHANGE;
m_nOriginalRTWidth = m_nOriginalRTHeight = 1;
m_LowResImageWidth = 0;
m_LowResImageHeight = 0;
m_pLowResImage = NULL;
m_pStreamingJob = NULL;
m_residenceTarget = RESIDENT_NONE;
m_residenceCurrent = RESIDENT_NONE;
m_lodClamp = 0;
m_lodBiasInitial = 0;
m_lodBiasCurrent = 0;
m_nDesiredDimensionLimit = 0;
m_nActualDimensionLimit = 0;
memset( &m_cachedFileLodSettings, 0, sizeof( m_cachedFileLodSettings ) );
#ifdef _DEBUG
m_pDebugName = NULL;
#endif
m_pStreamingVTF = NULL;
m_bStreamingFileReadFailed = false;
}
CTexture::~CTexture()
{
#ifdef _DEBUG
if ( m_nRefCount != 0 )
{
Warning( "Reference Count(%d) != 0 in ~CTexture for texture \"%s\"\n", (int)m_nRefCount, m_Name.String() );
}
#endif
Shutdown();
#ifdef _DEBUG
if ( m_pDebugName )
{
// delete[] m_pDebugName;
}
#endif
// Deliberately stomp our VTable so that we can detect cases where code tries to access freed materials.
int *p = (int *)this;
*p = 0xdeadbeef;
}
//-----------------------------------------------------------------------------
// Initializes the texture
//-----------------------------------------------------------------------------
void CTexture::Init( int w, int h, int d, ImageFormat fmt, int iFlags, int iFrameCount )
{
Assert( iFrameCount > 0 );
// This is necessary to prevent blowing away the allocated state,
// which is necessary for the ReleaseTextureHandles call below to work.
SetErrorTexture( false );
// free and release previous data
// cannot change to new intialization parameters yet
FreeShaderAPITextures();
ReleaseTextureHandles();
// update to new initialization parameters
// these are the *desired* new values
m_dimsMapping.m_nWidth = w;
m_dimsMapping.m_nHeight = h;
m_dimsMapping.m_nDepth = d;
m_ImageFormat = fmt;
m_nFrameCount = iFrameCount;
// We don't know the actual width and height until we get it ready to render
m_dimsActual.m_nWidth = m_dimsActual.m_nHeight = 0;
m_dimsActual.m_nDepth = 1;
m_dimsActual.m_nMipCount = 0;
m_dimsAllocated.m_nWidth = 0;
m_dimsAllocated.m_nHeight = 0;
m_dimsAllocated.m_nDepth = 0;
m_dimsAllocated.m_nMipCount = 0;
m_nStreamingMips = 0;
// Clear the m_nFlags bit. If we don't, then m_nFrameCount may end up being 1, and
// TEXTUREFLAGS_DEPTHRENDERTARGET could be set.
m_nFlags &= ~TEXTUREFLAGS_DEPTHRENDERTARGET;
m_nFlags |= iFlags;
CancelStreamingJob( false );
m_residenceTarget = RESIDENT_NONE;
m_residenceCurrent = RESIDENT_NONE;
m_lodClamp = 0;
m_lodBiasInitial = 0;
m_lodBiasCurrent = 0;
AllocateTextureHandles();
}
//-----------------------------------------------------------------------------
// Shuts down the texture
//-----------------------------------------------------------------------------
void CTexture::Shutdown()
{
Assert( m_pStreamingVTF == NULL );
// Clean up the low-res texture
delete[] m_pLowResImage;
m_pLowResImage = 0;
// Clean up the resources data
for ( DataChunk const *pDataChunk = m_arrDataChunks.Base(),
*pDataChunkEnd = pDataChunk + m_arrDataChunks.Count();
pDataChunk < pDataChunkEnd; ++pDataChunk )
{
pDataChunk->Deallocate();
}
m_arrDataChunks.RemoveAll();
// Frees the texture regen class
if ( m_pTextureRegenerator )
{
m_pTextureRegenerator->Release();
m_pTextureRegenerator = NULL;
}
CancelStreamingJob( false );
m_residenceTarget = RESIDENT_NONE;
m_residenceCurrent = RESIDENT_NONE;
m_lodClamp = 0;
m_lodBiasInitial = 0;
m_lodBiasCurrent = 0;
// This deletes the textures
FreeShaderAPITextures();
ReleaseTextureHandles();
NotifyUnloadedFile();
}
void CTexture::ReleaseMemory()
{
FreeShaderAPITextures();
NotifyUnloadedFile();
}
IVTFTexture *CTexture::GetScratchVTFTexture( )
{
const bool cbThreadInMatQueue = ( MaterialSystem()->GetRenderThreadId() == ThreadGetCurrentId() ); cbThreadInMatQueue;
Assert( cbThreadInMatQueue || ThreadInMainThread() );
const int ti = GetThreadId();
if ( !s_pVTFTexture[ ti ] )
s_pVTFTexture[ ti ] = CreateVTFTexture();
return s_pVTFTexture[ ti ];
}
void CTexture::ReleaseScratchVTFTexture( IVTFTexture* tex )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
const bool cbThreadInMatQueue = ( MaterialSystem()->GetRenderThreadId() == ThreadGetCurrentId() ); cbThreadInMatQueue;
Assert( cbThreadInMatQueue || ThreadInMainThread() );
Assert( m_pStreamingVTF == NULL || ThreadInMainThread() ); // Can only manipulate m_pStreamingVTF to release safely in main thread.
if ( m_pStreamingVTF )
{
Assert( tex == m_pStreamingVTF );
TextureManager()->ReleaseAsyncScratchVTF( m_pStreamingVTF );
m_pStreamingVTF = NULL;
return;
}
// Normal scratch main-thread vtf doesn't need to do anything.
}
//-----------------------------------------------------------------------------
//
// Various initialization methods
//
//-----------------------------------------------------------------------------
void CTexture::ApplyRenderTargetSizeMode( int &width, int &height, ImageFormat fmt )
{
width = m_nOriginalRTWidth;
height = m_nOriginalRTHeight;
switch ( m_RenderTargetSizeMode )
{
case RT_SIZE_FULL_FRAME_BUFFER:
{
MaterialSystem()->GetRenderTargetFrameBufferDimensions( width, height );
if( !HardwareConfig()->SupportsNonPow2Textures() )
{
width = FloorPow2( width + 1 );
height = FloorPow2( height + 1 );
}
}
break;
case RT_SIZE_FULL_FRAME_BUFFER_ROUNDED_UP:
{
MaterialSystem()->GetRenderTargetFrameBufferDimensions( width, height );
if( !HardwareConfig()->SupportsNonPow2Textures() )
{
width = CeilPow2( width );
height = CeilPow2( height );
}
}
break;
case RT_SIZE_PICMIP:
{
int fbWidth, fbHeight;
MaterialSystem()->GetRenderTargetFrameBufferDimensions( fbWidth, fbHeight );
int picmip = g_config.skipMipLevels;
while( picmip > 0 )
{
width >>= 1;
height >>= 1;
picmip--;
}
while( width > fbWidth )
{
width >>= 1;
}
while( height > fbHeight )
{
height >>= 1;
}
}
break;
case RT_SIZE_DEFAULT:
{
// Assume that the input is pow2.
Assert( ( width & ( width - 1 ) ) == 0 );
Assert( ( height & ( height - 1 ) ) == 0 );
int fbWidth, fbHeight;
MaterialSystem()->GetRenderTargetFrameBufferDimensions( fbWidth, fbHeight );
while( width > fbWidth )
{
width >>= 1;
}
while( height > fbHeight )
{
height >>= 1;
}
}
break;
case RT_SIZE_HDR:
{
MaterialSystem()->GetRenderTargetFrameBufferDimensions( width, height );
width = width / 4;
height = height / 4;
}
break;
case RT_SIZE_OFFSCREEN:
{
int fbWidth, fbHeight;
MaterialSystem()->GetRenderTargetFrameBufferDimensions( fbWidth, fbHeight );
// Shrink the buffer if it's bigger than back buffer. Otherwise, don't mess with it.
while( (width > fbWidth) || (height > fbHeight) )
{
width >>= 1;
height >>= 1;
}
}
break;
case RT_SIZE_LITERAL:
{
// Literal means literally don't mess with the dimensions. Unlike what OFFSCREEN does,
// which is totally to mess with the dimensions.
}
break;
case RT_SIZE_LITERAL_PICMIP:
{
// Don't do anything here, like literal. Later, we will pay attention to picmip settings s.t.
// these render targets look like other textures wrt Mapping Dimensions vs Actual Dimensions.
}
break;
case RT_SIZE_REPLAY_SCREENSHOT:
{
// Compute all possible resolutions if first time we're running this function
static bool bReplayInit = false;
static int m_aScreenshotWidths[ 3 ][ 2 ];
static ConVarRef replay_screenshotresolution( "replay_screenshotresolution" );
if ( !bReplayInit )
{
bReplayInit = true;
for ( int iAspect = 0; iAspect < 3; ++iAspect )
{
for ( int iRes = 0; iRes < 2; ++iRes )
{
int nWidth = (int)FastPow2( 9 + iRes );
m_aScreenshotWidths[ iAspect ][ iRes ] = nWidth;
}
}
}
// Get dimensions for unpadded image
int nUnpaddedWidth, nUnpaddedHeight;
// Figure out the proper screenshot size to use based on the aspect ratio
int nScreenWidth, nScreenHeight;
MaterialSystem()->GetRenderTargetFrameBufferDimensions( nScreenWidth, nScreenHeight );
float flAspectRatio = (float)nScreenWidth / nScreenHeight;
// Get the screenshot res
int iRes = clamp( replay_screenshotresolution.GetInt(), 0, 1 );
int iAspect;
if ( flAspectRatio == 16.0f/9 )
{
iAspect = 0;
}
else if ( flAspectRatio == 16.0f/10 )
{
iAspect = 1;
}
else
{
iAspect = 2; // 4:3
}
static float s_flInvAspectRatios[3] = { 9.0f/16.0f, 10.0f/16, 3.0f/4 };
nUnpaddedWidth = min( nScreenWidth, m_aScreenshotWidths[ iAspect ][ iRes ] );
nUnpaddedHeight = m_aScreenshotWidths[ iAspect ][ iRes ] * s_flInvAspectRatios[ iAspect ];
// Get dimensions for padded image based on unpadded size - must be power of 2 for a material/texture
width = SmallestPowerOfTwoGreaterOrEqual( nUnpaddedWidth );
height = SmallestPowerOfTwoGreaterOrEqual( nUnpaddedHeight );
}
break;
default:
{
if ( !HushAsserts() )
{
Assert( m_RenderTargetSizeMode == RT_SIZE_NO_CHANGE );
Assert( m_nOriginalRenderTargetType == RENDER_TARGET_NO_DEPTH ); // Only can use NO_CHANGE if we don't have a depth buffer.
}
}
break;
}
}
void CTexture::CopyToStagingTexture( ITexture* pDstTex )
{
Assert( pDstTex );
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
// Need to flush any commands in flight on our side of things
materials->Flush( false );
CTexture* pDstTexActual = assert_cast< CTexture* >( pDstTex );
// Then do the copy if everything is on the up and up.
if ( ( m_pTextureHandles == NULL || m_nFrameCount == 0 ) || ( pDstTexActual->m_pTextureHandles == NULL || pDstTexActual->m_nFrameCount == 0 ) )
{
Assert( !"Can't copy to a non-existent texture, may need to generate or something." );
return;
}
// Make sure we've actually got the right surface types.
Assert( m_nFlags & TEXTUREFLAGS_RENDERTARGET );
Assert( pDstTex->GetFlags() & TEXTUREFLAGS_STAGING_MEMORY );
g_pShaderAPI->CopyRenderTargetToScratchTexture( m_pTextureHandles[0], pDstTexActual->m_pTextureHandles[0] );
}
void CTexture::Map( void** pOutBits, int* pOutPitch )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
// Must be a staging texture to avoid catastrophic perf fail.
Assert( m_nFlags & TEXTUREFLAGS_STAGING_MEMORY );
if ( m_pTextureHandles == NULL || m_nFrameCount == 0 )
{
Assert( !"Can't map a non-existent texture, may need to generate or something." );
return;
}
g_pShaderAPI->LockRect( pOutBits, pOutPitch, m_pTextureHandles[ 0 ], 0, 0, 0, GetActualWidth(), GetActualHeight(), false, true );
}
void CTexture::Unmap()
{
if ( m_pTextureHandles == NULL || m_nFrameCount == 0 )
{
Assert( !"Can't unmap a non-existent texture, may need to generate or something." );
return;
}
g_pShaderAPI->UnlockRect( m_pTextureHandles[ 0 ], 0 );
}
bool CTexture::MakeResident( ResidencyType_t newResidence )
{
Assert( ( GetFlags() & TEXTUREFLAGS_STREAMABLE ) != 0 );
// If we already think we're supposed to go here, nothing to do and we should report success.
if ( m_residenceTarget == newResidence )
return true;
TM_ZONE_DEFAULT( TELEMETRY_LEVEL0 );
// What are we moving towards?
switch ( newResidence )
{
case RESIDENT_NONE:
MakeNonResident();
return true;
case RESIDENT_PARTIAL:
MakePartiallyResident();
return true;
case RESIDENT_FULL:
return MakeFullyResident();
default:
Assert( !"Missing switch statement" );
};
return false;
}
void CTexture::UpdateLodBias()
{
if ( m_lodBiasInitial == 0.0f )
return;
// Only perform adjustment once per frame.
if ( m_lastLodBiasAdjustFrame == g_FrameNum )
return;
bool bPopIn = mat_lodin_time.GetFloat() == 0;
if ( bPopIn && m_lodBiasInitial == 0.0f )
return;
if ( !bPopIn )
m_lodBiasCurrent = m_lodBiasInitial - ( Plat_FloatTime() - m_lodBiasStartTime ) / mat_lodin_time.GetFloat() * m_lodBiasInitial;
else
m_lodBiasCurrent = m_lodBiasInitial = 0.0f;
// If we're supposed to pop in when the object isn't visible and we have the opportunity...
if ( mat_lodin_hidden_pop.GetBool() && m_lastLodBiasAdjustFrame != g_FrameNum - 1 )
m_lodBiasCurrent = m_lodBiasInitial = 0.0f;
if ( m_lodBiasCurrent <= 0.0f )
{
m_lodBiasCurrent = m_lodBiasInitial = 0.0f;
m_lodBiasStartTime = 0;
}
m_lastLodBiasAdjustFrame = g_FrameNum;
SetFilteringAndClampingMode( true );
}
void CTexture::MakeNonResident()
{
if ( m_residenceCurrent != RESIDENT_NONE )
Shutdown();
m_residenceCurrent = m_residenceTarget = RESIDENT_NONE;
// Clear our the streamable fine flag to ensure we reload properly.
m_nFlags &= ~TEXTUREFLAGS_STREAMABLE_FINE;
}
void CTexture::MakePartiallyResident()
{
TM_ZONE_DEFAULT( TELEMETRY_LEVEL0 );
ResidencyType_t oldCurrentResidence = m_residenceCurrent;
ResidencyType_t oldTargetResidence = m_residenceTarget;
m_residenceCurrent = m_residenceTarget = RESIDENT_PARTIAL;
if ( oldCurrentResidence == RESIDENT_PARTIAL )
{
Assert( oldTargetResidence == RESIDENT_FULL ); oldTargetResidence;
// If we are already partially resident, then just cancel our job to stream in,
// cause we don't need that data anymore.
CancelStreamingJob();
return;
}
Assert( oldCurrentResidence == RESIDENT_FULL );
// Clear the fine bit.
m_nFlags &= ~TEXTUREFLAGS_STREAMABLE_FINE;
if ( HardwareConfig()->CanStretchRectFromTextures() )
{
m_lodClamp = 0;
m_lodBiasInitial = m_lodBiasCurrent = 0;
m_lastLodBiasAdjustFrame = g_FrameNum;
DownloadTexture( NULL, true );
}
else
{
// Oops. We were overzealous above--restore the residency to what it was.
m_residenceCurrent = oldCurrentResidence;
// Immediately display it as lower res (for consistency) but if we can't (efficiently)
// copy we just have to re-read everything from disk. Lame!
m_lodClamp = 3;
m_lodBiasInitial = m_lodBiasCurrent = 0;
m_lastLodBiasAdjustFrame = g_FrameNum;
SetFilteringAndClampingMode( true );
SafeAssign( &m_pStreamingJob, new CTextureStreamingJob( this ) );
MaterialSystem()->AsyncFindTexture( GetName(), GetTextureGroupName(), m_pStreamingJob, (void*) RESIDENT_PARTIAL, false, TEXTUREFLAGS_STREAMABLE_COARSE );
}
}
bool CTexture::MakeFullyResident()
{
TM_ZONE_DEFAULT( TELEMETRY_LEVEL0 );
ResidencyType_t oldCurrentResidence = m_residenceCurrent;
ResidencyType_t oldTargetResidence = m_residenceTarget;
if ( oldCurrentResidence == RESIDENT_FULL )
{
// This isn't a requirement, but right now it would be a mistake
Assert( !HardwareConfig()->CanStretchRectFromTextures() );
Assert( oldTargetResidence == RESIDENT_PARTIAL ); oldTargetResidence;
m_residenceCurrent = m_residenceTarget = RESIDENT_FULL;
m_lodClamp = 0;
m_lodBiasInitial = m_lodBiasCurrent = 0;
m_lastLodBiasAdjustFrame = g_FrameNum;
SetFilteringAndClampingMode( true );
CancelStreamingJob();
return true;
}
Assert( m_residenceTarget == RESIDENT_PARTIAL && m_residenceCurrent == RESIDENT_PARTIAL );
Assert( m_pStreamingJob == NULL );
SafeAssign( &m_pStreamingJob, new CTextureStreamingJob( this ) );
MaterialSystem()->AsyncFindTexture( GetName(), GetTextureGroupName(), m_pStreamingJob, (void*) RESIDENT_FULL, false, TEXTUREFLAGS_STREAMABLE_FINE );
m_residenceTarget = RESIDENT_FULL;
return true;
}
void CTexture::CancelStreamingJob( bool bJobMustExist )
{
bJobMustExist; // Only used by asserts ensuring correctness, so reference it for release builds.
// Most callers should be aware of whether the job exists, but for cleanup we don't know and we
// should be safe in that case.
Assert( !bJobMustExist || m_pStreamingJob );
if ( !m_pStreamingJob )
return;
// The streaming job and this (this texture) have a circular reference count--each one holds one for the other.
// As a result, this means that having the streaming job forget about the texture may cause the texture to go
// away completely! So we need to ensure that after we call "ForgetOwner" that we don't touch any instance
// variables.
CTextureStreamingJob* pJob = m_pStreamingJob;
m_pStreamingJob = NULL;
pJob->ForgetOwner( this );
SafeRelease( &pJob );
}
void CTexture::OnStreamingJobComplete( ResidencyType_t newResidenceCurrent )
{
Assert( m_pStreamingJob );
// It's probable that if this assert fires, we should just do nothing in here and return--but I'd
// like to see that happen to be sure.
Assert( newResidenceCurrent == m_residenceTarget );
m_residenceCurrent = newResidenceCurrent;
// Only do lod biasing for stream in. For stream out, just dump to lowest quality right away.
if ( m_residenceCurrent == RESIDENT_FULL )
{
if ( mat_lodin_time.GetFloat() > 0 )
{
m_lodBiasCurrent = m_lodBiasInitial = 1.0 * m_nStreamingMips;
m_lodBiasStartTime = Plat_FloatTime();
}
else
m_lodBiasCurrent = m_lodBiasInitial = 0.0f;
m_lastLodBiasAdjustFrame = g_FrameNum;
}
m_lodClamp = 0;
m_nStreamingMips = 0;
SetFilteringAndClampingMode( true );
// The job is complete, Cancel handles cleanup correctly.
CancelStreamingJob();
}
void CTexture::SetErrorTexture( bool bIsErrorTexture )
{
if ( bIsErrorTexture )
m_nInternalFlags |= TEXTUREFLAGSINTERNAL_ERROR;
else
m_nInternalFlags &= ( ~TEXTUREFLAGSINTERNAL_ERROR );
}
//-----------------------------------------------------------------------------
// Creates named render target texture
//-----------------------------------------------------------------------------
void CTexture::InitRenderTarget(
const char *pRTName,
int w,
int h,
RenderTargetSizeMode_t sizeMode,
ImageFormat fmt,
RenderTargetType_t type,
unsigned int textureFlags,
unsigned int renderTargetFlags )
{
if ( pRTName )
{
SetName( pRTName );
}
else
{
static int id = 0;
char pName[128];
Q_snprintf( pName, sizeof( pName ), "__render_target_%d", id );
++id;
SetName( pName );
}
if ( renderTargetFlags & CREATERENDERTARGETFLAGS_HDR )
{
if ( HardwareConfig()->GetHDRType() == HDR_TYPE_FLOAT )
{
// slam the format
fmt = IMAGE_FORMAT_RGBA16161616F;
}
}
int nFrameCount = 1;
int nFlags = TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_RENDERTARGET;
nFlags |= textureFlags;
if ( type == RENDER_TARGET_NO_DEPTH )
{
nFlags |= TEXTUREFLAGS_NODEPTHBUFFER;
}
else if ( type == RENDER_TARGET_WITH_DEPTH || type == RENDER_TARGET_ONLY_DEPTH || g_pShaderAPI->DoRenderTargetsNeedSeparateDepthBuffer() )
{
nFlags |= TEXTUREFLAGS_DEPTHRENDERTARGET;
++nFrameCount;
}
if ( renderTargetFlags & CREATERENDERTARGETFLAGS_TEMP )
{
m_nInternalFlags |= TEXTUREFLAGSINTERNAL_TEMPRENDERTARGET;
}
m_nOriginalRenderTargetType = type;
m_RenderTargetSizeMode = sizeMode;
m_nOriginalRTWidth = w;
m_nOriginalRTHeight = h;
if ( ImageLoader::ImageFormatInfo(fmt).m_NumAlphaBits > 1 )
{
nFlags |= TEXTUREFLAGS_EIGHTBITALPHA;
}
else if ( ImageLoader::ImageFormatInfo(fmt).m_NumAlphaBits == 1 )
{
nFlags |= TEXTUREFLAGS_ONEBITALPHA;
}
ApplyRenderTargetSizeMode( w, h, fmt );
Init( w, h, 1, fmt, nFlags, nFrameCount );
m_TextureGroupName = TEXTURE_GROUP_RENDER_TARGET;
}
void CTexture::OnRestore()
{
// May have to change whether or not we have a depth buffer.
// Are we a render target?
if ( m_nFlags & TEXTUREFLAGS_RENDERTARGET )
{
// Did they not ask for a depth buffer?
if ( m_nOriginalRenderTargetType == RENDER_TARGET )
{
// But, did we force them to have one, or should we force them to have one this time around?
bool bShouldForce = g_pShaderAPI->DoRenderTargetsNeedSeparateDepthBuffer();
bool bDidForce = ((m_nFlags & TEXTUREFLAGS_DEPTHRENDERTARGET) != 0);
if ( bShouldForce != bDidForce )
{
int nFlags = m_nFlags;
int iFrameCount = m_nFrameCount;
if ( bShouldForce )
{
Assert( !( nFlags & TEXTUREFLAGS_DEPTHRENDERTARGET ) );
iFrameCount = 2;
nFlags |= TEXTUREFLAGS_DEPTHRENDERTARGET;
}
else
{
Assert( ( nFlags & TEXTUREFLAGS_DEPTHRENDERTARGET ) );
iFrameCount = 1;
nFlags &= ~TEXTUREFLAGS_DEPTHRENDERTARGET;
}
Shutdown();
int newWidth, newHeight;
ApplyRenderTargetSizeMode( newWidth, newHeight, m_ImageFormat );
Init( newWidth, newHeight, 1, m_ImageFormat, nFlags, iFrameCount );
return;
}
}
// If we didn't recreate it up above, then we may need to resize it anyway if the framebuffer
// got smaller than we are.
int newWidth, newHeight;
ApplyRenderTargetSizeMode( newWidth, newHeight, m_ImageFormat );
if ( newWidth != m_dimsMapping.m_nWidth || newHeight != m_dimsMapping.m_nHeight )
{
Shutdown();
Init( newWidth, newHeight, 1, m_ImageFormat, m_nFlags, m_nFrameCount );
return;
}
}
else
{
if ( m_nFlags & TEXTUREFLAGS_STREAMABLE_FINE )
{
MakeResident( RESIDENT_NONE );
}
}
}
//-----------------------------------------------------------------------------
// Creates a procedural texture
//-----------------------------------------------------------------------------
void CTexture::InitProceduralTexture( const char *pTextureName, const char *pTextureGroupName, int w, int h, int d, ImageFormat fmt, int nFlags, ITextureRegenerator* generator )
{
// We shouldn't be asking for render targets here
Assert( (nFlags & (TEXTUREFLAGS_RENDERTARGET | TEXTUREFLAGS_DEPTHRENDERTARGET)) == 0 );
SetName( pTextureName );
// Eliminate flags that are inappropriate...
nFlags &= ~TEXTUREFLAGS_HINT_DXT5 | TEXTUREFLAGS_ONEBITALPHA | TEXTUREFLAGS_EIGHTBITALPHA |
TEXTUREFLAGS_RENDERTARGET | TEXTUREFLAGS_DEPTHRENDERTARGET;
// Insert required flags
nFlags |= TEXTUREFLAGS_PROCEDURAL;
int nAlphaBits = ImageLoader::ImageFormatInfo(fmt).m_NumAlphaBits;
if (nAlphaBits > 1)
{
nFlags |= TEXTUREFLAGS_EIGHTBITALPHA;
}
else if (nAlphaBits == 1)
{
nFlags |= TEXTUREFLAGS_ONEBITALPHA;
}
// Procedural textures are always one frame only
Init( w, h, d, fmt, nFlags, 1 );
SetTextureRegenerator(generator);
m_TextureGroupName = pTextureGroupName;
}
//-----------------------------------------------------------------------------
// Creates a file texture
//-----------------------------------------------------------------------------
void CTexture::InitFileTexture( const char *pTextureFile, const char *pTextureGroupName )
{
// For files, we only really know about the file name
// At any time, the file contents could change, and we could have
// a different size, number of frames, etc.
SetName( pTextureFile );
m_TextureGroupName = pTextureGroupName;
}
//-----------------------------------------------------------------------------
// Assigns/releases texture IDs for our animation frames
//-----------------------------------------------------------------------------
void CTexture::AllocateTextureHandles()
{
Assert( !m_pTextureHandles );
Assert( m_nFrameCount > 0 );
#ifdef DBGFLAG_ASSERT
if( m_nFlags & TEXTUREFLAGS_DEPTHRENDERTARGET )
{
Assert( m_nFrameCount >= 2 );
}
#endif
m_pTextureHandles = new ShaderAPITextureHandle_t[m_nFrameCount];
for( int i = 0; i != m_nFrameCount; ++i )
m_pTextureHandles[i] = INVALID_SHADERAPI_TEXTURE_HANDLE;
}
void CTexture::ReleaseTextureHandles()
{
if ( m_pTextureHandles )
{
delete[] m_pTextureHandles;
m_pTextureHandles = NULL;
}
}
//-----------------------------------------------------------------------------
// Creates the texture
//-----------------------------------------------------------------------------
bool CTexture::AllocateShaderAPITextures()
{
Assert( !HasBeenAllocated() );
TM_ZONE_DEFAULT( TELEMETRY_LEVEL0 );
int nCount = m_nFrameCount;
int nCreateFlags = 0;
if ( ( m_nFlags & TEXTUREFLAGS_ENVMAP ) && HardwareConfig()->SupportsCubeMaps() )
{
nCreateFlags |= TEXTURE_CREATE_CUBEMAP;
}
bool bIsFloat = ( m_ImageFormat == IMAGE_FORMAT_RGBA16161616F ) || ( m_ImageFormat == IMAGE_FORMAT_R32F ) ||
( m_ImageFormat == IMAGE_FORMAT_RGB323232F ) || ( m_ImageFormat == IMAGE_FORMAT_RGBA32323232F );
// Don't do sRGB on floating point textures
if ( ( m_nFlags & TEXTUREFLAGS_SRGB ) && !bIsFloat )
{
nCreateFlags |= TEXTURE_CREATE_SRGB; // for Posix/GL only
}
if ( m_nFlags & TEXTUREFLAGS_RENDERTARGET )
{
nCreateFlags |= TEXTURE_CREATE_RENDERTARGET;
// This here is simply so we can use a different call to
// create the depth texture below
if ( ( m_nFlags & TEXTUREFLAGS_DEPTHRENDERTARGET ) && ( nCount == 2 ) ) //nCount must be 2 on pc
{
--nCount;
}
}
else
{
// If it's not a render target, use the texture manager in dx
if ( m_nFlags & TEXTUREFLAGS_STAGING_MEMORY )
nCreateFlags |= TEXTURE_CREATE_SYSMEM;
else
{
#if defined(IS_WINDOWS_PC)
static ConVarRef mat_dxlevel("mat_dxlevel");
if ( mat_dxlevel.GetInt() < 90 || mat_managedtextures.GetBool() )
#endif
{
nCreateFlags |= TEXTURE_CREATE_MANAGED;
}
}
}
if ( m_nFlags & TEXTUREFLAGS_POINTSAMPLE )
{
nCreateFlags |= TEXTURE_CREATE_UNFILTERABLE_OK;
}
if ( m_nFlags & TEXTUREFLAGS_VERTEXTEXTURE )
{
nCreateFlags |= TEXTURE_CREATE_VERTEXTEXTURE;
}
int nCopies = 1;
if ( IsProcedural() )
{
// This is sort of hacky... should we store the # of copies in the VTF?
if ( !( m_nFlags & TEXTUREFLAGS_SINGLECOPY ) )
{
// FIXME: That 6 there is heuristically what I came up with what I
// need to get eyes not to stall on map alyx3. We need a better way
// of determining how many copies of the texture we should store.
nCopies = 6;
}
}
// For depth only render target: adjust texture width/height
// Currently we just leave it the same size, will update with further testing
int nShaderApiCreateTextureDepth = ( ( m_nFlags & TEXTUREFLAGS_DEPTHRENDERTARGET ) && ( m_nOriginalRenderTargetType == RENDER_TARGET_ONLY_DEPTH ) ) ? 1 : m_dimsAllocated.m_nDepth;
// Create all animated texture frames in a single call
g_pShaderAPI->CreateTextures(
m_pTextureHandles, nCount,
m_dimsAllocated.m_nWidth, m_dimsAllocated.m_nHeight, nShaderApiCreateTextureDepth, m_ImageFormat, m_dimsAllocated.m_nMipCount,
nCopies, nCreateFlags, GetName(), GetTextureGroupName() );
int accountingCount = nCount;
// Create the depth render target buffer
if ( m_nFlags & TEXTUREFLAGS_DEPTHRENDERTARGET )
{
MEM_ALLOC_CREDIT();
Assert( nCount == 1 );
char debugName[128];
Q_snprintf( debugName, ARRAYSIZE( debugName ), "%s_ZBuffer", GetName() );
Assert( m_nFrameCount >= 2 );
m_pTextureHandles[1] = g_pShaderAPI->CreateDepthTexture(
m_ImageFormat,
m_dimsAllocated.m_nWidth,
m_dimsAllocated.m_nHeight,
debugName,
( m_nOriginalRenderTargetType == RENDER_TARGET_ONLY_DEPTH ) );
accountingCount += 1;
}
STAGING_ONLY_EXEC( g_currentTextures.InsertOrReplace( this, TexInfo_t( GetName(), m_dimsAllocated.m_nWidth, m_dimsAllocated.m_nHeight, m_dimsAllocated.m_nDepth, m_dimsAllocated.m_nMipCount, accountingCount, nCopies, m_ImageFormat ) ) );
m_nInternalFlags |= TEXTUREFLAGSINTERNAL_ALLOCATED;
return true;
}
//-----------------------------------------------------------------------------
// Releases the texture's hardware memory
//-----------------------------------------------------------------------------
void CTexture::FreeShaderAPITextures()
{
if ( m_pTextureHandles && HasBeenAllocated() )
{
#ifdef STAGING_ONLY
// If this hits, there's a leak because we're not deallocating enough textures. Yikes!
Assert( g_currentTextures[ g_currentTextures.Find( this ) ].m_nFrameCount == m_nFrameCount );
// Remove ourselves from the list.
g_currentTextures.Remove( this );
#endif
// Release the frames
for ( int i = m_nFrameCount; --i >= 0; )
{
if ( g_pShaderAPI->IsTexture( m_pTextureHandles[i] ) )
{
#ifdef WIN32
Assert( _heapchk() == _HEAPOK );
#endif
g_pShaderAPI->DeleteTexture( m_pTextureHandles[i] );
m_pTextureHandles[i] = INVALID_SHADERAPI_TEXTURE_HANDLE;
}
}
}
m_nInternalFlags &= ~TEXTUREFLAGSINTERNAL_ALLOCATED;
// Clear texture streaming stuff, too.
if ( ( m_nFlags & TEXTUREFLAGS_STREAMABLE ) != 0 )
{
m_nFlags &= ~TEXTUREFLAGS_STREAMABLE_FINE;
m_residenceCurrent = m_residenceTarget = RESIDENT_NONE;
m_lodClamp = 0;
m_lodBiasCurrent = m_lodBiasInitial = 0;
m_lodBiasStartTime = 0;
}
}
void CTexture::MigrateShaderAPITextures()
{
TM_ZONE_DEFAULT( TELEMETRY_LEVEL0 );
const int cBytes = m_nFrameCount * sizeof ( ShaderAPITextureHandle_t );
ShaderAPITextureHandle_t *pTextureHandles = ( ShaderAPITextureHandle_t * ) stackalloc( cBytes );
Assert( pTextureHandles );
if ( !pTextureHandles )
return;
V_memcpy( pTextureHandles, m_pTextureHandles, cBytes );
// Pretend we haven't been allocated yet.
m_nInternalFlags &= ~TEXTUREFLAGSINTERNAL_ALLOCATED;
AllocateShaderAPITextures();
for ( int i = 0; i < m_nFrameCount; ++i )
{
Assert( g_pShaderAPI->IsTexture( pTextureHandles[ i ] ) == g_pShaderAPI->IsTexture( m_pTextureHandles[ i ] ) );
if ( !g_pShaderAPI->IsTexture( pTextureHandles[ i ] ) )
continue;
g_pShaderAPI->CopyTextureToTexture( pTextureHandles[ i ], m_pTextureHandles[ i ] );
}
for ( int i = 0; i < m_nFrameCount; ++i )
{
if ( !g_pShaderAPI->IsTexture( pTextureHandles[ i ] ) )
continue;
g_pShaderAPI->DeleteTexture( pTextureHandles[ i ] );
}
}
//-----------------------------------------------------------------------------
// Computes the actual format of the texture
//-----------------------------------------------------------------------------
ImageFormat CTexture::ComputeActualFormat( ImageFormat srcFormat )
{
ImageFormat dstFormat;
bool bIsCompressed = ImageLoader::IsCompressed( srcFormat );
if ( g_config.bCompressedTextures && HardwareConfig()->SupportsCompressedTextures() && bIsCompressed )
{
// for the runtime compressed formats the srcFormat won't equal the dstFormat, and we need to return srcFormat here
if ( ImageLoader::IsRuntimeCompressed( srcFormat ) )
{
return srcFormat;
}
// don't do anything since we are already in a compressed format.
dstFormat = g_pShaderAPI->GetNearestSupportedFormat( srcFormat );
Assert( dstFormat == srcFormat );
return dstFormat;
}
// NOTE: Below this piece of code is only called when compressed textures are
// turned off, or if the source texture is not compressed.
#ifdef DX_TO_GL_ABSTRACTION
if ( ( srcFormat == IMAGE_FORMAT_UVWQ8888 ) || ( srcFormat == IMAGE_FORMAT_UV88 ) || ( srcFormat == IMAGE_FORMAT_UVLX8888 ) )
{
// Danger, this is going to blow up on the Mac. You better know what you're
// doing with these exotic formats...which were introduced in 1999
Assert( 0 );
}
#endif
// We use the TEXTUREFLAGS_EIGHTBITALPHA and TEXTUREFLAGS_ONEBITALPHA flags
// to decide how many bits of alpha we need; vtex checks the alpha channel
// for all white, etc.
if( ( srcFormat == IMAGE_FORMAT_UVWQ8888 ) || ( srcFormat == IMAGE_FORMAT_UV88 ) ||
( srcFormat == IMAGE_FORMAT_UVLX8888 ) || ( srcFormat == IMAGE_FORMAT_RGBA16161616 ) ||
( srcFormat == IMAGE_FORMAT_RGBA16161616F ) )
{
#ifdef DX_TO_GL_ABSTRACTION
dstFormat = g_pShaderAPI->GetNearestSupportedFormat( srcFormat, false ); // Stupid HACK!
#else
dstFormat = g_pShaderAPI->GetNearestSupportedFormat( srcFormat, true ); // Stupid HACK!
#endif
}
else if ( m_nFlags & ( TEXTUREFLAGS_EIGHTBITALPHA | TEXTUREFLAGS_ONEBITALPHA ) )
{
dstFormat = g_pShaderAPI->GetNearestSupportedFormat( IMAGE_FORMAT_BGRA8888 );
}
else if ( srcFormat == IMAGE_FORMAT_I8 )
{
dstFormat = g_pShaderAPI->GetNearestSupportedFormat( IMAGE_FORMAT_I8 );
}
else
{
dstFormat = g_pShaderAPI->GetNearestSupportedFormat( IMAGE_FORMAT_BGR888 );
}
return dstFormat;
}
//-----------------------------------------------------------------------------
// Calculates info about whether we can make the texture smaller and by how much
//-----------------------------------------------------------------------------
int CTexture::ComputeActualSize( bool bIgnorePicmip, IVTFTexture *pVTFTexture, bool bTextureMigration )
{
unsigned int stripFlags = 0;
return ComputeMipSkipCount( GetName(), m_dimsMapping, bIgnorePicmip, pVTFTexture, m_nFlags, m_nDesiredDimensionLimit, &m_nStreamingMips, &m_cachedFileLodSettings, &m_dimsActual, &m_dimsAllocated, &stripFlags );
Assert( stripFlags == 0 ); // Not necessarily illegal, just needs investigating.
}
//-----------------------------------------------------------------------------
// Used to modify the texture bits (procedural textures only)
//-----------------------------------------------------------------------------
void CTexture::SetTextureRegenerator( ITextureRegenerator *pTextureRegen )
{
// NOTE: These can only be used by procedural textures
Assert( IsProcedural() );
if (m_pTextureRegenerator)
{
m_pTextureRegenerator->Release();
}
m_pTextureRegenerator = pTextureRegen;
}
//-----------------------------------------------------------------------------
// Gets us modifying a particular frame of our texture
//-----------------------------------------------------------------------------
void CTexture::Modify( int iFrame )
{
Assert( iFrame >= 0 && iFrame < m_nFrameCount );
Assert( HasBeenAllocated() );
g_pShaderAPI->ModifyTexture( m_pTextureHandles[iFrame] );
}
//-----------------------------------------------------------------------------
// Sets the texture clamping state on the currently modified frame
//-----------------------------------------------------------------------------
void CTexture::SetWrapState( )
{
// Border clamp applies to all texture coordinates
if ( m_nFlags & TEXTUREFLAGS_BORDER )
{
g_pShaderAPI->TexWrap( SHADER_TEXCOORD_S, SHADER_TEXWRAPMODE_BORDER );
g_pShaderAPI->TexWrap( SHADER_TEXCOORD_T, SHADER_TEXWRAPMODE_BORDER );
g_pShaderAPI->TexWrap( SHADER_TEXCOORD_U, SHADER_TEXWRAPMODE_BORDER );
return;
}
// Clamp mode in S
if ( m_nFlags & TEXTUREFLAGS_CLAMPS )
{
g_pShaderAPI->TexWrap( SHADER_TEXCOORD_S, SHADER_TEXWRAPMODE_CLAMP );
}
else
{
g_pShaderAPI->TexWrap( SHADER_TEXCOORD_S, SHADER_TEXWRAPMODE_REPEAT );
}
// Clamp mode in T
if ( m_nFlags & TEXTUREFLAGS_CLAMPT )
{
g_pShaderAPI->TexWrap( SHADER_TEXCOORD_T, SHADER_TEXWRAPMODE_CLAMP );
}
else
{
g_pShaderAPI->TexWrap( SHADER_TEXCOORD_T, SHADER_TEXWRAPMODE_REPEAT );
}
// Clamp mode in U
if ( m_nFlags & TEXTUREFLAGS_CLAMPU )
{
g_pShaderAPI->TexWrap( SHADER_TEXCOORD_U, SHADER_TEXWRAPMODE_CLAMP );
}
else
{
g_pShaderAPI->TexWrap( SHADER_TEXCOORD_U, SHADER_TEXWRAPMODE_REPEAT );
}
}
//-----------------------------------------------------------------------------
// Sets the texture filtering state on the currently modified frame
//-----------------------------------------------------------------------------
void CTexture::SetFilterState()
{
// Turns off filtering when we're point sampling
if( m_nFlags & TEXTUREFLAGS_POINTSAMPLE )
{
g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_NEAREST );
g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_NEAREST );
return;
}
// NOTE: config.bMipMapTextures and config.bFilterTextures is handled in ShaderAPIDX8
bool bEnableMipmapping = ( m_nFlags & TEXTUREFLAGS_NOMIP ) ? false : true;
if( !bEnableMipmapping )
{
g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_LINEAR );
g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_LINEAR );
return;
}
// Determing the filtering mode
bool bIsAnisotropic = false, bIsTrilinear = false;
if ( HardwareConfig()->GetDXSupportLevel() >= 80 && (g_config.m_nForceAnisotropicLevel > 1) &&
(HardwareConfig()->MaximumAnisotropicLevel() > 1) )
{
bIsAnisotropic = true;
}
else if ( g_config.ForceTrilinear() )
{
bIsAnisotropic = (( m_nFlags & TEXTUREFLAGS_ANISOTROPIC ) != 0) && (HardwareConfig()->MaximumAnisotropicLevel() > 1);
bIsTrilinear = true;
}
else
{
bIsAnisotropic = (( m_nFlags & TEXTUREFLAGS_ANISOTROPIC ) != 0) && (HardwareConfig()->MaximumAnisotropicLevel() > 1);
bIsTrilinear = ( m_nFlags & TEXTUREFLAGS_TRILINEAR ) != 0;
}
if ( bIsAnisotropic )
{
g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_ANISOTROPIC );
g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_ANISOTROPIC );
}
else
{
// force trilinear if we are on a dx8 card or above
if ( bIsTrilinear )
{
g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_LINEAR_MIPMAP_LINEAR );
g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_LINEAR );
}
else
{
g_pShaderAPI->TexMinFilter( SHADER_TEXFILTERMODE_LINEAR_MIPMAP_NEAREST );
g_pShaderAPI->TexMagFilter( SHADER_TEXFILTERMODE_LINEAR );
}
}
SetLodState();
}
//-----------------------------------------------------------------------------
// Sets the lod state on the currently modified frame
//-----------------------------------------------------------------------------
void CTexture::SetLodState()
{
// Set the lod clamping value to ensure we don't see anything we're not supposed to.
g_pShaderAPI->TexLodClamp( m_lodClamp );
g_pShaderAPI->TexLodBias( m_lodBiasCurrent );
}
//-----------------------------------------------------------------------------
// Download bits main entry point!!
//-----------------------------------------------------------------------------
void CTexture::DownloadTexture( Rect_t *pRect, bool bCopyFromCurrent )
{
// No downloading necessary if there's no graphics
if ( !g_pShaderDevice->IsUsingGraphics() )
return;
// We don't know the actual size of the texture at this stage...
if ( !pRect )
{
ReconstructTexture( bCopyFromCurrent );
}
else
{
// Not implemented yet.
Assert( bCopyFromCurrent == false );
ReconstructPartialTexture( pRect );
}
// Iterate over all the frames and set the appropriate wrapping + filtering state
SetFilteringAndClampingMode();
// texture bits have been updated, update the exclusion state
if ( m_nInternalFlags & TEXTUREFLAGSINTERNAL_SHOULDEXCLUDE )
{
m_nInternalFlags |= TEXTUREFLAGSINTERNAL_EXCLUDED;
}
else
{
m_nInternalFlags &= ~TEXTUREFLAGSINTERNAL_EXCLUDED;
}
// texture bits have been picmipped, update the picmip state
m_nActualDimensionLimit = m_nDesiredDimensionLimit;
}
void CTexture::Download( Rect_t *pRect, int nAdditionalCreationFlags /* = 0 */ )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
// Only download the bits if we can...
if ( g_pShaderAPI->CanDownloadTextures() )
{
MaterialLock_t hLock = MaterialSystem()->Lock();
m_nFlags |= nAdditionalCreationFlags; // Path to let stdshaders drive settings like sRGB-ness at creation time
DownloadTexture( pRect );
MaterialSystem()->Unlock( hLock );
}
}
// Save texture to a file.
bool CTexture::SaveToFile( const char *fileName )
{
bool bRet = false;
ITexture *pTexture = materials->FindTexture( "_rt_FullFrameFB1", TEXTURE_GROUP_RENDER_TARGET );
if ( !pTexture )
return bRet;
const int width = GetActualWidth();
const int height = GetActualHeight();
if ( pTexture->GetImageFormat() == IMAGE_FORMAT_RGBA8888 ||
pTexture->GetImageFormat() == IMAGE_FORMAT_ABGR8888 ||
pTexture->GetImageFormat() == IMAGE_FORMAT_ARGB8888 ||
pTexture->GetImageFormat() == IMAGE_FORMAT_BGRA8888 ||
pTexture->GetImageFormat() == IMAGE_FORMAT_BGRX8888 )
{
bool bCleanupTexture = false;
// Need to allocate a temporarily renderable surface. Sadness.
if ( width > pTexture->GetActualWidth() || height > pTexture->GetActualHeight() )
{
materials->OverrideRenderTargetAllocation( true );
// This one bumps the ref automatically for us.
pTexture = materials->CreateNamedRenderTargetTextureEx( "_rt_savetofile", width, height, RT_SIZE_LITERAL, IMAGE_FORMAT_BGRA8888, MATERIAL_RT_DEPTH_NONE, TEXTUREFLAGS_IMMEDIATE_CLEANUP );
materials->OverrideRenderTargetAllocation( false );
if ( !pTexture || pTexture->IsError() )
{
SafeRelease( &pTexture );
Msg( "SaveToFile: texture '_rt_FullFrameFB1' failed. Ptr:%p Format:%d\n", pTexture, ( pTexture ? pTexture->GetImageFormat() : 0 ) );
return false;
}
bCleanupTexture = true;
}
Rect_t SrcRect = { 0, 0, width, height };
Rect_t DstRect = SrcRect;
if ( ( width > 0 ) && ( height > 0 ) )
{
void *pixelValue = malloc( width * height * 2 * sizeof( BGRA8888_t ) );
if( pixelValue )
{
CMatRenderContextPtr pRenderContext( MaterialSystem() );
// Set the clear color to opaque black
pRenderContext->ClearColor4ub( 0, 0, 0, 0xFF );
pRenderContext->ClearBuffers( true, true, true );
pRenderContext->PushRenderTargetAndViewport( pTexture, 0, 0, width, height );
pRenderContext->CopyTextureToRenderTargetEx( 0, this, &SrcRect, &DstRect );
pRenderContext->ReadPixels( 0, 0, width, height, ( unsigned char * )pixelValue, pTexture->GetImageFormat() );
// Slap the alpha channel at the bottom of the tga file so we don't have to deal with crappy tools that can't
// handle rgb + alpha well. This means we can just do a "mat_texture_save_fonts" concommand, and then use
// something like Beyond Compare to look at the fonts differences between various platforms, etc.
CPixelWriter pixelWriterSrc;
CPixelWriter pixelWriterDst;
pixelWriterSrc.SetPixelMemory( pTexture->GetImageFormat(), pixelValue, width * sizeof( BGRA8888_t ) );
pixelWriterDst.SetPixelMemory( pTexture->GetImageFormat(), pixelValue, width * sizeof( BGRA8888_t ) );
for (int y = 0; y < height; ++y)
{
pixelWriterSrc.Seek( 0, y );
pixelWriterDst.Seek( 0, y + height );
for (int x = 0; x < width; ++x)
{
int r, g, b, a;
pixelWriterSrc.ReadPixelNoAdvance( r, g, b, a );
pixelWriterSrc.WritePixel( a, a, a, 255 );
pixelWriterDst.WritePixel( r, g, b, 255 );
}
}
if ( TGAWriter::WriteTGAFile( fileName, width, height * 2, pTexture->GetImageFormat(), ( uint8 * )pixelValue, width * sizeof( BGRA8888_t ) ) )
{
bRet = true;
}
// restore our previous state
pRenderContext->PopRenderTargetAndViewport();
free( pixelValue );
}
}
if ( bCleanupTexture )
SafeRelease( &pTexture );
}
else
{
Msg( "SaveToFile: texture '_rt_FullFrameFB1' failed. Ptr:%p Format:%d\n", pTexture, ( pTexture ? pTexture->GetImageFormat() : 0 ) );
}
return bRet;
}
bool CTexture::AsyncReadTextureFromFile( IVTFTexture* pVTFTexture, unsigned int nAdditionalCreationFlags )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
m_bStreamingFileReadFailed = false; // Optimism!
char pCacheFileName[ MATERIAL_MAX_PATH ];
FileHandle_t fileHandle = FILESYSTEM_INVALID_HANDLE;
GetCacheFilename( pCacheFileName, MATERIAL_MAX_PATH );
if ( !GetFileHandle( &fileHandle, pCacheFileName, NULL ) )
{
m_bStreamingFileReadFailed = true;
return false;
}
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - %s", __FUNCTION__, tmDynamicString( TELEMETRY_LEVEL0, pCacheFileName ) );
// OSX hackery
int nPreserveFlags = nAdditionalCreationFlags;
if ( m_nFlags & TEXTUREFLAGS_SRGB )
nPreserveFlags |= TEXTUREFLAGS_SRGB;
uint16 dontCareStreamedMips = m_nStreamingMips;
TextureLODControlSettings_t settings = m_cachedFileLodSettings;
if ( !SLoadTextureBitsFromFile( &pVTFTexture, fileHandle, m_nFlags | nPreserveFlags, &settings, m_nDesiredDimensionLimit, &dontCareStreamedMips, GetName(), pCacheFileName, &m_dimsMapping ) )
{
g_pFullFileSystem->Close( fileHandle );
m_bStreamingFileReadFailed = true;
return false;
}
g_pFullFileSystem->Close( fileHandle );
m_pStreamingVTF = pVTFTexture;
return true;
}
void CTexture::AsyncCancelReadTexture( )
{
Assert( m_bStreamingFileReadFailed || m_pStreamingVTF != NULL );
if ( m_pStreamingVTF )
{
TextureManager()->ReleaseAsyncScratchVTF( m_pStreamingVTF );
m_pStreamingVTF = NULL;
}
}
void CTexture::Bind( Sampler_t sampler )
{
Bind( sampler, 0 );
}
//-----------------------------------------------------------------------------
// Binds a particular texture (possibly paired)
//-----------------------------------------------------------------------------
void CTexture::Bind( Sampler_t sampler1, int nFrame, Sampler_t sampler2 /* = -1 */ )
{
if ( g_pShaderDevice->IsUsingGraphics() )
{
TextureManager()->RequestAllMipmaps( this );
if ( nFrame < 0 || nFrame >= m_nFrameCount )
{
// FIXME: Use the well-known 'error' id instead of frame 0
nFrame = 0;
// Assert(0);
}
// Make sure we've actually allocated the texture handle
if ( HasBeenAllocated() )
{
g_pShaderAPI->BindTexture( sampler1, m_pTextureHandles[nFrame] );
}
else
{
ExecuteNTimes( 20, Warning( "Trying to bind texture %s, but texture handles are not valid. Binding a white texture!\n", GetName() ) );
g_pShaderAPI->BindStandardTexture( sampler1, TEXTURE_WHITE );
}
}
}
void CTexture::BindVertexTexture( VertexTextureSampler_t sampler, int nFrame )
{
if ( g_pShaderDevice->IsUsingGraphics() )
{
if ( nFrame < 0 || nFrame >= m_nFrameCount )
{
// FIXME: Use the well-known 'error' id instead of frame 0
nFrame = 0;
// Assert(0);
}
// Make sure we've actually allocated the texture
Assert( HasBeenAllocated() );
g_pShaderAPI->BindVertexTexture( sampler, m_pTextureHandles[nFrame] );
}
}
//-----------------------------------------------------------------------------
// Set this texture as a render target
//-----------------------------------------------------------------------------
bool CTexture::SetRenderTarget( int nRenderTargetID )
{
return SetRenderTarget( nRenderTargetID, NULL );
}
//-----------------------------------------------------------------------------
// Set this texture as a render target
// Optionally bind pDepthTexture as depth buffer
//-----------------------------------------------------------------------------
bool CTexture::SetRenderTarget( int nRenderTargetID, ITexture *pDepthTexture )
{
if ( ( m_nFlags & TEXTUREFLAGS_RENDERTARGET ) == 0 )
return false;
// Make sure we've actually allocated the texture handles
Assert( HasBeenAllocated() );
ShaderAPITextureHandle_t textureHandle = m_pTextureHandles[0];
ShaderAPITextureHandle_t depthTextureHandle = (uintp)SHADER_RENDERTARGET_DEPTHBUFFER;
if ( m_nFlags & TEXTUREFLAGS_DEPTHRENDERTARGET )
{
Assert( m_nFrameCount >= 2 );
depthTextureHandle = m_pTextureHandles[1];
}
else if ( m_nFlags & TEXTUREFLAGS_NODEPTHBUFFER )
{
// GR - render target without depth buffer
depthTextureHandle = (uintp)SHADER_RENDERTARGET_NONE;
}
if ( pDepthTexture)
{
depthTextureHandle = static_cast<ITextureInternal *>(pDepthTexture)->GetTextureHandle(0);
}
g_pShaderAPI->SetRenderTargetEx( nRenderTargetID, textureHandle, depthTextureHandle );
return true;
}
//-----------------------------------------------------------------------------
// Reference counting
//-----------------------------------------------------------------------------
void CTexture::IncrementReferenceCount( void )
{
++m_nRefCount;
}
void CTexture::DecrementReferenceCount( void )
{
if ( ( --m_nRefCount <= 0 ) && ( m_nFlags & TEXTUREFLAGS_IMMEDIATE_CLEANUP ) != 0 )
{
Assert( m_nRefCount == 0 );
// Just inform the texture manager, it will decide to free us at a later date.
TextureManager()->MarkUnreferencedTextureForCleanup( this );
}
}
int CTexture::GetReferenceCount( )
{
return m_nRefCount;
}
//-----------------------------------------------------------------------------
// Various accessor methods
//-----------------------------------------------------------------------------
const char* CTexture::GetName( ) const
{
return m_Name.String();
}
const char* CTexture::GetTextureGroupName( ) const
{
return m_TextureGroupName.String();
}
void CTexture::SetName( const char* pName )
{
// normalize and convert to a symbol
char szCleanName[MAX_PATH];
m_Name = NormalizeTextureName( pName, szCleanName, sizeof( szCleanName ) );
#ifdef _DEBUG
if ( m_pDebugName )
{
delete [] m_pDebugName;
}
int nLen = V_strlen( szCleanName ) + 1;
m_pDebugName = new char[nLen];
V_memcpy( m_pDebugName, szCleanName, nLen );
#endif
}
ImageFormat CTexture::GetImageFormat() const
{
return m_ImageFormat;
}
int CTexture::GetMappingWidth() const
{
return m_dimsMapping.m_nWidth;
}
int CTexture::GetMappingHeight() const
{
return m_dimsMapping.m_nHeight;
}
int CTexture::GetMappingDepth() const
{
return m_dimsMapping.m_nDepth;
}
int CTexture::GetActualWidth() const
{
return m_dimsActual.m_nWidth;
}
int CTexture::GetActualHeight() const
{
return m_dimsActual.m_nHeight;
}
int CTexture::GetActualDepth() const
{
return m_dimsActual.m_nDepth;
}
int CTexture::GetNumAnimationFrames() const
{
return m_nFrameCount;
}
void CTexture::GetReflectivity( Vector& reflectivity )
{
Precache();
VectorCopy( m_vecReflectivity, reflectivity );
}
//-----------------------------------------------------------------------------
// Little helper polling methods
//-----------------------------------------------------------------------------
bool CTexture::IsTranslucent() const
{
return ( m_nFlags & (TEXTUREFLAGS_ONEBITALPHA | TEXTUREFLAGS_EIGHTBITALPHA) ) != 0;
}
bool CTexture::IsNormalMap( void ) const
{
return ( ( m_nFlags & TEXTUREFLAGS_NORMAL ) != 0 );
}
bool CTexture::IsCubeMap( void ) const
{
return ( ( m_nFlags & TEXTUREFLAGS_ENVMAP ) != 0 );
}
bool CTexture::IsRenderTarget( void ) const
{
return ( ( m_nFlags & TEXTUREFLAGS_RENDERTARGET ) != 0 );
}
bool CTexture::IsTempRenderTarget( void ) const
{
return ( ( m_nInternalFlags & TEXTUREFLAGSINTERNAL_TEMPRENDERTARGET ) != 0 );
}
bool CTexture::IsProcedural() const
{
return ( (m_nFlags & TEXTUREFLAGS_PROCEDURAL) != 0 );
}
bool CTexture::IsMipmapped() const
{
return ( (m_nFlags & TEXTUREFLAGS_NOMIP) == 0 );
}
unsigned int CTexture::GetFlags() const
{
return m_nFlags;
}
void CTexture::ForceLODOverride( int iNumLodsOverrideUpOrDown )
{
TextureLodOverride::OverrideInfo oi( iNumLodsOverrideUpOrDown, iNumLodsOverrideUpOrDown );
TextureLodOverride::Add( GetName(), oi );
Download( NULL );
}
bool CTexture::IsError() const
{
return ( (m_nInternalFlags & TEXTUREFLAGSINTERNAL_ERROR) != 0 );
}
bool CTexture::HasBeenAllocated() const
{
return ( (m_nInternalFlags & TEXTUREFLAGSINTERNAL_ALLOCATED) != 0 );
}
bool CTexture::IsVolumeTexture() const
{
return (m_dimsMapping.m_nDepth > 1);
}
//-----------------------------------------------------------------------------
// Sets the filtering + clamping modes on the texture
//-----------------------------------------------------------------------------
void CTexture::SetFilteringAndClampingMode( bool bOnlyLodValues )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
if( !HasBeenAllocated() )
return;
for ( int iFrame = 0; iFrame < m_nFrameCount; ++iFrame )
{
Modify( iFrame ); // Indicate we're changing state with respect to a particular frame
if ( !bOnlyLodValues )
{
SetWrapState(); // Send the appropriate wrap/clamping modes to the shaderapi.
SetFilterState(); // Set the filtering mode for the texture after downloading it.
// NOTE: Apparently, the filter state cannot be set until after download
}
else
SetLodState();
}
}
//-----------------------------------------------------------------------------
// Loads up the non-fallback information about the texture
//-----------------------------------------------------------------------------
void CTexture::Precache()
{
// We only have to do something in the case of a file texture
if ( IsRenderTarget() || IsProcedural() )
return;
if ( HasBeenAllocated() )
return;
// Blow off env_cubemap too...
if ( !Q_strnicmp( m_Name.String(), "env_cubemap", 12 ))
return;
int nAdditionalFlags = 0;
if ( ( m_nFlags & TEXTUREFLAGS_STREAMABLE ) != 0 )
{
// If we were previously streamed in, make sure we still do this time around.
nAdditionalFlags = TEXTUREFLAGS_STREAMABLE_COARSE;
Assert( ( m_nFlags & TEXTUREFLAGS_STREAMABLE_FINE ) == 0 );
Assert( m_residenceCurrent == RESIDENT_NONE && m_residenceTarget == RESIDENT_NONE );
Assert( m_lodClamp == 0 );
Assert( m_lodBiasCurrent == 0 && m_lodBiasInitial == 0 );
Assert( m_lodBiasStartTime == 0 );
}
ScratchVTF scratch( this );
IVTFTexture *pVTFTexture = scratch.Get();
// The texture name doubles as the relative file name
// It's assumed to have already been set by this point
// Compute the cache name
char pCacheFileName[MATERIAL_MAX_PATH];
Q_snprintf( pCacheFileName, sizeof( pCacheFileName ), "materials/%s" TEXTURE_FNAME_EXTENSION, m_Name.String() );
int nHeaderSize = VTFFileHeaderSize( VTF_MAJOR_VERSION );
unsigned char *pMem = (unsigned char *)stackalloc( nHeaderSize );
CUtlBuffer buf( pMem, nHeaderSize );
if ( !g_pFullFileSystem->ReadFile( pCacheFileName, NULL, buf, nHeaderSize ) )
{
goto precacheFailed;
}
if ( !pVTFTexture->Unserialize( buf, true ) )
{
Warning( "Error reading material \"%s\"\n", pCacheFileName );
goto precacheFailed;
}
// NOTE: Don't set the image format in case graphics are active
VectorCopy( pVTFTexture->Reflectivity(), m_vecReflectivity );
m_dimsMapping.m_nWidth = pVTFTexture->Width();
m_dimsMapping.m_nHeight = pVTFTexture->Height();
m_dimsMapping.m_nDepth = pVTFTexture->Depth();
m_nFlags = pVTFTexture->Flags() | nAdditionalFlags;
m_nFrameCount = pVTFTexture->FrameCount();
if ( !m_pTextureHandles )
{
// NOTE: m_nFrameCount and m_pTextureHandles are strongly associated
// whenever one is modified the other must also be modified
AllocateTextureHandles();
}
return;
precacheFailed:
m_vecReflectivity.Init( 0, 0, 0 );
m_dimsMapping.m_nWidth = 32;
m_dimsMapping.m_nHeight = 32;
m_dimsMapping.m_nDepth = 1;
m_nFlags = TEXTUREFLAGS_NOMIP;
SetErrorTexture( true );
m_nFrameCount = 1;
if ( !m_pTextureHandles )
{
// NOTE: m_nFrameCount and m_pTextureHandles are strongly associated
// whenever one is modified the other must also be modified
AllocateTextureHandles();
}
}
//-----------------------------------------------------------------------------
// Loads the low-res image from the texture
//-----------------------------------------------------------------------------
void CTexture::LoadLowResTexture( IVTFTexture *pTexture )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
delete [] m_pLowResImage;
m_pLowResImage = NULL;
if ( pTexture->LowResWidth() == 0 || pTexture->LowResHeight() == 0 )
{
m_LowResImageWidth = m_LowResImageHeight = 0;
return;
}
m_LowResImageWidth = pTexture->LowResWidth();
m_LowResImageHeight = pTexture->LowResHeight();
m_pLowResImage = new unsigned char[m_LowResImageWidth * m_LowResImageHeight * 3];
#ifdef DBGFLAG_ASSERT
bool retVal =
#endif
ImageLoader::ConvertImageFormat( pTexture->LowResImageData(), pTexture->LowResFormat(),
m_pLowResImage, IMAGE_FORMAT_RGB888, m_LowResImageWidth, m_LowResImageHeight );
Assert( retVal );
}
void *CTexture::GetResourceData( uint32 eDataType, size_t *pnumBytes ) const
{
for ( DataChunk const *pDataChunk = m_arrDataChunks.Base(),
*pDataChunkEnd = pDataChunk + m_arrDataChunks.Count();
pDataChunk < pDataChunkEnd; ++pDataChunk )
{
if ( ( pDataChunk->m_eType & ~RSRCF_MASK ) == eDataType )
{
if ( ( pDataChunk->m_eType & RSRCF_HAS_NO_DATA_CHUNK ) == 0 )
{
if ( pnumBytes)
*pnumBytes = pDataChunk->m_numBytes;
return pDataChunk->m_pvData;
}
else
{
if ( pnumBytes )
*pnumBytes = sizeof( pDataChunk->m_numBytes );
return ( void *)( &pDataChunk->m_numBytes );
}
}
}
if ( pnumBytes )
pnumBytes = 0;
return NULL;
}
#pragma pack(1)
struct DXTColBlock
{
unsigned short col0;
unsigned short col1;
// no bit fields - use bytes
unsigned char row[4];
};
struct DXTAlphaBlock3BitLinear
{
unsigned char alpha0;
unsigned char alpha1;
unsigned char stuff[6];
};
#pragma pack()
static void FillCompressedTextureWithSingleColor( int red, int green, int blue, int alpha, unsigned char *pImageData,
int width, int height, int depth, ImageFormat imageFormat )
{
Assert( ( width < 4 ) || !( width % 4 ) );
Assert( ( height < 4 ) || !( height % 4 ) );
Assert( ( depth < 4 ) || !( depth % 4 ) );
if ( width < 4 && width > 0 )
{
width = 4;
}
if ( height < 4 && height > 0 )
{
height = 4;
}
if ( depth < 4 && depth > 1 )
{
depth = 4;
}
int numBlocks = ( width * height ) >> 4;
numBlocks *= depth;
DXTColBlock colorBlock;
memset( &colorBlock, 0, sizeof( colorBlock ) );
( ( BGR565_t * )&( colorBlock.col0 ) )->Set( red, green, blue );
( ( BGR565_t * )&( colorBlock.col1 ) )->Set( red, green, blue );
switch( imageFormat )
{
case IMAGE_FORMAT_DXT1:
case IMAGE_FORMAT_ATI1N: // Invalid block data, but correct memory footprint
{
int i;
for( i = 0; i < numBlocks; i++ )
{
memcpy( pImageData + i * 8, &colorBlock, sizeof( colorBlock ) );
}
}
break;
case IMAGE_FORMAT_DXT5:
case IMAGE_FORMAT_ATI2N:
{
int i;
for( i = 0; i < numBlocks; i++ )
{
// memset( pImageData + i * 16, 0, 16 );
memcpy( pImageData + i * 16 + 8, &colorBlock, sizeof( colorBlock ) );
// memset( pImageData + i * 16 + 8, 0xffff, 8 ); // alpha block
}
}
break;
default:
Assert( 0 );
break;
}
}
// This table starts out like the programmatic logic that used to be here,
// but then has some other colors, so that we don't see repeats.
// Also, there is no black, which seems to be an error condition on OpenGL.
// There also aren't any zeros in this table, since these colors may get
// multiplied with, say, vertex colors which are tinted, resulting in black pixels.
int sg_nMipLevelColors[14][3] = { { 64, 255, 64 }, // Green
{ 255, 64, 64 }, // Red
{ 255, 255, 64 }, // Yellow
{ 64, 64, 255 }, // Blue
{ 64, 255, 255 }, // Cyan
{ 255, 64, 255 }, // Magenta
{ 255, 255, 255 }, // White
{ 255, 150, 150 }, // Light Red
{ 255, 255, 150 }, // Light Yellow
{ 150, 150, 255 }, // Light Blue
{ 150, 255, 255 }, // Light Cyan
{ 255, 150, 255 }, // Light Magenta
{ 150, 150, 128 }, // Light Gray
{ 138, 131, 64 } };// Brown
//-----------------------------------------------------------------------------
// Generate a texture that shows the various mip levels
//-----------------------------------------------------------------------------
void CTexture::GenerateShowMipLevelsTextures( IVTFTexture *pTexture )
{
if( pTexture->FaceCount() > 1 )
return;
switch( pTexture->Format() )
{
// These are formats that we don't bother with for generating mip level textures.
case IMAGE_FORMAT_RGBA16161616F:
case IMAGE_FORMAT_R32F:
case IMAGE_FORMAT_RGB323232F:
case IMAGE_FORMAT_RGBA32323232F:
case IMAGE_FORMAT_UV88:
break;
default:
for (int iFrame = 0; iFrame < pTexture->FrameCount(); ++iFrame )
{
for (int iFace = 0; iFace < pTexture->FaceCount(); ++iFace )
{
for (int iMip = 0; iMip < pTexture->MipCount(); ++iMip )
{
int red = sg_nMipLevelColors[iMip][0];//( ( iMip + 1 ) & 2 ) ? 255 : 0;
int green = sg_nMipLevelColors[iMip][1];//( ( iMip + 1 ) & 1 ) ? 255 : 0;
int blue = sg_nMipLevelColors[iMip][2];//( ( iMip + 1 ) & 4 ) ? 255 : 0;
int nWidth, nHeight, nDepth;
pTexture->ComputeMipLevelDimensions( iMip, &nWidth, &nHeight, &nDepth );
if( pTexture->Format() == IMAGE_FORMAT_DXT1 || pTexture->Format() == IMAGE_FORMAT_DXT5 ||
pTexture->Format() == IMAGE_FORMAT_ATI1N || pTexture->Format() == IMAGE_FORMAT_ATI2N )
{
unsigned char *pImageData = pTexture->ImageData( iFrame, iFace, iMip, 0, 0, 0 );
int alpha = 255;
FillCompressedTextureWithSingleColor( red, green, blue, alpha, pImageData, nWidth, nHeight, nDepth, pTexture->Format() );
}
else
{
for ( int z = 0; z < nDepth; ++z )
{
CPixelWriter pixelWriter;
pixelWriter.SetPixelMemory( pTexture->Format(),
pTexture->ImageData( iFrame, iFace, iMip, 0, 0, z ), pTexture->RowSizeInBytes( iMip ) );
for (int y = 0; y < nHeight; ++y)
{
pixelWriter.Seek( 0, y );
for (int x = 0; x < nWidth; ++x)
{
pixelWriter.WritePixel( red, green, blue, 255 );
}
}
}
}
}
}
}
break;
}
}
//-----------------------------------------------------------------------------
// Generate a texture that shows the various mip levels
//-----------------------------------------------------------------------------
void CTexture::CopyLowResImageToTexture( IVTFTexture *pTexture )
{
int nFlags = pTexture->Flags();
nFlags |= TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_POINTSAMPLE;
nFlags &= ~(TEXTUREFLAGS_TRILINEAR | TEXTUREFLAGS_ANISOTROPIC | TEXTUREFLAGS_HINT_DXT5);
nFlags &= ~(TEXTUREFLAGS_NORMAL | TEXTUREFLAGS_ENVMAP);
nFlags &= ~(TEXTUREFLAGS_ONEBITALPHA | TEXTUREFLAGS_EIGHTBITALPHA);
Assert( pTexture->FrameCount() == 1 );
Init( pTexture->Width(), pTexture->Height(), 1, IMAGE_FORMAT_BGR888, nFlags, 1 );
pTexture->Init( m_LowResImageWidth, m_LowResImageHeight, 1, IMAGE_FORMAT_BGR888, nFlags, 1 );
// Don't bother computing the actual size; it's actually equal to the low-res size
// With only one mip level
m_dimsActual.m_nWidth = m_LowResImageWidth;
m_dimsActual.m_nHeight = m_LowResImageHeight;
m_dimsActual.m_nDepth = 1;
m_dimsActual.m_nMipCount = 1;
// Copy the row-res image into the VTF Texture
CPixelWriter pixelWriter;
pixelWriter.SetPixelMemory( pTexture->Format(),
pTexture->ImageData( 0, 0, 0 ), pTexture->RowSizeInBytes( 0 ) );
for ( int y = 0; y < m_LowResImageHeight; ++y )
{
pixelWriter.Seek( 0, y );
for ( int x = 0; x < m_LowResImageWidth; ++x )
{
int red = m_pLowResImage[0];
int green = m_pLowResImage[1];
int blue = m_pLowResImage[2];
m_pLowResImage += 3;
pixelWriter.WritePixel( red, green, blue, 255 );
}
}
}
//-----------------------------------------------------------------------------
// Sets up debugging texture bits, if appropriate
//-----------------------------------------------------------------------------
bool CTexture::SetupDebuggingTextures( IVTFTexture *pVTFTexture )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
if ( pVTFTexture->Flags() & TEXTUREFLAGS_NODEBUGOVERRIDE )
return false;
// The all mips flag is typically used on detail textures, which can
// really mess up visualization if we apply the debug-colorized
// versions of them to debug-colorized base textures, so skip 'em
if ( g_config.nShowMipLevels && !(pVTFTexture->Flags() & TEXTUREFLAGS_ALL_MIPS) )
{
// mat_showmiplevels 1 means don't do normal maps
if ( ( g_config.nShowMipLevels == 1 ) && ( pVTFTexture->Flags() & ( TEXTUREFLAGS_NORMAL | TEXTUREFLAGS_SSBUMP ) ) )
return false;
// mat_showmiplevels 2 means don't do base textures
if ( ( g_config.nShowMipLevels == 2 ) && !( pVTFTexture->Flags() & ( TEXTUREFLAGS_NORMAL | TEXTUREFLAGS_SSBUMP ) ) )
return false;
// This mode shows the mip levels as different colors
GenerateShowMipLevelsTextures( pVTFTexture );
return true;
}
else if ( g_config.bShowLowResImage && pVTFTexture->FrameCount() == 1 &&
pVTFTexture->FaceCount() == 1 && ((pVTFTexture->Flags() & TEXTUREFLAGS_NORMAL) == 0) &&
m_LowResImageWidth != 0 && m_LowResImageHeight != 0 )
{
// This mode just uses the low res texture
CopyLowResImageToTexture( pVTFTexture );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Converts the texture to the actual format
// Returns true if conversion applied, false otherwise
//-----------------------------------------------------------------------------
bool CTexture::ConvertToActualFormat( IVTFTexture *pVTFTexture )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
if ( !g_pShaderDevice->IsUsingGraphics() )
return false;
bool bConverted = false;
ImageFormat fmt = m_ImageFormat;
ImageFormat dstFormat = ComputeActualFormat( pVTFTexture->Format() );
if ( fmt != dstFormat )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - conversion from (%d to %d)", __FUNCTION__, fmt, dstFormat );
pVTFTexture->ConvertImageFormat( dstFormat, false );
m_ImageFormat = dstFormat;
bConverted = true;
}
else if ( HardwareConfig()->GetHDRType() == HDR_TYPE_INTEGER &&
fmt == dstFormat && dstFormat == IMAGE_FORMAT_RGBA16161616F )
{
// This is to force at most the precision of int16 for fp16 texture when running the integer path.
pVTFTexture->ConvertImageFormat( IMAGE_FORMAT_RGBA16161616, false );
pVTFTexture->ConvertImageFormat( IMAGE_FORMAT_RGBA16161616F, false );
bConverted = true;
}
return bConverted;
}
void CTexture::GetFilename( char *pOut, int maxLen ) const
{
const char *pName = m_Name.String();
bool bIsUNCName = ( pName[0] == '/' && pName[1] == '/' && pName[2] != '/' );
if ( !bIsUNCName )
{
Q_snprintf( pOut, maxLen,
"materials/%s" TEXTURE_FNAME_EXTENSION, pName );
}
else
{
Q_snprintf( pOut, maxLen, "%s" TEXTURE_FNAME_EXTENSION, pName );
}
}
void CTexture::ReloadFilesInList( IFileList *pFilesToReload )
{
if ( IsProcedural() || IsRenderTarget() )
return;
char filename[MAX_PATH];
GetFilename( filename, sizeof( filename ) );
if ( pFilesToReload->IsFileInList( filename ) )
{
Download();
}
}
//-----------------------------------------------------------------------------
// Loads the texture bits from a file.
//-----------------------------------------------------------------------------
IVTFTexture *CTexture::LoadTextureBitsFromFile( char *pCacheFileName, char **ppResolvedFilename )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s %s", __FUNCTION__, tmDynamicString( TELEMETRY_LEVEL0, pCacheFileName ) );
if ( m_bStreamingFileReadFailed )
{
Assert( m_pStreamingVTF == NULL );
return HandleFileLoadFailedTexture( GetScratchVTFTexture() );
}
// OSX hackery
int nPreserveFlags = 0;
if ( m_nFlags & TEXTUREFLAGS_SRGB )
nPreserveFlags |= TEXTUREFLAGS_SRGB;
unsigned int stripFlags = 0;
IVTFTexture *pVTFTexture = m_pStreamingVTF;
if ( !pVTFTexture )
{
pVTFTexture = GetScratchVTFTexture();
FileHandle_t fileHandle = FILESYSTEM_INVALID_HANDLE;
if ( !GetFileHandle( &fileHandle, pCacheFileName, ppResolvedFilename ) )
return HandleFileLoadFailedTexture( pVTFTexture );
TextureLODControlSettings_t settings = m_cachedFileLodSettings;
if ( !SLoadTextureBitsFromFile( &pVTFTexture, fileHandle, m_nFlags | nPreserveFlags, &settings, m_nDesiredDimensionLimit, &m_nStreamingMips, GetName(), pCacheFileName, &m_dimsMapping, &m_dimsActual, &m_dimsAllocated, &stripFlags ) )
{
g_pFullFileSystem->Close( fileHandle );
return HandleFileLoadFailedTexture( pVTFTexture );
}
g_pFullFileSystem->Close( fileHandle );
}
// Don't reinitialize here if we're streaming in the fine levels, we already have been initialized with coarse.
if ( ( m_nFlags & TEXTUREFLAGS_STREAMABLE_FINE ) == 0 )
{
// Initing resets these, but we're happy with the values now--so store and restore them around the Init call.
TexDimensions_t actual = m_dimsActual,
allocated = m_dimsAllocated;
// Initialize the texture class with vtf header data before operations
Init( m_dimsMapping.m_nWidth,
m_dimsMapping.m_nHeight,
m_dimsMapping.m_nDepth,
pVTFTexture->Format(),
pVTFTexture->Flags() | nPreserveFlags,
pVTFTexture->FrameCount()
);
m_dimsActual = actual;
m_dimsAllocated = allocated;
m_nFlags &= ~stripFlags;
}
else
{
// Not illegal, just needs investigation.
Assert( stripFlags == 0 );
}
if ( m_pStreamingVTF )
ComputeActualSize( false, pVTFTexture, ( m_nFlags & TEXTUREFLAGS_STREAMABLE ) != 0 );
VectorCopy( pVTFTexture->Reflectivity(), m_vecReflectivity );
// If we've only streamed in coarse but haven't started on fine yet, go ahead and mark us as
// partially resident and set up our clamping values.
if ( ( m_nFlags & TEXTUREFLAGS_STREAMABLE ) == TEXTUREFLAGS_STREAMABLE_COARSE )
{
pVTFTexture->GetMipmapRange( &m_lodClamp, NULL );
m_residenceTarget = RESIDENT_PARTIAL;
m_residenceCurrent = RESIDENT_PARTIAL;
}
// Build the low-res texture
LoadLowResTexture( pVTFTexture );
// Load the resources
if ( unsigned int uiRsrcCount = pVTFTexture->GetResourceTypes( NULL, 0 ) )
{
uint32 *arrRsrcTypes = ( uint32 * )_alloca( uiRsrcCount * sizeof( unsigned int ) );
pVTFTexture->GetResourceTypes( arrRsrcTypes, uiRsrcCount );
m_arrDataChunks.EnsureCapacity( uiRsrcCount );
for ( uint32 *arrRsrcTypesEnd = arrRsrcTypes + uiRsrcCount;
arrRsrcTypes < arrRsrcTypesEnd; ++arrRsrcTypes )
{
switch ( *arrRsrcTypes )
{
case VTF_LEGACY_RSRC_LOW_RES_IMAGE:
case VTF_LEGACY_RSRC_IMAGE:
// These stock types use specific load routines
continue;
default:
{
DataChunk dc;
dc.m_eType = *arrRsrcTypes;
dc.m_eType &= ~RSRCF_MASK;
size_t numBytes;
if ( void *pvData = pVTFTexture->GetResourceData( dc.m_eType, &numBytes ) )
{
Assert( numBytes >= sizeof( uint32 ) );
if ( numBytes == sizeof( dc.m_numBytes ) )
{
dc.m_eType |= RSRCF_HAS_NO_DATA_CHUNK;
dc.m_pvData = NULL;
memcpy( &dc.m_numBytes, pvData, numBytes );
}
else
{
dc.Allocate( numBytes );
memcpy( dc.m_pvData, pvData, numBytes );
}
m_arrDataChunks.AddToTail( dc );
}
}
}
}
}
// Try to set up debugging textures, if we're in a debugging mode
if ( !IsProcedural() )
SetupDebuggingTextures( pVTFTexture );
if ( ConvertToActualFormat( pVTFTexture ) )
pVTFTexture; // STAGING_ONLY_EXEC ( Warning( "\"%s\" not in final format, this is causing stutters or load time bloat!\n", pCacheFileName ) );
return pVTFTexture;
}
IVTFTexture *CTexture::HandleFileLoadFailedTexture( IVTFTexture *pVTFTexture )
{
// create the error texture
// This will make a checkerboard texture to indicate failure
pVTFTexture->Init( 32, 32, 1, IMAGE_FORMAT_BGRA8888, m_nFlags, 1 );
Init( pVTFTexture->Width(), pVTFTexture->Height(), pVTFTexture->Depth(), pVTFTexture->Format(),
pVTFTexture->Flags(), pVTFTexture->FrameCount() );
m_vecReflectivity.Init( 0.5f, 0.5f, 0.5f );
// NOTE: For mat_picmip to work, we must use the same size (32x32)
// Which should work since every card can handle textures of that size
m_dimsAllocated.m_nWidth = m_dimsActual.m_nWidth = pVTFTexture->Width();
m_dimsAllocated.m_nHeight = m_dimsActual.m_nHeight = pVTFTexture->Height();
m_dimsAllocated.m_nDepth = 1;
m_dimsAllocated.m_nMipCount = m_dimsActual.m_nMipCount = 1;
m_nStreamingMips = 0;
// generate the checkerboard
TextureManager()->GenerateErrorTexture( this, pVTFTexture );
ConvertToActualFormat( pVTFTexture );
// Deactivate procedural texture...
m_nFlags &= ~TEXTUREFLAGS_PROCEDURAL;
SetErrorTexture( true );
return pVTFTexture;
}
//-----------------------------------------------------------------------------
// Computes subrect for a particular miplevel
//-----------------------------------------------------------------------------
void CTexture::ComputeMipLevelSubRect( const Rect_t* pSrcRect, int nMipLevel, Rect_t *pSubRect )
{
if (nMipLevel == 0)
{
*pSubRect = *pSrcRect;
return;
}
float flInvShrink = 1.0f / (float)(1 << nMipLevel);
pSubRect->x = pSrcRect->x * flInvShrink;
pSubRect->y = pSrcRect->y * flInvShrink;
pSubRect->width = (int)ceil( (pSrcRect->x + pSrcRect->width) * flInvShrink ) - pSubRect->x;
pSubRect->height = (int)ceil( (pSrcRect->y + pSrcRect->height) * flInvShrink ) - pSubRect->y;
}
//-----------------------------------------------------------------------------
// Computes the face count + first face
//-----------------------------------------------------------------------------
void CTexture::GetDownloadFaceCount( int &nFirstFace, int &nFaceCount )
{
nFaceCount = 1;
nFirstFace = 0;
if ( IsCubeMap() )
{
if ( HardwareConfig()->SupportsCubeMaps() )
{
nFaceCount = CUBEMAP_FACE_COUNT-1;
}
else
{
// This will cause us to use the spheremap instead of the cube faces
// in the case where we don't support cubemaps
nFirstFace = CUBEMAP_FACE_SPHEREMAP;
}
}
}
//-----------------------------------------------------------------------------
// Fixup a queue loaded texture with the delayed hi-res data
//-----------------------------------------------------------------------------
void CTexture::FixupTexture( const void *pData, int nSize, LoaderError_t loaderError )
{
if ( loaderError != LOADERERROR_NONE )
{
// mark as invalid
nSize = 0;
}
m_nInternalFlags &= ~TEXTUREFLAGSINTERNAL_QUEUEDLOAD;
// Make sure we've actually allocated the texture handles
Assert( HasBeenAllocated() );
}
static void QueuedLoaderCallback( void *pContext, void *pContext2, const void *pData, int nSize, LoaderError_t loaderError )
{
reinterpret_cast< CTexture * >( pContext )->FixupTexture( pData, nSize, loaderError );
}
//-----------------------------------------------------------------------------
// Generates the procedural bits
//-----------------------------------------------------------------------------
IVTFTexture *CTexture::ReconstructPartialProceduralBits( const Rect_t *pRect, Rect_t *pActualRect )
{
// Figure out the actual size for this texture based on the current mode
bool bIgnorePicmip = ( m_nFlags & ( TEXTUREFLAGS_STAGING_MEMORY | TEXTUREFLAGS_IGNORE_PICMIP ) ) != 0;
ComputeActualSize( bIgnorePicmip );
// Figure out how many mip levels we're skipping...
int nSizeFactor = 1;
int nWidth = GetActualWidth();
if ( nWidth != 0 )
{
nSizeFactor = GetMappingWidth() / nWidth;
}
int nMipSkipCount = 0;
while (nSizeFactor > 1)
{
nSizeFactor >>= 1;
++nMipSkipCount;
}
// Determine a rectangle appropriate for the actual size...
// It must bound all partially-covered pixels..
ComputeMipLevelSubRect( pRect, nMipSkipCount, pActualRect );
// Create the texture
IVTFTexture *pVTFTexture = GetScratchVTFTexture();
// Initialize the texture
pVTFTexture->Init( m_dimsActual.m_nWidth, m_dimsActual.m_nHeight, m_dimsActual.m_nDepth,
ComputeActualFormat( m_ImageFormat ), m_nFlags, m_nFrameCount );
// Generate the bits from the installed procedural regenerator
if ( m_pTextureRegenerator )
{
m_pTextureRegenerator->RegenerateTextureBits( this, pVTFTexture, pActualRect );
}
else
{
// In this case, we don't have one, so just use a checkerboard...
TextureManager()->GenerateErrorTexture( this, pVTFTexture );
}
return pVTFTexture;
}
//-----------------------------------------------------------------------------
// Regenerates the bits of a texture within a particular rectangle
//-----------------------------------------------------------------------------
void CTexture::ReconstructPartialTexture( const Rect_t *pRect )
{
// FIXME: for now, only procedural textures can handle sub-rect specification.
Assert( IsProcedural() );
// Also, we need procedural textures that have only a single copy!!
// Otherwise this partial upload will not occur on all copies
Assert( m_nFlags & TEXTUREFLAGS_SINGLECOPY );
Rect_t vtfRect;
IVTFTexture *pVTFTexture = ReconstructPartialProceduralBits( pRect, &vtfRect );
// FIXME: for now, depth textures do not work with this.
Assert( pVTFTexture->Depth() == 1 );
// Make sure we've allocated the API textures
if ( !HasBeenAllocated() )
{
if ( !AllocateShaderAPITextures() )
return;
}
int nFaceCount, nFirstFace;
GetDownloadFaceCount( nFirstFace, nFaceCount );
// Blit down portions of the various VTF frames into the board memory
int nStride;
Rect_t mipRect;
for ( int iFrame = 0; iFrame < m_nFrameCount; ++iFrame )
{
Modify( iFrame );
for ( int iFace = 0; iFace < nFaceCount; ++iFace )
{
for ( int iMip = 0; iMip < m_dimsActual.m_nMipCount; ++iMip )
{
pVTFTexture->ComputeMipLevelSubRect( &vtfRect, iMip, &mipRect );
nStride = pVTFTexture->RowSizeInBytes( iMip );
unsigned char *pBits = pVTFTexture->ImageData( iFrame, iFace + nFirstFace, iMip, mipRect.x, mipRect.y, 0 );
g_pShaderAPI->TexSubImage2D(
iMip,
iFace,
mipRect.x,
mipRect.y,
0,
mipRect.width,
mipRect.height,
pVTFTexture->Format(),
nStride,
false,
pBits );
}
}
}
}
//-----------------------------------------------------------------------------
// Generates the procedural bits
//-----------------------------------------------------------------------------
IVTFTexture *CTexture::ReconstructProceduralBits()
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
// Figure out the actual size for this texture based on the current mode
bool bIgnorePicmip = ( m_nFlags & ( TEXTUREFLAGS_STAGING_MEMORY | TEXTUREFLAGS_IGNORE_PICMIP ) ) != 0;
ComputeActualSize( bIgnorePicmip );
// Create the texture
IVTFTexture *pVTFTexture = NULL;
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - GetScratchVTFTexture", __FUNCTION__ );
pVTFTexture = GetScratchVTFTexture();
}
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - Init", __FUNCTION__ );
// Initialize the texture
pVTFTexture->Init( m_dimsActual.m_nWidth, m_dimsActual.m_nHeight, m_dimsActual.m_nDepth,
ComputeActualFormat( m_ImageFormat ), m_nFlags, m_nFrameCount );
}
// Generate the bits from the installed procedural regenerator
if ( m_pTextureRegenerator )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - RegenerateTextureBits", __FUNCTION__ );
Rect_t rect;
rect.x = 0; rect.y = 0;
rect.width = m_dimsActual.m_nWidth;
rect.height = m_dimsActual.m_nHeight;
m_pTextureRegenerator->RegenerateTextureBits( this, pVTFTexture, &rect );
}
else
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - GenerateErrorTexture", __FUNCTION__ );
// In this case, we don't have one, so just use a checkerboard...
TextureManager()->GenerateErrorTexture( this, pVTFTexture );
}
return pVTFTexture;
}
void CTexture::WriteDataToShaderAPITexture( int nFrameCount, int nFaceCount, int nFirstFace, int nMipCount, IVTFTexture *pVTFTexture, ImageFormat fmt )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
// If we're a staging texture, there's nothing to do.
if ( ( m_nFlags & TEXTUREFLAGS_STAGING_MEMORY ) != 0 )
return;
for ( int iFrame = 0; iFrame < m_nFrameCount; ++iFrame )
{
Modify( iFrame );
g_pShaderAPI->TexImageFromVTF( pVTFTexture, iFrame );
}
}
bool CTexture::IsDepthTextureFormat( ImageFormat fmt )
{
return ( ( m_ImageFormat == IMAGE_FORMAT_NV_DST16 ) ||
( m_ImageFormat == IMAGE_FORMAT_NV_DST24 ) ||
( m_ImageFormat == IMAGE_FORMAT_NV_INTZ ) ||
( m_ImageFormat == IMAGE_FORMAT_NV_RAWZ ) ||
( m_ImageFormat == IMAGE_FORMAT_ATI_DST16 ) ||
( m_ImageFormat == IMAGE_FORMAT_ATI_DST24 ) );
}
//-----------------------------------------------------------------------------
void CTexture::NotifyUnloadedFile()
{
// Make sure we have a regular texture that was loaded from a file
if ( IsProcedural() || IsRenderTarget() || !m_Name.IsValid() )
return;
const char *pName = m_Name.String();
if ( *pName == '\0' )
return;
bool bIsUNCName = ( pName[0] == '/' && pName[1] == '/' && pName[2] != '/' );
if ( bIsUNCName )
return;
// Generate the filename
char pCacheFileName[MATERIAL_MAX_PATH];
Q_snprintf( pCacheFileName, sizeof( pCacheFileName ), "materials/%s" TEXTURE_FNAME_EXTENSION, pName );
// Let filesystem know that the file is uncached, so it knows
// what to do with tracking info
g_pFullFileSystem->NotifyFileUnloaded( pCacheFileName, "GAME" );
}
//-----------------------------------------------------------------------------
// Sets or updates the texture bits
//-----------------------------------------------------------------------------
void CTexture::ReconstructTexture( bool bCopyFromCurrent )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
Assert( !bCopyFromCurrent || HardwareConfig()->CanStretchRectFromTextures() );
int oldWidth = m_dimsAllocated.m_nWidth;
int oldHeight = m_dimsAllocated.m_nHeight;
int oldDepth = m_dimsAllocated.m_nDepth;
int oldMipCount = m_dimsAllocated.m_nMipCount;
int oldFrameCount = m_nFrameCount;
// FIXME: Should RenderTargets be a special case of Procedural?
char *pResolvedFilename = NULL;
IVTFTexture *pVTFTexture = NULL;
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - Begin", __FUNCTION__ );
if ( IsProcedural() )
{
// This will call the installed texture bit regeneration interface
pVTFTexture = ReconstructProceduralBits();
}
else if ( IsRenderTarget() )
{
// Compute the actual size + format based on the current mode
bool bIgnorePicmip = m_RenderTargetSizeMode != RT_SIZE_LITERAL_PICMIP;
ComputeActualSize( bIgnorePicmip );
}
else if ( bCopyFromCurrent )
{
ComputeActualSize( false, NULL, true );
}
else
{
NotifyUnloadedFile();
char pCacheFileName[ MATERIAL_MAX_PATH ] = { 0 };
GetCacheFilename( pCacheFileName, ARRAYSIZE( pCacheFileName ) );
// Get the data from disk...
// NOTE: Reloading the texture bits can cause the texture size, frames, format, pretty much *anything* can change.
pVTFTexture = LoadTextureBitsFromFile( pCacheFileName, &pResolvedFilename );
}
}
if ( !HasBeenAllocated() ||
m_dimsAllocated.m_nWidth != oldWidth ||
m_dimsAllocated.m_nHeight != oldHeight ||
m_dimsAllocated.m_nDepth != oldDepth ||
m_dimsAllocated.m_nMipCount != oldMipCount ||
m_nFrameCount != oldFrameCount )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - Allocation", __FUNCTION__ );
const bool cbCanStretchRectTextures = HardwareConfig()->CanStretchRectFromTextures();
const bool cbShouldMigrateTextures = ( ( m_nFlags & TEXTUREFLAGS_STREAMABLE_FINE ) != 0 ) && m_nFrameCount == oldFrameCount;
// If we're just streaming in more data--or demoting ourselves, do a migration instead.
if ( bCopyFromCurrent || ( cbCanStretchRectTextures && cbShouldMigrateTextures ) )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - Migration", __FUNCTION__ );
MigrateShaderAPITextures();
// Ahh--I feel terrible about this, but we genuinely don't need anything else if we're streaming.
if ( bCopyFromCurrent )
return;
}
else
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - Deallocate / Allocate", __FUNCTION__ );
// If we're doing a wholesale copy, we need to restore these values that will be cleared by FreeShaderAPITextures.
// Record them here, restore them below.
unsigned int restoreStreamingFlag = ( m_nFlags & TEXTUREFLAGS_STREAMABLE );
ResidencyType_t restoreResidenceCurrent = m_residenceCurrent;
ResidencyType_t restoreResidenceTarget = m_residenceTarget;
if ( HasBeenAllocated() )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - Deallocate", __FUNCTION__ );
// This is necessary for the reload case, we may discover there
// are more frames of a texture animation, for example, which means
// we can't rely on having the same number of texture frames.
FreeShaderAPITextures();
}
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - Allocate", __FUNCTION__ );
// Create the shader api textures
if ( !AllocateShaderAPITextures() )
return;
// Restored once we successfully allocate the shader api textures, but only if we're
//
if ( !cbCanStretchRectTextures && cbShouldMigrateTextures )
{
m_nFlags |= restoreStreamingFlag;
m_residenceCurrent = restoreResidenceCurrent;
m_residenceTarget = restoreResidenceTarget;
}
}
}
else if ( bCopyFromCurrent )
{
Assert( !"We're about to crash, last chance to examine this texture." );
}
// Render Targets just need to be cleared, they have no upload
if ( IsRenderTarget() )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - RT Stuff", __FUNCTION__ );
// Clear the render target to opaque black
// Only clear if we're not a depth-stencil texture
if ( !IsDepthTextureFormat( m_ImageFormat ) )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - Clearing", __FUNCTION__ );
CMatRenderContextPtr pRenderContext( MaterialSystem() );
ITexture *pThisTexture = GetEmbeddedTexture( 0 );
pRenderContext->PushRenderTargetAndViewport( pThisTexture ); // Push this texture on the stack
g_pShaderAPI->ClearColor4ub( 0, 0, 0, 0xFF ); // Set the clear color to opaque black
g_pShaderAPI->ClearBuffers( true, false, false, m_dimsActual.m_nWidth, m_dimsActual.m_nHeight ); // Clear the target
pRenderContext->PopRenderTargetAndViewport(); // Pop back to previous target
}
// no upload
return;
}
// Blit down the texture faces, frames, and mips into the board memory
int nFirstFace, nFaceCount;
GetDownloadFaceCount( nFirstFace, nFaceCount );
WriteDataToShaderAPITexture( m_nFrameCount, nFaceCount, nFirstFace, m_dimsActual.m_nMipCount, pVTFTexture, m_ImageFormat );
ReleaseScratchVTFTexture( pVTFTexture );
pVTFTexture = NULL;
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - Final Cleanup", __FUNCTION__ );
// allocated by strdup
free( pResolvedFilename );
// the pc can afford to persist a large buffer
FreeOptimalReadBuffer( 6*1024*1024 );
}
void CTexture::GetCacheFilename( char* pOutBuffer, int nBufferSize ) const
{
Assert( pOutBuffer );
if ( IsProcedural() || IsRenderTarget() )
{
pOutBuffer[0] = 0;
return;
}
else
{
const char *pName;
if ( m_nInternalFlags & TEXTUREFLAGSINTERNAL_SHOULDEXCLUDE )
{
pName = "dev/dev_exclude_error";
}
else
{
pName = m_Name.String();
}
bool bIsUNCName = ( pName[ 0 ] == '/' && pName[ 1 ] == '/' && pName[ 2 ] != '/' );
if ( !bIsUNCName )
{
Q_snprintf( pOutBuffer, nBufferSize, "materials/%s" TEXTURE_FNAME_EXTENSION, pName );
}
else
{
Q_snprintf( pOutBuffer, nBufferSize, "%s" TEXTURE_FNAME_EXTENSION, pName );
}
}
}
bool CTexture::GetFileHandle( FileHandle_t *pOutFileHandle, char *pCacheFileName, char **ppResolvedFilename ) const
{
Assert( pOutFileHandle );
FileHandle_t& fileHandle = *pOutFileHandle;
fileHandle = FILESYSTEM_INVALID_HANDLE;
while ( fileHandle == FILESYSTEM_INVALID_HANDLE ) // run until found a file or out of rules
{
fileHandle = g_pFullFileSystem->OpenEx( pCacheFileName, "rb", 0, MaterialSystem()->GetForcedTextureLoadPathID(), ppResolvedFilename );
if ( fileHandle == FILESYSTEM_INVALID_HANDLE )
{
// try any fallbacks.
char *pHdrExt = Q_stristr( pCacheFileName, ".hdr" TEXTURE_FNAME_EXTENSION );
if ( pHdrExt )
{
DevWarning( "A custom HDR cubemap \"%s\": cannot be found on disk.\n"
"This really should have a HDR version, trying a fall back to a non-HDR version.\n", pCacheFileName );
strcpy( pHdrExt, TEXTURE_FNAME_EXTENSION );
}
else
{
// no more fallbacks
break;
}
}
}
if ( fileHandle == FILESYSTEM_INVALID_HANDLE )
{
if ( Q_strnicmp( m_Name.String(), "env_cubemap", 12 ) )
{
if ( IsPosix() )
{
Msg( "\n ##### CTexture::LoadTextureBitsFromFile couldn't find %s\n", pCacheFileName );
}
DevWarning( "\"%s\": can't be found on disk\n", pCacheFileName );
}
return false;
}
return true;
}
// Get the shaderapi texture handle associated w/ a particular frame
ShaderAPITextureHandle_t CTexture::GetTextureHandle( int nFrame, int nTextureChannel )
{
if ( nFrame < 0 )
{
nFrame = 0;
Warning( "CTexture::GetTextureHandle(): nFrame is < 0!\n" );
}
if ( nFrame >= m_nFrameCount )
{
// NOTE: This can happen during alt-tab. If you alt-tab while loading a level then the first local cubemap bind will do this, for example.
Assert( nFrame < m_nFrameCount );
return INVALID_SHADERAPI_TEXTURE_HANDLE;
}
Assert( nTextureChannel < 2 );
// Make sure we've actually allocated the texture handles
Assert( m_pTextureHandles );
Assert( HasBeenAllocated() );
if ( m_pTextureHandles == NULL || !HasBeenAllocated() )
{
return INVALID_SHADERAPI_TEXTURE_HANDLE;
}
// Don't get paired handle here...callers of this function don't know about paired textures
return m_pTextureHandles[nFrame];
}
void CTexture::GetLowResColorSample( float s, float t, float *color ) const
{
if ( m_LowResImageWidth <= 0 || m_LowResImageHeight <= 0 )
{
// Warning( "Programming error: GetLowResColorSample \"%s\": %dx%d\n", m_pName, ( int )m_LowResImageWidth, ( int )m_LowResImageHeight );
return;
}
// force s and t into [0,1)
if ( s < 0.0f )
{
s = ( 1.0f - ( float )( int )s ) + s;
}
if ( t < 0.0f )
{
t = ( 1.0f - ( float )( int )t ) + t;
}
s = s - ( float )( int )s;
t = t - ( float )( int )t;
s *= m_LowResImageWidth;
t *= m_LowResImageHeight;
int wholeS, wholeT;
wholeS = ( int )s;
wholeT = ( int )t;
float fracS, fracT;
fracS = s - ( float )( int )s;
fracT = t - ( float )( int )t;
// filter twice in the s dimension.
float sColor[2][3];
int wholeSPlusOne = ( wholeS + 1 ) % m_LowResImageWidth;
int wholeTPlusOne = ( wholeT + 1 ) % m_LowResImageHeight;
sColor[0][0] = ( 1.0f - fracS ) * ( m_pLowResImage[( wholeS + wholeT * m_LowResImageWidth ) * 3 + 0] * ( 1.0f / 255.0f ) );
sColor[0][1] = ( 1.0f - fracS ) * ( m_pLowResImage[( wholeS + wholeT * m_LowResImageWidth ) * 3 + 1] * ( 1.0f / 255.0f ) );
sColor[0][2] = ( 1.0f - fracS ) * ( m_pLowResImage[( wholeS + wholeT * m_LowResImageWidth ) * 3 + 2] * ( 1.0f / 255.0f ) );
sColor[0][0] += fracS * ( m_pLowResImage[( wholeSPlusOne + wholeT * m_LowResImageWidth ) * 3 + 0] * ( 1.0f / 255.0f ) );
sColor[0][1] += fracS * ( m_pLowResImage[( wholeSPlusOne + wholeT * m_LowResImageWidth ) * 3 + 1] * ( 1.0f / 255.0f ) );
sColor[0][2] += fracS * ( m_pLowResImage[( wholeSPlusOne + wholeT * m_LowResImageWidth ) * 3 + 2] * ( 1.0f / 255.0f ) );
sColor[1][0] = ( 1.0f - fracS ) * ( m_pLowResImage[( wholeS + wholeTPlusOne * m_LowResImageWidth ) * 3 + 0] * ( 1.0f / 255.0f ) );
sColor[1][1] = ( 1.0f - fracS ) * ( m_pLowResImage[( wholeS + wholeTPlusOne * m_LowResImageWidth ) * 3 + 1] * ( 1.0f / 255.0f ) );
sColor[1][2] = ( 1.0f - fracS ) * ( m_pLowResImage[( wholeS + wholeTPlusOne * m_LowResImageWidth ) * 3 + 2] * ( 1.0f / 255.0f ) );
sColor[1][0] += fracS * ( m_pLowResImage[( wholeSPlusOne + wholeTPlusOne * m_LowResImageWidth ) * 3 + 0] * ( 1.0f / 255.0f ) );
sColor[1][1] += fracS * ( m_pLowResImage[( wholeSPlusOne + wholeTPlusOne * m_LowResImageWidth ) * 3 + 1] * ( 1.0f / 255.0f ) );
sColor[1][2] += fracS * ( m_pLowResImage[( wholeSPlusOne + wholeTPlusOne * m_LowResImageWidth ) * 3 + 2] * ( 1.0f / 255.0f ) );
color[0] = sColor[0][0] * ( 1.0f - fracT ) + sColor[1][0] * fracT;
color[1] = sColor[0][1] * ( 1.0f - fracT ) + sColor[1][1] * fracT;
color[2] = sColor[0][2] * ( 1.0f - fracT ) + sColor[1][2] * fracT;
}
int CTexture::GetApproximateVidMemBytes( void ) const
{
ImageFormat format = GetImageFormat();
int width = GetActualWidth();
int height = GetActualHeight();
int depth = GetActualDepth();
int numFrames = GetNumAnimationFrames();
bool isMipmapped = IsMipmapped();
return numFrames * ImageLoader::GetMemRequired( width, height, depth, format, isMipmapped );
}
void CTexture::CopyFrameBufferToMe( int nRenderTargetID, Rect_t *pSrcRect, Rect_t *pDstRect )
{
Assert( m_pTextureHandles && m_nFrameCount >= 1 );
if ( m_pTextureHandles && m_nFrameCount >= 1 )
{
g_pShaderAPI->CopyRenderTargetToTextureEx( m_pTextureHandles[0], nRenderTargetID, pSrcRect, pDstRect );
}
}
void CTexture::CopyMeToFrameBuffer( int nRenderTargetID, Rect_t *pSrcRect, Rect_t *pDstRect )
{
Assert( m_pTextureHandles && m_nFrameCount >= 1 );
if ( m_pTextureHandles && m_nFrameCount >= 1 )
{
g_pShaderAPI->CopyTextureToRenderTargetEx( nRenderTargetID, m_pTextureHandles[0], pSrcRect, pDstRect );
}
}
ITexture *CTexture::GetEmbeddedTexture( int nIndex )
{
return ( nIndex == 0 ) ? this : NULL;
}
void CTexture::DeleteIfUnreferenced()
{
if ( m_nRefCount > 0 )
return;
if ( ThreadInMainThread() )
{
// Render thread better not be active or bad things can happen.
Assert( MaterialSystem()->GetRenderThreadId() == (uintp)-1 );
TextureManager()->RemoveTexture( this );
return;
}
// Can't actually clean up from render thread--just safely mark this texture as
// one we should check for cleanup next EndFrame when it's safe.
TextureManager()->MarkUnreferencedTextureForCleanup( this );
}
//Swap everything about a texture except the name. Created to support Portal mod's need for swapping out water render targets in recursive stencil views
void CTexture::SwapContents( ITexture *pOther )
{
if( (pOther == NULL) || (pOther == this) )
return;
ICallQueue *pCallQueue = materials->GetRenderContext()->GetCallQueue();
if ( pCallQueue )
{
pCallQueue->QueueCall( this, &CTexture::SwapContents, pOther );
return;
}
AssertMsg( dynamic_cast<CTexture *>(pOther) != NULL, "Texture swapping broken" );
CTexture *pOtherAsCTexture = (CTexture *)pOther;
CTexture *pTemp = (CTexture *)stackalloc( sizeof( CTexture ) );
//swap everything. Note that this copies the entire object including the
// vtable pointer, thus ruining polymorphism. Use with care.
// The unnecessary casts to (void*) hint to clang that we know what we
// are doing.
memcpy( (void*)pTemp, (const void*)this, sizeof( CTexture ) );
memcpy( (void*)this, (const void*)pOtherAsCTexture, sizeof( CTexture ) );
memcpy( (void*)pOtherAsCTexture, (const void*)pTemp, sizeof( CTexture ) );
//we have the other's name, give it back
memcpy( &pOtherAsCTexture->m_Name, &m_Name, sizeof( m_Name ) );
//pTemp still has our name
memcpy( &m_Name, &pTemp->m_Name, sizeof( m_Name ) );
}
void CTexture::MarkAsPreloaded( bool bSet )
{
if ( bSet )
{
m_nInternalFlags |= TEXTUREFLAGSINTERNAL_PRELOADED;
}
else
{
m_nInternalFlags &= ~TEXTUREFLAGSINTERNAL_PRELOADED;
}
}
bool CTexture::IsPreloaded() const
{
return ( ( m_nInternalFlags & TEXTUREFLAGSINTERNAL_PRELOADED ) != 0 );
}
void CTexture::MarkAsExcluded( bool bSet, int nDimensionsLimit )
{
if ( bSet )
{
// exclusion trumps picmipping
m_nInternalFlags |= TEXTUREFLAGSINTERNAL_SHOULDEXCLUDE;
m_nDesiredDimensionLimit = 0;
}
else
{
// not excluding, but can optionally picmip
m_nInternalFlags &= ~TEXTUREFLAGSINTERNAL_SHOULDEXCLUDE;
m_nDesiredDimensionLimit = nDimensionsLimit;
}
}
bool CTexture::UpdateExcludedState( void )
{
bool bDesired = ( m_nInternalFlags & TEXTUREFLAGSINTERNAL_SHOULDEXCLUDE ) != 0;
bool bActual = ( m_nInternalFlags & TEXTUREFLAGSINTERNAL_EXCLUDED ) != 0;
if ( ( bDesired == bActual ) && ( m_nDesiredDimensionLimit == m_nActualDimensionLimit ) )
{
return false;
}
if ( m_nInternalFlags & TEXTUREFLAGSINTERNAL_QUEUEDLOAD )
{
// already scheduled
return true;
}
// force the texture to re-download, causes the texture bits to match its desired exclusion state
Download();
return true;
}
void CTextureStreamingJob::OnAsyncFindComplete( ITexture* pTex, void* pExtraArgs )
{
const intp cArgsAsInt = ( intp ) pExtraArgs;
Assert( m_pOwner == NULL || m_pOwner == pTex );
if ( m_pOwner )
m_pOwner->OnStreamingJobComplete( static_cast<ResidencyType_t>( cArgsAsInt ) );
// OnStreamingJobComplete should've cleaned us up
Assert( m_pOwner == NULL );
}
// ------------------------------------------------------------------------------------------------
int GetThreadId()
{
TM_ZONE_DEFAULT( TELEMETRY_LEVEL0 );
// Turns the current thread into a 0-based index for use in accessing statics in this file.
int retVal = INT_MAX;
if ( ThreadInMainThread() )
retVal = 0;
else if ( MaterialSystem()->GetRenderThreadId() == ThreadGetCurrentId() )
retVal = 1;
else if ( TextureManager()->ThreadInAsyncLoadThread() )
retVal = 2;
else if ( TextureManager()->ThreadInAsyncReadThread() )
retVal = 3;
else
{
STAGING_ONLY_EXEC( AssertAlways( !"Unexpected thread in GetThreadId, need to debug this--crash is next. Tell McJohn." ) );
DebuggerBreakIfDebugging_StagingOnly();
}
Assert( retVal < MAX_RENDER_THREADS );
return retVal;
}
// ------------------------------------------------------------------------------------------------
bool SLoadTextureBitsFromFile( IVTFTexture **ppOutVtfTexture, FileHandle_t hFile, unsigned int nFlags,
TextureLODControlSettings_t* pInOutCachedFileLodSettings,
int nDesiredDimensionLimit, unsigned short* pOutStreamedMips,
const char* pName, const char* pCacheFileName,
TexDimensions_t* pOptOutDimsMapping,
TexDimensions_t* pOptOutDimsActual,
TexDimensions_t* pOptOutDimsAllocated,
unsigned int* pOptOutStripFlags )
{
// NOTE! NOTE! NOTE! If you are making changes to this function, be aware that it has threading
// NOTE! NOTE! NOTE! implications. It can be called synchronously by the Main thread,
// NOTE! NOTE! NOTE! or by the streaming texture code!
Assert( ppOutVtfTexture != NULL && *ppOutVtfTexture != NULL );
CUtlBuffer buf;
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - ReadHeaderFromFile", __FUNCTION__ );
int nHeaderSize = VTFFileHeaderSize( VTF_MAJOR_VERSION );
// restrict read to the header only!
// header provides info to avoid reading the entire file
int nBytesOptimalRead = GetOptimalReadBuffer( &buf, hFile, nHeaderSize );
int nBytesRead = g_pFullFileSystem->ReadEx( buf.Base(), nBytesOptimalRead, Min( nHeaderSize, ( int ) g_pFullFileSystem->Size( hFile ) ), hFile ); // only read as much as the file has
buf.SeekPut( CUtlBuffer::SEEK_HEAD, nBytesRead );
nBytesRead = nHeaderSize = ( ( VTFFileBaseHeader_t * ) buf.Base() )->headerSize;
g_pFullFileSystem->Seek( hFile, nHeaderSize, FILESYSTEM_SEEK_HEAD );
}
// Unserialize the header only
// need the header first to determine remainder of data
if ( !( *ppOutVtfTexture )->Unserialize( buf, true ) )
{
Warning( "Error reading texture header \"%s\"\n", pCacheFileName );
return false;
}
// Need to record this now, before we ask for the trimmed down data to potentially be loaded.
TexDimensions_t dimsMappingCurrent( ( *ppOutVtfTexture )->Width(), ( *ppOutVtfTexture )->Height(), ( *ppOutVtfTexture )->MipCount(), ( *ppOutVtfTexture )->Depth() );
if ( pOptOutDimsMapping )
( *pOptOutDimsMapping ) = dimsMappingCurrent;
int nFullFlags = ( *ppOutVtfTexture )->Flags()
| nFlags;
// Seek the reading back to the front of the buffer
buf.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );
// Compute the actual texture dimensions
int nMipSkipCount = ComputeMipSkipCount( pName, dimsMappingCurrent, false, *ppOutVtfTexture, nFullFlags, nDesiredDimensionLimit, pOutStreamedMips, pInOutCachedFileLodSettings, pOptOutDimsActual, pOptOutDimsAllocated, pOptOutStripFlags );
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - ReadDataFromFile", __FUNCTION__ );
// Determine how much of the file to read in
int nFileSize = ( *ppOutVtfTexture )->FileSize( nMipSkipCount );
int nActualFileSize = (int)g_pFullFileSystem->Size( hFile );
if ( nActualFileSize < nFileSize )
{
if ( mat_spew_on_texture_size.GetInt() )
DevMsg( "Bad VTF data for %s, expected file size:%d actual file size:%d \n", pCacheFileName, nFileSize, nActualFileSize );
nFileSize = nActualFileSize;
}
// Read only the portion of the file that we care about
g_pFullFileSystem->Seek( hFile, 0, FILESYSTEM_SEEK_HEAD );
int nBytesOptimalRead = GetOptimalReadBuffer( &buf, hFile, nFileSize );
int nBytesRead = g_pFullFileSystem->ReadEx( buf.Base(), nBytesOptimalRead, nFileSize, hFile );
buf.SeekPut( CUtlBuffer::SEEK_HEAD, nBytesRead );
// Some hardware doesn't support copying textures to other textures. For them, we need to reread the
// whole file, so if they are doing the final read (the fine levels) then reread everything by stripping
// off the flags we are trying to pass in.
unsigned int nForceFlags = nFullFlags & TEXTUREFLAGS_STREAMABLE;
if ( !HardwareConfig()->CanStretchRectFromTextures() && ( nForceFlags & TEXTUREFLAGS_STREAMABLE_FINE ) )
nForceFlags = 0;
// NOTE: Skipping mip levels here will cause the size to be changed
bool bRetVal = ( *ppOutVtfTexture )->UnserializeEx( buf, false, nForceFlags, nMipSkipCount );
FreeOptimalReadBuffer( 6*1024*1024 );
if ( !bRetVal )
{
Warning( "Error reading texture data \"%s\"\n", pCacheFileName );
}
return bRetVal;
}
//-----------------------------------------------------------------------------
// Compute the actual mip count based on the actual size
//-----------------------------------------------------------------------------
int ComputeActualMipCount( const TexDimensions_t& actualDims, unsigned int nFlags )
{
if ( nFlags & TEXTUREFLAGS_ENVMAP )
{
if ( !HardwareConfig()->SupportsMipmappedCubemaps() )
{
return 1;
}
}
if ( nFlags & TEXTUREFLAGS_NOMIP )
{
return 1;
}
// Unless ALLMIPS is set, we stop mips at 32x32
const int nMaxMipSize = 32;
// Clamp border textures on Posix to fix L4D2 flashlight cookie issue
#ifdef DX_TO_GL_ABSTRACTION
if ( ( false && !g_bForceTextureAllMips && !( nFlags & TEXTUREFLAGS_ALL_MIPS ) ) || ( true && ( nFlags & TEXTUREFLAGS_BORDER ) ) )
#else
if ( ( true && !g_bForceTextureAllMips && !( nFlags & TEXTUREFLAGS_ALL_MIPS ) ) || ( false && ( nFlags & TEXTUREFLAGS_BORDER ) ) )
#endif
{
int nNumMipLevels = 1;
int h = actualDims.m_nWidth;
int w = actualDims.m_nHeight;
while ( MIN( w, h ) > nMaxMipSize )
{
++nNumMipLevels;
w >>= 1;
h >>= 1;
}
return nNumMipLevels;
}
return ImageLoader::GetNumMipMapLevels( actualDims.m_nWidth, actualDims.m_nHeight, actualDims.m_nDepth );
}
// ------------------------------------------------------------------------------------------------
int ComputeMipSkipCount( const char* pName, const TexDimensions_t& mappingDims, bool bIgnorePicmip, IVTFTexture *pOptVTFTexture, unsigned int nFlags, int nDesiredDimensionLimit, unsigned short* pOutStreamedMips, TextureLODControlSettings_t* pInOutCachedFileLodSettings, TexDimensions_t* pOptOutActualDims, TexDimensions_t* pOptOutAllocatedDims, unsigned int* pOptOutStripFlags )
{
// NOTE! NOTE! NOTE! If you are making changes to this function, be aware that it has threading
// NOTE! NOTE! NOTE! implications. It can be called synchronously by the Main thread,
// NOTE! NOTE! NOTE! or by the streaming texture code!
Assert( pName != NULL );
Assert( pOutStreamedMips != NULL );
Assert( pInOutCachedFileLodSettings != NULL );
TexDimensions_t actualDims = mappingDims,
allocatedDims;
const bool bTextureMigration = ( nFlags & TEXTUREFLAGS_STREAMABLE ) != 0;
unsigned int stripFlags = 0;
int nClampX = actualDims.m_nWidth; // no clamping (clamp to texture dimensions)
int nClampY = actualDims.m_nHeight;
int nClampZ = actualDims.m_nDepth;
// Fetch LOD settings from the VTF if available
TextureLODControlSettings_t lcs;
memset( &lcs, 0, sizeof( lcs ) );
TextureLODControlSettings_t const *pLODInfo = NULL;
if ( pOptVTFTexture )
{
pLODInfo = reinterpret_cast<TextureLODControlSettings_t const *> (
pOptVTFTexture->GetResourceData( VTF_RSRC_TEXTURE_LOD_SETTINGS, NULL ) );
// Texture streaming means there are times we call this where we don't have a VTFTexture, even though
// we're a file. So we need to store off the LOD settings whenever we get in here with a file that has them
// so that we can use the correct values for when we don't. Otherwise, the texture will be confused about
// what size to use and everything will die a horrible, horrible death.
if ( pLODInfo )
( *pInOutCachedFileLodSettings ) = ( *pLODInfo );
}
else if ( bTextureMigration )
{
pLODInfo = pInOutCachedFileLodSettings;
}
if ( pLODInfo )
lcs = *pLODInfo;
// Prepare the default LOD settings (that essentially result in no clamping)
TextureLODControlSettings_t default_lod_settings;
memset( &default_lod_settings, 0, sizeof( default_lod_settings ) );
{
for ( int w = actualDims.m_nWidth; w > 1; w >>= 1 )
++ default_lod_settings.m_ResolutionClampX;
for ( int h = actualDims.m_nHeight; h > 1; h >>= 1 )
++ default_lod_settings.m_ResolutionClampY;
}
// Check for LOD control override
{
TextureLodOverride::OverrideInfo oi = TextureLodOverride::Get( pName );
if ( oi.x && oi.y && !pLODInfo ) // If overriding texture that doesn't have lod info yet, then use default
lcs = default_lod_settings;
lcs.m_ResolutionClampX += oi.x;
lcs.m_ResolutionClampY += oi.y;
if ( int8( lcs.m_ResolutionClampX ) < 0 )
lcs.m_ResolutionClampX = 0;
if ( int8( lcs.m_ResolutionClampY ) < 0 )
lcs.m_ResolutionClampY = 0;
}
// Compute the requested mip0 dimensions
if ( lcs.m_ResolutionClampX && lcs.m_ResolutionClampY )
{
nClampX = (1 << lcs.m_ResolutionClampX );
nClampY = (1 << lcs.m_ResolutionClampY );
}
// In case clamp values exceed texture dimensions, then fix up
// the clamping values
nClampX = min( nClampX, (int)actualDims.m_nWidth );
nClampY = min( nClampY, (int)actualDims.m_nHeight );
//
// Honor dimension limit restrictions
//
if ( nDesiredDimensionLimit > 0 )
{
while ( nClampX > nDesiredDimensionLimit ||
nClampY > nDesiredDimensionLimit )
{
nClampX >>= 1;
nClampY >>= 1;
}
}
//
// Unless ignoring picmip, reflect the global picmip level in clamp dimensions
//
if ( !bIgnorePicmip )
{
// If picmip requests texture degradation, then honor it
// for loddable textures only
if ( !( nFlags & TEXTUREFLAGS_NOLOD ) &&
( g_config.skipMipLevels > 0 ) )
{
for ( int iDegrade = 0; iDegrade < g_config.skipMipLevels; ++ iDegrade )
{
// don't go lower than 4, or dxt textures won't work properly
if ( nClampX > 4 &&
nClampY > 4 )
{
nClampX >>= 1;
nClampY >>= 1;
}
}
}
// If picmip requests quality upgrade, then always honor it
if ( g_config.skipMipLevels < 0 )
{
for ( int iUpgrade = 0; iUpgrade < - g_config.skipMipLevels; ++ iUpgrade )
{
if ( nClampX < actualDims.m_nWidth &&
nClampY < actualDims.m_nHeight )
{
nClampX <<= 1;
nClampY <<= 1;
}
else
break;
}
}
}
//
// Now use hardware settings to clamp our "clamping dimensions"
//
int iHwWidth = HardwareConfig()->MaxTextureWidth();
int iHwHeight = HardwareConfig()->MaxTextureHeight();
int iHwDepth = HardwareConfig()->MaxTextureDepth();
nClampX = min( nClampX, max( iHwWidth, 4 ) );
nClampY = min( nClampY, max( iHwHeight, 4 ) );
nClampZ = min( nClampZ, max( iHwDepth, 1 ) );
// In case clamp values exceed texture dimensions, then fix up
// the clamping values.
nClampX = min( nClampX, (int)actualDims.m_nWidth );
nClampY = min( nClampY, (int)actualDims.m_nHeight );
nClampZ = min( nClampZ, (int)actualDims.m_nDepth );
//
// Clamp to the determined dimensions
//
int numMipsSkipped = 0; // will compute now when clamping how many mips we drop
while ( ( actualDims.m_nWidth > nClampX ) ||
( actualDims.m_nHeight > nClampY ) ||
( actualDims.m_nDepth > nClampZ ) )
{
actualDims.m_nWidth >>= 1;
actualDims.m_nHeight >>= 1;
actualDims.m_nDepth = Max( 1, actualDims.m_nDepth >> 1 );
++ numMipsSkipped;
}
Assert( actualDims.m_nWidth > 0 && actualDims.m_nHeight > 0 && actualDims.m_nDepth > 0 );
// Now that we've got the actual size, we can figure out the mip count
actualDims.m_nMipCount = ComputeActualMipCount( actualDims, nFlags );
// If we're streaming, cut down what we're loading.
// We can only stream things that have a mipmap pyramid (not just a single mipmap).
bool bHasSetAllocation = false;
if ( ( nFlags & TEXTUREFLAGS_STREAMABLE ) == TEXTUREFLAGS_STREAMABLE_COARSE )
{
if ( actualDims.m_nMipCount > 1 )
{
allocatedDims.m_nWidth = actualDims.m_nWidth;
allocatedDims.m_nHeight = actualDims.m_nHeight;
allocatedDims.m_nDepth = actualDims.m_nDepth;
allocatedDims.m_nMipCount = actualDims.m_nMipCount;
for ( int i = 0; i < STREAMING_START_MIPMAP; ++i )
{
// Stop when width or height is at 4 pixels (or less). We could do better,
// but some textures really can't function if they're less than 4 pixels (compressed textures, for example).
if ( allocatedDims.m_nWidth <= 4 || allocatedDims.m_nHeight <= 4 )
break;
allocatedDims.m_nWidth >>= 1;
allocatedDims.m_nHeight >>= 1;
allocatedDims.m_nDepth = Max( 1, allocatedDims.m_nDepth >> 1 );
allocatedDims.m_nMipCount = Max( 1, allocatedDims.m_nMipCount - 1 );
++numMipsSkipped;
++( *pOutStreamedMips );
}
bHasSetAllocation = true;
}
else
{
// Clear out that we're streaming, this isn't a texture we can stream.
stripFlags |= TEXTUREFLAGS_STREAMABLE_COARSE;
}
}
if ( !bHasSetAllocation )
{
allocatedDims.m_nWidth = actualDims.m_nWidth;
allocatedDims.m_nHeight = actualDims.m_nHeight;
allocatedDims.m_nDepth = actualDims.m_nDepth;
allocatedDims.m_nMipCount = actualDims.m_nMipCount;
}
if ( pOptOutActualDims )
*pOptOutActualDims = actualDims;
if ( pOptOutAllocatedDims )
*pOptOutAllocatedDims = allocatedDims;
if ( pOptOutStripFlags )
( *pOptOutStripFlags ) = stripFlags;
// Returns the number we skipped
return numMipsSkipped;
}
//-----------------------------------------------------------------------------
// Get an optimal read buffer, persists and avoids excessive allocations
//-----------------------------------------------------------------------------
int GetOptimalReadBuffer( CUtlBuffer* pOutOptimalBuffer, FileHandle_t hFile, int nSize )
{
// NOTE! NOTE! NOTE! If you are making changes to this function, be aware that it has threading
// NOTE! NOTE! NOTE! implications. It can be called synchronously by the Main thread,
// NOTE! NOTE! NOTE! or by the streaming texture code!
Assert( GetThreadId() < MAX_RENDER_THREADS );
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s (%d bytes)", __FUNCTION__, nSize );
Assert( pOutOptimalBuffer != NULL );
// get an optimal read buffer, only resize if necessary
const int minSize = 2 * 1024 * 1024; // Uses 2MB min to avoid fragmentation
nSize = max( nSize, minSize );
int nBytesOptimalRead = g_pFullFileSystem->GetOptimalReadSize( hFile, nSize );
const int ti = GetThreadId();
if ( nBytesOptimalRead > s_nOptimalReadBufferSize[ ti ] )
{
FreeOptimalReadBuffer( 0 );
s_nOptimalReadBufferSize[ ti ] = nBytesOptimalRead;
s_pOptimalReadBuffer[ ti ] = g_pFullFileSystem->AllocOptimalReadBuffer( hFile, nSize );
if ( mat_spewalloc.GetBool() )
{
Msg( "Allocated optimal read buffer of %d bytes @ 0x%p for thread %d\n", s_nOptimalReadBufferSize[ ti ], s_pOptimalReadBuffer[ ti ], ti );
}
}
// set external buffer and reset to empty
( *pOutOptimalBuffer ).SetExternalBuffer( s_pOptimalReadBuffer[ ti ], s_nOptimalReadBufferSize[ ti ], 0 );
// return the optimal read size
return nBytesOptimalRead;
}
//-----------------------------------------------------------------------------
// Free the optimal read buffer if it grows too large
//-----------------------------------------------------------------------------
void FreeOptimalReadBuffer( int nMaxSize )
{
// NOTE! NOTE! NOTE! If you are making changes to this function, be aware that it has threading
// NOTE! NOTE! NOTE! implications. It can be called synchronously by the Main thread,
// NOTE! NOTE! NOTE! or by the streaming texture code!
Assert( GetThreadId() < MAX_RENDER_THREADS );
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
const int ti = GetThreadId();
if ( s_pOptimalReadBuffer[ ti ] && s_nOptimalReadBufferSize[ ti ] >= nMaxSize )
{
if ( mat_spewalloc.GetBool() )
{
Msg( "Freeing optimal read buffer of %d bytes @ 0x%p for thread %d\n", s_nOptimalReadBufferSize[ ti ], s_pOptimalReadBuffer[ ti ], ti );
}
g_pFullFileSystem->FreeOptimalReadBuffer( s_pOptimalReadBuffer[ ti ] );
s_pOptimalReadBuffer[ ti ] = NULL;
s_nOptimalReadBufferSize[ ti ] = 0;
}
}
#if defined( STAGING_ONLY )
CON_COMMAND( dumptexallocs, "List currently allocated textures and properties about them" )
{
Msg( "Texture Memory Statistics follow:\n" );
uint64 totalTexMemAllocated = 0;
FOR_EACH_MAP_FAST( g_currentTextures, i )
{
const TexInfo_t& tex = g_currentTextures[ i ];
uint64 thisTexMem = tex.ComputeTexSize();
totalTexMemAllocated += thisTexMem;
Msg( "%s: %llu bytes\n", ( const char * ) tex.m_Name, thisTexMem );
}
Msg( "Total Memory Allocated: %llu bytes\n", totalTexMemAllocated );
}
#endif
//////////////////////////////////////////////////////////////////////////
//
// Saving all the texture LOD modifications to content
//
//////////////////////////////////////////////////////////////////////////
#ifdef IS_WINDOWS_PC
static bool SetBufferValue( char *chTxtFileBuffer, char const *szLookupKey, char const *szNewValue )
{
bool bResult = false;
size_t lenTmp = strlen( szNewValue );
size_t nTxtFileBufferLen = strlen( chTxtFileBuffer );
for ( char *pch = chTxtFileBuffer;
( NULL != ( pch = strstr( pch, szLookupKey ) ) );
++ pch )
{
char *val = pch + strlen( szLookupKey );
if ( !V_isspace( *val ) )
continue;
else
++ val;
char *pValStart = val;
// Okay, here comes the value
while ( *val && V_isspace( *val ) )
++ val;
while ( *val && !V_isspace( *val ) )
++ val;
char *pValEnd = val; // Okay, here ends the value
memmove( pValStart + lenTmp, pValEnd, chTxtFileBuffer + nTxtFileBufferLen + 1 - pValEnd );
memcpy( pValStart, szNewValue, lenTmp );
nTxtFileBufferLen += ( lenTmp - ( pValEnd - pValStart ) );
bResult = true;
}
if ( !bResult )
{
char *pchAdd = chTxtFileBuffer + nTxtFileBufferLen;
strcpy( pchAdd + strlen( pchAdd ), "\n" );
strcpy( pchAdd + strlen( pchAdd ), szLookupKey );
strcpy( pchAdd + strlen( pchAdd ), " " );
strcpy( pchAdd + strlen( pchAdd ), szNewValue );
strcpy( pchAdd + strlen( pchAdd ), "\n" );
bResult = true;
}
return bResult;
}
// Replaces the first occurrence of "szFindData" with "szNewData"
// Returns the remaining buffer past the replaced data or NULL if
// no replacement occurred.
static char * BufferReplace( char *buf, char const *szFindData, char const *szNewData )
{
size_t len = strlen( buf ), lFind = strlen( szFindData ), lNew = strlen( szNewData );
if ( char *pBegin = strstr( buf, szFindData ) )
{
memmove( pBegin + lNew, pBegin + lFind, buf + len - ( pBegin + lFind ) );
memmove( pBegin, szNewData, lNew );
return pBegin + lNew;
}
return NULL;
}
class CP4Requirement
{
public:
CP4Requirement();
~CP4Requirement();
protected:
bool m_bLoadedModule;
CSysModule *m_pP4Module;
};
CP4Requirement::CP4Requirement() :
m_bLoadedModule( false ),
m_pP4Module( NULL )
{
#ifdef STAGING_ONLY
if ( p4 )
return;
// load the p4 lib
m_pP4Module = Sys_LoadModule( "p4lib" );
m_bLoadedModule = true;
if ( m_pP4Module )
{
CreateInterfaceFn factory = Sys_GetFactory( m_pP4Module );
if ( factory )
{
p4 = ( IP4 * )factory( P4_INTERFACE_VERSION, NULL );
if ( p4 )
{
extern CreateInterfaceFn g_fnMatSystemConnectCreateInterface;
p4->Connect( g_fnMatSystemConnectCreateInterface );
p4->Init();
}
}
}
#endif // STAGING_ONLY
if ( !p4 )
{
Warning( "Can't load p4lib.dll\n" );
}
}
CP4Requirement::~CP4Requirement()
{
if ( m_bLoadedModule && m_pP4Module )
{
if ( p4 )
{
p4->Shutdown();
p4->Disconnect();
}
Sys_UnloadModule( m_pP4Module );
m_pP4Module = NULL;
p4 = NULL;
}
}
static ConVar mat_texture_list_content_path( "mat_texture_list_content_path", "", FCVAR_ARCHIVE, "The content path to the materialsrc directory. If left unset, it'll assume your content directory is next to the currently running game dir." );
CON_COMMAND_F( mat_texture_list_txlod_sync, "'reset' - resets all run-time changes to LOD overrides, 'save' - saves all changes to material content files", FCVAR_DONTRECORD )
{
using namespace TextureLodOverride;
if ( args.ArgC() != 2 )
goto usage;
char const *szCmd = args.Arg( 1 );
Msg( "mat_texture_list_txlod_sync %s...\n", szCmd );
if ( !stricmp( szCmd, "reset" ) )
{
for ( int k = 0; k < s_OverrideMap.GetNumStrings(); ++ k )
{
char const *szTx = s_OverrideMap.String( k );
s_OverrideMap[ k ] = OverrideInfo(); // Reset the override info
// Force the texture LOD override to get re-processed
if ( ITexture *pTx = materials->FindTexture( szTx, "" ) )
pTx->ForceLODOverride( 0 );
else
Warning( " mat_texture_list_txlod_sync reset - texture '%s' no longer found.\n", szTx );
}
s_OverrideMap.Purge();
Msg("mat_texture_list_txlod_sync reset : completed.\n");
return;
}
else if ( !stricmp( szCmd, "save" ) )
{
CP4Requirement p4req;
if ( !p4 )
g_p4factory->SetDummyMode( true );
for ( int k = 0; k < s_OverrideMap.GetNumStrings(); ++ k )
{
char const *szTx = s_OverrideMap.String( k );
OverrideInfo oi = s_OverrideMap[ k ];
ITexture *pTx = materials->FindTexture( szTx, "" );
if ( !oi.x || !oi.y )
continue;
if ( !pTx )
{
Warning( " mat_texture_list_txlod_sync save - texture '%s' no longer found.\n", szTx );
continue;
}
int iMaxWidth = pTx->GetActualWidth(), iMaxHeight = pTx->GetActualHeight();
// Save maxwidth and maxheight
char chMaxWidth[20], chMaxHeight[20];
sprintf( chMaxWidth, "%d", iMaxWidth ), sprintf( chMaxHeight, "%d", iMaxHeight );
// We have the texture and path to its content
char chResolveName[ MAX_PATH ] = {0}, chResolveNameArg[ MAX_PATH ] = {0};
Q_snprintf( chResolveNameArg, sizeof( chResolveNameArg ) - 1, "materials/%s" TEXTURE_FNAME_EXTENSION, szTx );
char *szTextureContentPath;
if ( !mat_texture_list_content_path.GetString()[0] )
{
szTextureContentPath = const_cast< char * >( g_pFullFileSystem->RelativePathToFullPath( chResolveNameArg, "game", chResolveName, sizeof( chResolveName ) - 1 ) );
if ( !szTextureContentPath )
{
Warning( " mat_texture_list_txlod_sync save - texture '%s' is not loaded from file system.\n", szTx );
continue;
}
if ( !BufferReplace( szTextureContentPath, "\\game\\", "\\content\\" ) ||
!BufferReplace( szTextureContentPath, "\\materials\\", "\\materialsrc\\" ) )
{
Warning( " mat_texture_list_txlod_sync save - texture '%s' cannot be mapped to content directory.\n", szTx );
continue;
}
}
else
{
V_strncpy( chResolveName, mat_texture_list_content_path.GetString(), MAX_PATH );
V_strncat( chResolveName, "/", MAX_PATH );
V_strncat( chResolveName, szTx, MAX_PATH );
V_strncat( chResolveName, TEXTURE_FNAME_EXTENSION, MAX_PATH );
szTextureContentPath = chResolveName;
}
// Figure out what kind of source content is there:
// 1. look for TGA - if found, get the txt file (if txt file missing, create one)
// 2. otherwise look for PSD - affecting psdinfo
// 3. else error
char *pExtPut = szTextureContentPath + strlen( szTextureContentPath ) - strlen( TEXTURE_FNAME_EXTENSION ); // compensating the TEXTURE_FNAME_EXTENSION(.vtf) extension
// 1.tga
sprintf( pExtPut, ".tga" );
if ( g_pFullFileSystem->FileExists( szTextureContentPath ) )
{
// Have tga - pump in the txt file
sprintf( pExtPut, ".txt" );
CUtlBuffer bufTxtFileBuffer( 0, 0, CUtlBuffer::TEXT_BUFFER );
g_pFullFileSystem->ReadFile( szTextureContentPath, 0, bufTxtFileBuffer );
for ( int kCh = 0; kCh < 1024; ++kCh ) bufTxtFileBuffer.PutChar( 0 );
// Now fix maxwidth/maxheight settings
SetBufferValue( ( char * ) bufTxtFileBuffer.Base(), "maxwidth", chMaxWidth );
SetBufferValue( ( char * ) bufTxtFileBuffer.Base(), "maxheight", chMaxHeight );
bufTxtFileBuffer.SeekPut( CUtlBuffer::SEEK_HEAD, strlen( ( char * ) bufTxtFileBuffer.Base() ) );
// Check out or add the file
g_p4factory->SetOpenFileChangeList( "Texture LOD Autocheckout" );
CP4AutoEditFile autop4_edit( szTextureContentPath );
// Save the file contents
if ( g_pFullFileSystem->WriteFile( szTextureContentPath, 0, bufTxtFileBuffer ) )
{
Msg(" '%s' : saved.\n", szTextureContentPath );
CP4AutoAddFile autop4_add( szTextureContentPath );
}
else
{
Warning( " '%s' : failed to save - set \"maxwidth %d maxheight %d\" manually.\n",
szTextureContentPath, iMaxWidth, iMaxHeight );
}
continue;
}
// 2.psd
sprintf( pExtPut, ".psd" );
if ( g_pFullFileSystem->FileExists( szTextureContentPath ) )
{
char chCommand[MAX_PATH];
char szTxtFileName[MAX_PATH] = {0};
GetModSubdirectory( "tmp_lod_psdinfo.txt", szTxtFileName, sizeof( szTxtFileName ) );
sprintf( chCommand, "/C psdinfo \"%s\" > \"%s\"", szTextureContentPath, szTxtFileName);
ShellExecute( NULL, NULL, "cmd.exe", chCommand, NULL, SW_HIDE );
Sleep( 200 );
CUtlBuffer bufTxtFileBuffer( 0, 0, CUtlBuffer::TEXT_BUFFER );
g_pFullFileSystem->ReadFile( szTxtFileName, 0, bufTxtFileBuffer );
for ( int kCh = 0; kCh < 1024; ++ kCh ) bufTxtFileBuffer.PutChar( 0 );
// Now fix maxwidth/maxheight settings
SetBufferValue( ( char * ) bufTxtFileBuffer.Base(), "maxwidth", chMaxWidth );
SetBufferValue( ( char * ) bufTxtFileBuffer.Base(), "maxheight", chMaxHeight );
bufTxtFileBuffer.SeekPut( CUtlBuffer::SEEK_HEAD, strlen( ( char * ) bufTxtFileBuffer.Base() ) );
// Check out or add the file
// Save the file contents
if ( g_pFullFileSystem->WriteFile( szTxtFileName, 0, bufTxtFileBuffer ) )
{
g_p4factory->SetOpenFileChangeList( "Texture LOD Autocheckout" );
CP4AutoEditFile autop4_edit( szTextureContentPath );
sprintf( chCommand, "/C psdinfo -write \"%s\" < \"%s\"", szTextureContentPath, szTxtFileName );
Sleep( 200 );
ShellExecute( NULL, NULL, "cmd.exe", chCommand, NULL, SW_HIDE );
Sleep( 200 );
Msg(" '%s' : saved.\n", szTextureContentPath );
CP4AutoAddFile autop4_add( szTextureContentPath );
}
else
{
Warning( " '%s' : failed to save - set \"maxwidth %d maxheight %d\" manually.\n",
szTextureContentPath, iMaxWidth, iMaxHeight );
}
continue;
}
// 3. - error
sprintf( pExtPut, "" );
{
Warning( " '%s' : doesn't specify a valid TGA or PSD file!\n", szTextureContentPath );
continue;
}
}
Msg("mat_texture_list_txlod_sync save : completed.\n");
return;
}
else
goto usage;
return;
usage:
Warning(
"Usage:\n"
" mat_texture_list_txlod_sync reset - resets all run-time changes to LOD overrides;\n"
" mat_texture_list_txlod_sync save - saves all changes to material content files.\n"
);
}
#endif