You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4959 lines
154 KiB
4959 lines
154 KiB
//========= 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 <malloc.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; |
|
} |
|
|
|
if ( V_strstr( GetName(), "c_sniperrifle_scope" ) ) |
|
{ |
|
int i = 0; |
|
i = 3; |
|
} |
|
|
|
|
|
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 = (unsigned int)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 = (unsigned int)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() == 0xFFFFFFFF ); |
|
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 int cArgsAsInt = ( int ) 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 ); |
|
|
|
if ( V_strstr( pName, "c_rocketlauncher/c_rocketlauncher" ) ) |
|
{ |
|
int i = 0; |
|
i = 3; |
|
} |
|
|
|
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
|
|
|