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.
3497 lines
96 KiB
3497 lines
96 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: The VTF file format I/O class to help simplify access to VTF files |
|
// |
|
//=====================================================================================// |
|
|
|
#undef fopen |
|
#include "bitmap/imageformat.h" |
|
#include "cvtf.h" |
|
#include "utlbuffer.h" |
|
#include "tier0/dbg.h" |
|
#include "mathlib/vector.h" |
|
#include "mathlib/mathlib.h" |
|
#include "tier1/strtools.h" |
|
#include "tier0/mem.h" |
|
#include "s3tc_decode.h" |
|
#include "utlvector.h" |
|
#include "vprof_telemetry.h" |
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include "tier0/memdbgon.h" |
|
|
|
// byteswap data descriptions |
|
BEGIN_BYTESWAP_DATADESC( VTFFileBaseHeader_t ) |
|
DEFINE_ARRAY( fileTypeString, FIELD_CHARACTER, 4 ), |
|
DEFINE_ARRAY( version, FIELD_INTEGER, 2 ), |
|
DEFINE_FIELD( headerSize, FIELD_INTEGER ), |
|
END_DATADESC() |
|
|
|
BEGIN_BYTESWAP_DATADESC( VTFFileHeaderV7_1_t ) |
|
DEFINE_ARRAY( fileTypeString, FIELD_CHARACTER, 4 ), |
|
DEFINE_ARRAY( version, FIELD_INTEGER, 2 ), |
|
DEFINE_FIELD( headerSize, FIELD_INTEGER ), |
|
DEFINE_FIELD( width, FIELD_SHORT ), |
|
DEFINE_FIELD( height, FIELD_SHORT ), |
|
DEFINE_FIELD( flags, FIELD_INTEGER ), |
|
DEFINE_FIELD( numFrames, FIELD_SHORT ), |
|
DEFINE_FIELD( startFrame, FIELD_SHORT ), |
|
DEFINE_FIELD( reflectivity, FIELD_VECTOR ), |
|
DEFINE_FIELD( bumpScale, FIELD_FLOAT ), |
|
DEFINE_FIELD( imageFormat, FIELD_INTEGER ), |
|
DEFINE_FIELD( numMipLevels, FIELD_CHARACTER ), |
|
DEFINE_FIELD( lowResImageFormat, FIELD_INTEGER ), |
|
DEFINE_FIELD( lowResImageWidth, FIELD_CHARACTER ), |
|
DEFINE_FIELD( lowResImageHeight, FIELD_CHARACTER ), |
|
END_DATADESC() |
|
|
|
BEGIN_BYTESWAP_DATADESC( VTFFileHeaderV7_2_t ) |
|
DEFINE_ARRAY( fileTypeString, FIELD_CHARACTER, 4 ), |
|
DEFINE_ARRAY( version, FIELD_INTEGER, 2 ), |
|
DEFINE_FIELD( headerSize, FIELD_INTEGER ), |
|
DEFINE_FIELD( width, FIELD_SHORT ), |
|
DEFINE_FIELD( height, FIELD_SHORT ), |
|
DEFINE_FIELD( flags, FIELD_INTEGER ), |
|
DEFINE_FIELD( numFrames, FIELD_SHORT ), |
|
DEFINE_FIELD( startFrame, FIELD_SHORT ), |
|
DEFINE_FIELD( reflectivity, FIELD_VECTOR ), |
|
DEFINE_FIELD( bumpScale, FIELD_FLOAT ), |
|
DEFINE_FIELD( imageFormat, FIELD_INTEGER ), |
|
DEFINE_FIELD( numMipLevels, FIELD_CHARACTER ), |
|
DEFINE_FIELD( lowResImageFormat, FIELD_INTEGER ), |
|
DEFINE_FIELD( lowResImageWidth, FIELD_CHARACTER ), |
|
DEFINE_FIELD( lowResImageHeight, FIELD_CHARACTER ), |
|
DEFINE_FIELD( depth, FIELD_SHORT ), |
|
END_DATADESC() |
|
|
|
BEGIN_BYTESWAP_DATADESC( VTFFileHeaderV7_3_t ) |
|
DEFINE_ARRAY( fileTypeString, FIELD_CHARACTER, 4 ), |
|
DEFINE_ARRAY( version, FIELD_INTEGER, 2 ), |
|
DEFINE_FIELD( headerSize, FIELD_INTEGER ), |
|
DEFINE_FIELD( width, FIELD_SHORT ), |
|
DEFINE_FIELD( height, FIELD_SHORT ), |
|
DEFINE_FIELD( flags, FIELD_INTEGER ), |
|
DEFINE_FIELD( numFrames, FIELD_SHORT ), |
|
DEFINE_FIELD( startFrame, FIELD_SHORT ), |
|
DEFINE_FIELD( reflectivity, FIELD_VECTOR ), |
|
DEFINE_FIELD( bumpScale, FIELD_FLOAT ), |
|
DEFINE_FIELD( imageFormat, FIELD_INTEGER ), |
|
DEFINE_FIELD( numMipLevels, FIELD_CHARACTER ), |
|
DEFINE_FIELD( lowResImageFormat, FIELD_INTEGER ), |
|
DEFINE_FIELD( lowResImageWidth, FIELD_CHARACTER ), |
|
DEFINE_FIELD( lowResImageHeight, FIELD_CHARACTER ), |
|
DEFINE_FIELD( depth, FIELD_SHORT ), |
|
DEFINE_FIELD( numResources, FIELD_INTEGER ), |
|
END_DATADESC() |
|
|
|
BEGIN_BYTESWAP_DATADESC_( VTFFileHeaderX360_t, VTFFileBaseHeader_t ) |
|
DEFINE_FIELD( flags, FIELD_INTEGER ), |
|
DEFINE_FIELD( width, FIELD_SHORT ), |
|
DEFINE_FIELD( height, FIELD_SHORT ), |
|
DEFINE_FIELD( depth, FIELD_SHORT ), |
|
DEFINE_FIELD( numFrames, FIELD_SHORT ), |
|
DEFINE_FIELD( preloadDataSize, FIELD_SHORT ), |
|
DEFINE_FIELD( mipSkipCount, FIELD_CHARACTER ), |
|
DEFINE_FIELD( numResources, FIELD_CHARACTER ), |
|
DEFINE_FIELD( reflectivity, FIELD_VECTOR ), |
|
DEFINE_FIELD( bumpScale, FIELD_FLOAT ), |
|
DEFINE_FIELD( imageFormat, FIELD_INTEGER ), |
|
DEFINE_ARRAY( lowResImageSample, FIELD_CHARACTER, 4 ), |
|
DEFINE_FIELD( compressedSize, FIELD_INTEGER ), |
|
END_DATADESC() |
|
|
|
#if defined( POSIX ) || defined( _X360 ) |
|
// stub functions |
|
const char* S3TC_GetBlock( |
|
const void *pCompressed, |
|
ImageFormat format, |
|
int nBlocksWide, // How many blocks wide is the image (pixels wide / 4). |
|
int xBlock, |
|
int yBlock ) |
|
{ |
|
return NULL; |
|
} |
|
|
|
char* S3TC_GetBlock( |
|
void *pCompressed, |
|
ImageFormat format, |
|
int nBlocksWide, // How many blocks wide is the image (pixels wide / 4). |
|
int xBlock, |
|
int yBlock ) |
|
{ |
|
return NULL; |
|
} |
|
|
|
S3PaletteIndex S3TC_GetPaletteIndex( |
|
unsigned char *pFaceData, |
|
ImageFormat format, |
|
int imageWidth, |
|
int x, |
|
int y ) |
|
{ |
|
S3PaletteIndex nullPalette; |
|
memset(&nullPalette, 0x0, sizeof(nullPalette)); |
|
return nullPalette; |
|
} |
|
|
|
// Merge the two palettes and copy the colors |
|
void S3TC_MergeBlocks( |
|
char **blocks, |
|
S3RGBA **pOriginals, |
|
int nBlocks, |
|
int lPitch, // (in BYTES) |
|
ImageFormat format |
|
) |
|
{ |
|
} |
|
|
|
// Note: width, x, and y are in texels, not S3 blocks. |
|
void S3TC_SetPaletteIndex( |
|
unsigned char *pFaceData, |
|
ImageFormat format, |
|
int imageWidth, |
|
int x, |
|
int y, |
|
S3PaletteIndex paletteIndex ) |
|
{ |
|
} |
|
#endif |
|
|
|
// This gives a vertex number to each of the 4 verts on each face. |
|
// We use this to match the verts and determine which edges need to be blended together. |
|
// The vert ordering is lower-left, top-left, top-right, bottom-right. |
|
int g_leftFaceVerts[4] = { 2, 6, 7, 3 }; |
|
int g_frontFaceVerts[4] = { 2, 3, 5, 4 }; |
|
int g_downFaceVerts[4] = { 4, 0, 6, 2 }; |
|
int g_rightFaceVerts[4] = { 5, 1, 0, 4 }; |
|
int g_backFaceVerts[4] = { 7, 6, 0, 1 }; |
|
int g_upFaceVerts[4] = { 3, 7, 1, 5 }; |
|
|
|
int *g_FaceVerts[6] = |
|
{ |
|
g_rightFaceVerts, |
|
g_leftFaceVerts, |
|
g_backFaceVerts, |
|
g_frontFaceVerts, |
|
g_upFaceVerts, |
|
g_downFaceVerts |
|
}; |
|
|
|
// For skyboxes.. |
|
// These were constructed for the engine skybox, which looks like this |
|
// (assuming X goes forward, Y goes left, and Z goes up). |
|
// |
|
// 6 ------------- 5 |
|
// / / |
|
// / | / | |
|
// / | / | |
|
// 2 ------------- 1 | |
|
// | | |
|
// | | |
|
// | 7 ------|------ 4 |
|
// | / | / |
|
// | / | / |
|
// / / |
|
// 3 ------------- 0 |
|
// |
|
int g_skybox_rightFaceVerts[4] = { 7, 6, 5, 4 }; |
|
int g_skybox_leftFaceVerts[4] = { 0, 1, 2, 3 }; |
|
int g_skybox_backFaceVerts[4] = { 3, 2, 6, 7 }; |
|
int g_skybox_frontFaceVerts[4] = { 4, 5, 1, 0 }; |
|
int g_skybox_upFaceVerts[4] = { 6, 2, 1, 5 }; |
|
int g_skybox_downFaceVerts[4] = { 3, 7, 4, 0 }; |
|
|
|
int *g_skybox_FaceVerts[6] = |
|
{ |
|
g_skybox_rightFaceVerts, |
|
g_skybox_leftFaceVerts, |
|
g_skybox_backFaceVerts, |
|
g_skybox_frontFaceVerts, |
|
g_skybox_upFaceVerts, |
|
g_skybox_downFaceVerts |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Class factory |
|
//----------------------------------------------------------------------------- |
|
IVTFTexture *CreateVTFTexture() |
|
{ |
|
return new CVTFTexture; |
|
} |
|
|
|
void DestroyVTFTexture( IVTFTexture *pTexture ) |
|
{ |
|
CVTFTexture *pTex = static_cast<CVTFTexture*>(pTexture); |
|
if ( pTex ) |
|
{ |
|
delete pTex; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Allows us to only load in the first little bit of the VTF file to get info |
|
//----------------------------------------------------------------------------- |
|
int VTFFileHeaderSize( int nMajorVersion, int nMinorVersion ) |
|
{ |
|
if ( nMajorVersion == -1 ) |
|
{ |
|
nMajorVersion = VTF_MAJOR_VERSION; |
|
} |
|
|
|
if ( nMinorVersion == -1 ) |
|
{ |
|
nMinorVersion = VTF_MINOR_VERSION; |
|
} |
|
|
|
switch ( nMajorVersion ) |
|
{ |
|
case VTF_MAJOR_VERSION: |
|
switch ( nMinorVersion ) |
|
{ |
|
case 0: // fall through |
|
case 1: |
|
return sizeof( VTFFileHeaderV7_1_t ); |
|
case 2: |
|
return sizeof( VTFFileHeaderV7_2_t ); |
|
case 3: |
|
return sizeof( VTFFileHeaderV7_3_t ) + sizeof( ResourceEntryInfo ) * MAX_RSRC_DICTIONARY_ENTRIES; |
|
case 4: |
|
case VTF_MINOR_VERSION: |
|
int size1 = sizeof( VTFFileHeader_t ); |
|
int size2 = sizeof( ResourceEntryInfo ) * MAX_RSRC_DICTIONARY_ENTRIES; |
|
int result = size1 + size2; |
|
//printf("\n VTFFileHeaderSize (%i %i) is %i + %i -> %i",nMajorVersion,nMinorVersion, size1, size2, result ); |
|
return result; |
|
} |
|
break; |
|
|
|
case VTF_X360_MAJOR_VERSION: |
|
return sizeof( VTFFileHeaderX360_t ) + sizeof( ResourceEntryInfo ) * MAX_X360_RSRC_DICTIONARY_ENTRIES; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Constructor, destructor |
|
//----------------------------------------------------------------------------- |
|
CVTFTexture::CVTFTexture() |
|
{ |
|
m_nVersion[0] = 0; |
|
m_nVersion[1] = 0; |
|
|
|
m_nWidth = 0; |
|
m_nHeight = 0; |
|
m_nDepth = 1; |
|
m_Format = IMAGE_FORMAT_UNKNOWN; |
|
|
|
m_nMipCount = 0; |
|
m_nFaceCount = 0; |
|
m_nFrameCount = 0; |
|
|
|
// FIXME: Is the start frame needed? |
|
m_iStartFrame = 0; |
|
|
|
m_flAlphaThreshhold = -1.0f; |
|
m_flAlphaHiFreqThreshhold = -1.0f; |
|
|
|
m_flBumpScale = 1.0f; |
|
m_vecReflectivity.Init( 1.0, 1.0, 1.0f ); |
|
|
|
m_nFlags = 0; |
|
m_pImageData = NULL; |
|
m_nImageAllocSize = 0; |
|
|
|
// LowRes data |
|
m_LowResImageFormat = IMAGE_FORMAT_UNKNOWN; |
|
m_nLowResImageWidth = 0; |
|
m_nLowResImageHeight = 0; |
|
m_pLowResImageData = NULL; |
|
m_nLowResImageAllocSize = 0; |
|
|
|
#if defined( _X360 ) |
|
m_nMipSkipCount = 0; |
|
*(unsigned int *)m_LowResImageSample = 0; |
|
#endif |
|
|
|
Assert( m_arrResourcesInfo.Count() == 0 ); |
|
Assert( m_arrResourcesData.Count() == 0 ); |
|
Assert( m_arrResourcesData_ForReuse.Count() == 0 ); |
|
|
|
memset( &m_Options, 0, sizeof( m_Options ) ); |
|
m_Options.cbSize = sizeof( m_Options ); |
|
|
|
m_nFinestMipmapLevel = 0; |
|
m_nCoarsestMipmapLevel = 0; |
|
} |
|
|
|
CVTFTexture::~CVTFTexture() |
|
{ |
|
Shutdown(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Compute the mip count based on the size + flags |
|
//----------------------------------------------------------------------------- |
|
int CVTFTexture::ComputeMipCount() const |
|
{ |
|
if ( IsX360() && ( m_nVersion[0] == VTF_X360_MAJOR_VERSION ) && ( m_nFlags & TEXTUREFLAGS_NOMIP ) ) |
|
{ |
|
// 360 vtf format culled unused mips at conversion time |
|
return 1; |
|
} |
|
|
|
// NOTE: No matter what, all mip levels should be created because |
|
// we have to worry about various fallbacks |
|
return ImageLoader::GetNumMipMapLevels( m_nWidth, m_nHeight, m_nDepth ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Allocate data blocks with an eye toward re-using memory |
|
//----------------------------------------------------------------------------- |
|
|
|
static bool GenericAllocateReusableData( unsigned char **ppData, int *pNumAllocated, int numRequested ) |
|
{ |
|
// If we're asking for memory and we have way more than we expect, free some. |
|
if ( *pNumAllocated < numRequested || ( numRequested > 0 && *pNumAllocated > 16 * numRequested ) ) |
|
{ |
|
delete [] *ppData; |
|
*ppData = new unsigned char[ numRequested ]; |
|
if ( *ppData ) |
|
{ |
|
*pNumAllocated = numRequested; |
|
return true; |
|
} |
|
|
|
*pNumAllocated = 0; |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
bool CVTFTexture::AllocateImageData( int nMemorySize ) |
|
{ |
|
return GenericAllocateReusableData( &m_pImageData, &m_nImageAllocSize, nMemorySize ); |
|
} |
|
|
|
bool CVTFTexture::ResourceMemorySection::AllocateData( int nMemorySize ) |
|
{ |
|
if ( GenericAllocateReusableData( &m_pData, &m_nDataAllocSize, nMemorySize ) ) |
|
{ |
|
m_nDataLength = nMemorySize; |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
bool CVTFTexture::AllocateLowResImageData( int nMemorySize ) |
|
{ |
|
return GenericAllocateReusableData( &m_pLowResImageData, &m_nLowResImageAllocSize, nMemorySize ); |
|
} |
|
|
|
inline bool IsMultipleOf4( int value ) |
|
{ |
|
// NOTE: This catches powers of 2 less than 4 also |
|
return ( value <= 2 ) || ( (value & 0x3) == 0 ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Initialization |
|
//----------------------------------------------------------------------------- |
|
bool CVTFTexture::Init( int nWidth, int nHeight, int nDepth, ImageFormat fmt, int iFlags, int iFrameCount, int nForceMipCount ) |
|
{ |
|
if ( nDepth == 0 ) |
|
{ |
|
nDepth = 1; |
|
} |
|
|
|
if (iFlags & TEXTUREFLAGS_ENVMAP) |
|
{ |
|
if (nWidth != nHeight) |
|
{ |
|
Warning( "Height and width must be equal for cubemaps!\n" ); |
|
return false; |
|
} |
|
if (nDepth != 1) |
|
{ |
|
Warning( "Depth must be 1 for cubemaps!\n" ); |
|
return false; |
|
} |
|
} |
|
|
|
if ( ( fmt == IMAGE_FORMAT_DXT1 ) || ( fmt == IMAGE_FORMAT_DXT3 ) || ( fmt == IMAGE_FORMAT_DXT5 ) || |
|
( fmt == IMAGE_FORMAT_DXT1_RUNTIME ) || ( fmt == IMAGE_FORMAT_DXT5_RUNTIME ) ) |
|
{ |
|
if ( !IsMultipleOf4( nWidth ) || !IsMultipleOf4( nHeight ) || !IsMultipleOf4( nDepth ) ) |
|
{ |
|
Warning( "Image dimensions must be multiple of 4!\n" ); |
|
return false; |
|
} |
|
} |
|
|
|
if ( fmt == IMAGE_FORMAT_DEFAULT ) |
|
{ |
|
fmt = IMAGE_FORMAT_RGBA8888; |
|
} |
|
|
|
m_nWidth = nWidth; |
|
m_nHeight = nHeight; |
|
m_nDepth = nDepth; |
|
m_Format = fmt; |
|
m_nFlags = iFlags; |
|
|
|
// THIS CAUSED A BUG!!! We want all of the mip levels in the vtf file even with nomip in case we have lod. |
|
// NOTE: But we don't want more than 1 mip level for procedural textures |
|
if ( (iFlags & (TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_PROCEDURAL)) == (TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_PROCEDURAL) ) |
|
{ |
|
nForceMipCount = 1; |
|
} |
|
|
|
if ( nForceMipCount == -1 ) |
|
{ |
|
m_nMipCount = ComputeMipCount(); |
|
} |
|
else |
|
{ |
|
m_nMipCount = nForceMipCount; |
|
} |
|
|
|
m_nFrameCount = iFrameCount; |
|
|
|
m_nFaceCount = (iFlags & TEXTUREFLAGS_ENVMAP) ? CUBEMAP_FACE_COUNT : 1; |
|
|
|
#if defined( _X360 ) |
|
m_nMipSkipCount = 0; |
|
#endif |
|
|
|
// Need to do this because Shutdown deallocates the low-res image |
|
m_nLowResImageWidth = m_nLowResImageHeight = 0; |
|
|
|
// Allocate me some bits! |
|
int iMemorySize = ComputeTotalSize(); |
|
if ( !AllocateImageData( iMemorySize ) ) |
|
return false; |
|
|
|
// As soon as we have image indicate so in the resources |
|
if ( iMemorySize ) |
|
FindOrCreateResourceEntryInfo( VTF_LEGACY_RSRC_IMAGE ); |
|
else |
|
RemoveResourceEntryInfo( VTF_LEGACY_RSRC_IMAGE ); |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Methods to initialize the low-res image |
|
//----------------------------------------------------------------------------- |
|
void CVTFTexture::InitLowResImage( int nWidth, int nHeight, ImageFormat fmt ) |
|
{ |
|
m_nLowResImageWidth = nWidth; |
|
m_nLowResImageHeight = nHeight; |
|
m_LowResImageFormat = fmt; |
|
|
|
// Allocate low-res bits |
|
int iLowResImageSize = ImageLoader::GetMemRequired( m_nLowResImageWidth, |
|
m_nLowResImageHeight, 1, m_LowResImageFormat, false ); |
|
|
|
if ( !AllocateLowResImageData( iLowResImageSize ) ) |
|
return; |
|
|
|
// As soon as we have low-res image indicate so in the resources |
|
if ( iLowResImageSize ) |
|
FindOrCreateResourceEntryInfo( VTF_LEGACY_RSRC_LOW_RES_IMAGE ); |
|
else |
|
RemoveResourceEntryInfo( VTF_LEGACY_RSRC_LOW_RES_IMAGE ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Methods to set other texture fields |
|
//----------------------------------------------------------------------------- |
|
void CVTFTexture::SetBumpScale( float flScale ) |
|
{ |
|
m_flBumpScale = flScale; |
|
} |
|
|
|
void CVTFTexture::SetReflectivity( const Vector &vecReflectivity ) |
|
{ |
|
VectorCopy( vecReflectivity, m_vecReflectivity ); |
|
} |
|
|
|
// Sets threshhold values for alphatest mipmapping |
|
void CVTFTexture::SetAlphaTestThreshholds( float flBase, float flHighFreq ) |
|
{ |
|
m_flAlphaThreshhold = flBase; |
|
m_flAlphaHiFreqThreshhold = flHighFreq; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Release and reset the resources. |
|
//----------------------------------------------------------------------------- |
|
void CVTFTexture::ReleaseResources() |
|
{ |
|
m_arrResourcesInfo.RemoveAll(); |
|
|
|
for ( ResourceMemorySection *pRms = m_arrResourcesData.Base(), |
|
*pRmsEnd = pRms + m_arrResourcesData.Count(); pRms < pRmsEnd; ++pRms ) |
|
{ |
|
delete [] pRms->m_pData; |
|
} |
|
m_arrResourcesData.RemoveAll(); |
|
|
|
for ( ResourceMemorySection *pRms = m_arrResourcesData_ForReuse.Base(), |
|
*pRmsEnd = pRms + m_arrResourcesData_ForReuse.Count(); pRms < pRmsEnd; ++pRms ) |
|
{ |
|
delete [] pRms->m_pData; |
|
} |
|
m_arrResourcesData_ForReuse.RemoveAll(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Shutdown |
|
//----------------------------------------------------------------------------- |
|
void CVTFTexture::Shutdown() |
|
{ |
|
#if defined( _X360 ) |
|
// must be first to ensure X360 aliased pointers are unhooked, otherwise memory corruption |
|
ReleaseImageMemory(); |
|
#endif |
|
|
|
delete[] m_pImageData; |
|
m_pImageData = NULL; |
|
m_nImageAllocSize = 0; |
|
|
|
delete[] m_pLowResImageData; |
|
m_pLowResImageData = NULL; |
|
m_nLowResImageAllocSize = 0; |
|
|
|
ReleaseResources(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// These are methods to help with optimization of file access |
|
//----------------------------------------------------------------------------- |
|
void CVTFTexture::LowResFileInfo( int *pStartLocation, int *pSizeInBytes ) const |
|
{ |
|
// Once the header is read in, they indicate where to start reading |
|
// other data, and how many bytes to read.... |
|
|
|
if ( ResourceEntryInfo const *pLowResData = FindResourceEntryInfo( VTF_LEGACY_RSRC_LOW_RES_IMAGE ) ) |
|
{ |
|
*pStartLocation = pLowResData->resData; |
|
*pSizeInBytes = ImageLoader::GetMemRequired( m_nLowResImageWidth, |
|
m_nLowResImageHeight, 1, m_LowResImageFormat, false ); |
|
} |
|
else |
|
{ |
|
*pStartLocation = 0; |
|
*pSizeInBytes = 0; |
|
} |
|
} |
|
|
|
void CVTFTexture::ImageFileInfo( int nFrame, int nFace, int nMipLevel, int *pStartLocation, int *pSizeInBytes) const |
|
{ |
|
int i; |
|
int iMipWidth; |
|
int iMipHeight; |
|
int iMipDepth; |
|
|
|
ResourceEntryInfo const *pImageDataInfo = FindResourceEntryInfo( VTF_LEGACY_RSRC_IMAGE ); |
|
|
|
if ( pImageDataInfo == NULL ) |
|
{ |
|
// This should never happen for real, but can happen if someone intentionally fed us a bad VTF. |
|
Assert( pImageDataInfo ); |
|
( *pStartLocation ) = 0; |
|
( *pSizeInBytes ) = 0; |
|
return; |
|
} |
|
|
|
// The image data start offset |
|
int nOffset = pImageDataInfo->resData; |
|
|
|
// get to the right miplevel |
|
for( i = m_nMipCount - 1; i > nMipLevel; --i ) |
|
{ |
|
ComputeMipLevelDimensions( i, &iMipWidth, &iMipHeight, &iMipDepth ); |
|
int iMipLevelSize = ImageLoader::GetMemRequired( iMipWidth, iMipHeight, iMipDepth, m_Format, false ); |
|
nOffset += iMipLevelSize * m_nFrameCount * m_nFaceCount; |
|
} |
|
|
|
// get to the right frame |
|
ComputeMipLevelDimensions( nMipLevel, &iMipWidth, &iMipHeight, &iMipDepth ); |
|
int nFaceSize = ImageLoader::GetMemRequired( iMipWidth, iMipHeight, iMipDepth, m_Format, false ); |
|
|
|
// For backwards compatibility, we don't read in the spheremap fallback on |
|
// older format .VTF files... |
|
int nFacesToRead = m_nFaceCount; |
|
if ( IsCubeMap() ) |
|
{ |
|
if ((m_nVersion[0] == 7) && (m_nVersion[1] < 1 || m_nVersion[1] > 4)) |
|
{ |
|
nFacesToRead = 6; |
|
if (nFace == CUBEMAP_FACE_SPHEREMAP) |
|
{ |
|
--nFace; |
|
} |
|
} |
|
} |
|
|
|
int nFrameSize = nFacesToRead * nFaceSize; |
|
nOffset += nFrameSize * nFrame; |
|
|
|
// get to the right face |
|
nOffset += nFace * nFaceSize; |
|
|
|
*pStartLocation = nOffset; |
|
*pSizeInBytes = nFaceSize; |
|
} |
|
|
|
int CVTFTexture::FileSize( int nMipSkipCount ) const |
|
{ |
|
ResourceEntryInfo const *pImageDataInfo = FindResourceEntryInfo( VTF_LEGACY_RSRC_IMAGE ); |
|
|
|
// Can be null when someone gives us an intentionally malformed VTF. |
|
if ( pImageDataInfo == NULL ) |
|
{ |
|
// Still do the assert so we can catch this in debug--we don't expect this for well formed files. |
|
Assert( pImageDataInfo != NULL ); |
|
return 0; |
|
} |
|
|
|
int nOffset = pImageDataInfo->resData; |
|
|
|
int nFaceSize = ComputeFaceSize( nMipSkipCount ); |
|
int nImageSize = nFaceSize * m_nFaceCount * m_nFrameCount; |
|
return nOffset + nImageSize; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Unserialization of low-res data |
|
//----------------------------------------------------------------------------- |
|
bool CVTFTexture::LoadLowResData( CUtlBuffer &buf ) |
|
{ |
|
// Allocate low-res bits |
|
InitLowResImage( m_nLowResImageWidth, m_nLowResImageHeight, m_LowResImageFormat ); |
|
int nLowResImageSize = ImageLoader::GetMemRequired( m_nLowResImageWidth, |
|
m_nLowResImageHeight, 1, m_LowResImageFormat, false ); |
|
buf.Get( m_pLowResImageData, nLowResImageSize ); |
|
|
|
bool bValid = buf.IsValid(); |
|
|
|
return bValid; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Unserialization of image data |
|
//----------------------------------------------------------------------------- |
|
bool CVTFTexture::LoadImageData( CUtlBuffer &buf, const VTFFileHeader_t &header, int nSkipMipLevels ) |
|
{ |
|
// Fix up the mip count + size based on how many mip levels we skip... |
|
if (nSkipMipLevels > 0) |
|
{ |
|
Assert( m_nMipCount > nSkipMipLevels ); |
|
if (header.numMipLevels < nSkipMipLevels) |
|
{ |
|
// NOTE: This can only happen with older format .vtf files |
|
Warning("Warning! Encountered old format VTF file; please rebuild it!\n"); |
|
return false; |
|
} |
|
|
|
ComputeMipLevelDimensions( nSkipMipLevels, &m_nWidth, &m_nHeight, &m_nDepth ); |
|
m_nMipCount -= nSkipMipLevels; |
|
} |
|
|
|
// read the texture image (including mipmaps if they are there and needed.) |
|
int iImageSize = ComputeFaceSize(); |
|
iImageSize *= m_nFaceCount * m_nFrameCount; |
|
|
|
if ( !AllocateImageData( iImageSize ) ) |
|
return false; |
|
|
|
// NOTE: The mip levels are stored ascending from smallest (1x1) to largest (NxN) |
|
// in order to allow for truncated reads of the minimal required data |
|
|
|
// NOTE: I checked in a bad version 4 where it stripped out the spheremap. |
|
// To make it all work, need to check for that bad case. |
|
bool bNoSkip = false; |
|
if ( IsCubeMap() && ( header.version[0] == 7 ) && ( header.version[1] == 4 ) ) |
|
{ |
|
int nBytesRemaining = buf.TellMaxPut() - buf.TellGet(); |
|
int nFileSize = ComputeFaceSize( nSkipMipLevels ) * m_nFaceCount * m_nFrameCount; |
|
if ( nBytesRemaining == nFileSize ) |
|
{ |
|
bNoSkip = true; |
|
} |
|
} |
|
|
|
int nGet = buf.TellGet(); |
|
|
|
retryCubemapLoad: |
|
for (int iMip = m_nMipCount; --iMip >= 0; ) |
|
{ |
|
// NOTE: This is for older versions... |
|
if ( header.numMipLevels - nSkipMipLevels <= iMip ) |
|
continue; |
|
|
|
int iMipSize = ComputeMipSize( iMip ); |
|
|
|
for (int iFrame = 0; iFrame < m_nFrameCount; ++iFrame) |
|
{ |
|
for (int iFace = 0; iFace < m_nFaceCount; ++iFace) |
|
{ |
|
// printf("\n tex %p mip %i frame %i face %i size %i buf offset %i", this, iMip, iFrame, iFace, iMipSize, buf.TellGet() ); |
|
unsigned char *pMipBits = ImageData( iFrame, iFace, iMip ); |
|
buf.Get( pMipBits, iMipSize ); |
|
} |
|
|
|
// Strip out the spheremap in older versions |
|
if ( IsCubeMap() && !bNoSkip && ( header.version[0] == 7 ) && ( header.version[1] >= 1 ) && ( header.version[1] < 5 ) ) |
|
{ |
|
buf.SeekGet( CUtlBuffer::SEEK_CURRENT, iMipSize ); |
|
} |
|
} |
|
} |
|
|
|
bool bOk = buf.IsValid(); |
|
if ( !bOk && IsCubeMap() && ( header.version[0] == 7 ) && ( header.version[1] <= 4 ) ) |
|
{ |
|
if ( !bNoSkip ) |
|
{ |
|
bNoSkip = true; |
|
buf.SeekGet( CUtlBuffer::SEEK_HEAD, nGet ); |
|
goto retryCubemapLoad; |
|
} |
|
Warning( "** Encountered stale cubemap! Please rebuild the following vtf:\n" ); |
|
} |
|
return bOk; |
|
} |
|
|
|
void *CVTFTexture::SetResourceData( uint32 eType, void const *pData, size_t nNumBytes ) |
|
{ |
|
Assert( ( eType & RSRCF_MASK ) == 0 ); |
|
eType &= ~RSRCF_MASK; |
|
|
|
// Very inefficient to set less than 4 bytes of data |
|
Assert( !nNumBytes || ( nNumBytes >= sizeof( uint32 ) ) ); |
|
|
|
if ( nNumBytes ) |
|
{ |
|
ResourceEntryInfo *pInfo = FindOrCreateResourceEntryInfo( eType ); |
|
int idx = pInfo - m_arrResourcesInfo.Base(); |
|
ResourceMemorySection &rms = m_arrResourcesData[ idx ]; |
|
|
|
if ( nNumBytes == sizeof( pInfo->resData ) ) |
|
{ |
|
// store 4 bytes directly |
|
pInfo->eType |= RSRCF_HAS_NO_DATA_CHUNK; |
|
if ( pData ) |
|
pInfo->resData = reinterpret_cast< const int * >( pData )[0]; |
|
return &pInfo->resData; |
|
} |
|
else |
|
{ |
|
if ( !rms.AllocateData( nNumBytes ) ) |
|
{ |
|
RemoveResourceEntryInfo( eType ); |
|
return NULL; |
|
} |
|
|
|
if ( pData ) |
|
memcpy( rms.m_pData, pData, nNumBytes ); |
|
return rms.m_pData; |
|
} |
|
} |
|
else |
|
{ |
|
RemoveResourceEntryInfo( eType ); |
|
return NULL; |
|
} |
|
} |
|
|
|
void *CVTFTexture::GetResourceData( uint32 eType, size_t *pDataSize ) const |
|
{ |
|
Assert( ( eType & RSRCF_MASK ) == 0 ); |
|
eType &= ~RSRCF_MASK; |
|
|
|
ResourceEntryInfo const *pInfo = FindResourceEntryInfo( eType ); |
|
if ( pInfo ) |
|
{ |
|
if ( ( pInfo->eType & RSRCF_HAS_NO_DATA_CHUNK ) == 0 ) |
|
{ |
|
int idx = pInfo - m_arrResourcesInfo.Base(); |
|
ResourceMemorySection const &rms = m_arrResourcesData[ idx ]; |
|
if ( pDataSize ) |
|
{ |
|
*pDataSize = rms.m_nDataLength; |
|
} |
|
return rms.m_pData; |
|
} |
|
else |
|
{ |
|
if ( pDataSize ) |
|
{ |
|
*pDataSize = sizeof( pInfo->resData ); |
|
} |
|
return (void *)&pInfo->resData; |
|
} |
|
} |
|
else |
|
{ |
|
if ( pDataSize ) |
|
*pDataSize = 0; |
|
} |
|
|
|
return NULL; |
|
} |
|
|
|
bool CVTFTexture::HasResourceEntry( uint32 eType ) const |
|
{ |
|
return ( FindResourceEntryInfo( eType ) != NULL ); |
|
} |
|
|
|
unsigned int CVTFTexture::GetResourceTypes( unsigned int *arrTypesBuffer, int numTypesBufferElems ) const |
|
{ |
|
for ( ResourceEntryInfo const *pInfo = m_arrResourcesInfo.Base(), |
|
*pInfoEnd = pInfo + m_arrResourcesInfo.Count(); |
|
numTypesBufferElems-- > 0 && pInfo < pInfoEnd; ) |
|
{ |
|
*( arrTypesBuffer++ ) = ( ( pInfo++ )->eType & ~RSRCF_MASK ); |
|
} |
|
|
|
return m_arrResourcesInfo.Count(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Serialization/Unserialization of resource data |
|
//----------------------------------------------------------------------------- |
|
bool CVTFTexture::ResourceMemorySection::LoadData( CUtlBuffer &buf, CByteswap &byteSwap ) |
|
{ |
|
// Read the size |
|
int iDataSize = 0; |
|
buf.Get( &iDataSize, sizeof( iDataSize ) ); |
|
byteSwap.SwapBufferToTargetEndian( &iDataSize ); |
|
|
|
// Read the actual data |
|
if ( !AllocateData( iDataSize ) ) |
|
return false; |
|
|
|
buf.Get( m_pData, iDataSize ); |
|
|
|
// Test valid |
|
bool bValid = buf.IsValid(); |
|
|
|
return bValid; |
|
} |
|
|
|
bool CVTFTexture::ResourceMemorySection::WriteData( CUtlBuffer &buf ) const |
|
{ |
|
Assert( m_nDataLength && m_pData ); |
|
int iBufSize = m_nDataLength; |
|
|
|
buf.Put( &iBufSize, sizeof( iBufSize ) ); |
|
buf.Put( m_pData, m_nDataLength ); |
|
|
|
return buf.IsValid(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Checks if the file data needs to be swapped |
|
//----------------------------------------------------------------------------- |
|
bool CVTFTexture::SetupByteSwap( CUtlBuffer &buf ) |
|
{ |
|
VTFFileBaseHeader_t *header = (VTFFileBaseHeader_t*)buf.PeekGet(); |
|
|
|
if ( header->version[0] == SwapLong( VTF_MAJOR_VERSION ) ) |
|
{ |
|
m_Swap.ActivateByteSwapping( true ); |
|
return true; |
|
} |
|
return false; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Unserialization |
|
//----------------------------------------------------------------------------- |
|
static bool ReadHeaderFromBufferPastBaseHeader( CUtlBuffer &buf, VTFFileHeader_t &header ) |
|
{ |
|
unsigned char *pBuf = (unsigned char*)(&header) + sizeof(VTFFileBaseHeader_t); |
|
if ( header.version[1] <= VTF_MINOR_VERSION && header.version[1] >= 4 ) |
|
{ |
|
buf.Get( pBuf, sizeof(VTFFileHeader_t) - sizeof(VTFFileBaseHeader_t) ); |
|
} |
|
else if ( header.version[1] == 3 ) |
|
{ |
|
buf.Get( pBuf, sizeof(VTFFileHeaderV7_3_t) - sizeof(VTFFileBaseHeader_t) ); |
|
} |
|
else if ( header.version[1] == 2 ) |
|
{ |
|
buf.Get( pBuf, sizeof(VTFFileHeaderV7_2_t) - sizeof(VTFFileBaseHeader_t) ); |
|
} |
|
else if ( header.version[1] == 1 || header.version[1] == 0 ) |
|
{ |
|
// previous version 7.0 or 7.1 |
|
buf.Get( pBuf, sizeof(VTFFileHeaderV7_1_t) - sizeof(VTFFileBaseHeader_t) ); |
|
} |
|
else |
|
{ |
|
Warning( "*** Encountered VTF file with an invalid minor version!\n" ); |
|
return false; |
|
} |
|
|
|
return buf.IsValid(); |
|
} |
|
|
|
bool CVTFTexture::ReadHeader( CUtlBuffer &buf, VTFFileHeader_t &header ) |
|
{ |
|
if ( IsX360() && SetupByteSwap( buf ) ) |
|
{ |
|
VTFFileBaseHeader_t baseHeader; |
|
m_Swap.SwapFieldsToTargetEndian( &baseHeader, (VTFFileBaseHeader_t*)buf.PeekGet() ); |
|
|
|
// Swap the header inside the UtlBuffer |
|
if ( baseHeader.version[0] == VTF_MAJOR_VERSION ) |
|
{ |
|
if ( baseHeader.version[1] == 0 || baseHeader.version[1] == 1 ) |
|
{ |
|
// version 7.0 or 7.1 |
|
m_Swap.SwapFieldsToTargetEndian( (VTFFileHeaderV7_1_t*)buf.PeekGet() ); |
|
} |
|
else if ( baseHeader.version[1] == 2 ) |
|
{ |
|
// version 7.2 |
|
m_Swap.SwapFieldsToTargetEndian( (VTFFileHeaderV7_2_t*)buf.PeekGet() ); |
|
} |
|
else if ( baseHeader.version[1] == 3 ) |
|
{ |
|
m_Swap.SwapFieldsToTargetEndian( (VTFFileHeaderV7_3_t*)buf.PeekGet() ); |
|
} |
|
else if ( baseHeader.version[1] >= 4 && baseHeader.version[1] <= VTF_MINOR_VERSION ) |
|
{ |
|
m_Swap.SwapFieldsToTargetEndian( (VTFFileHeader_t*)buf.PeekGet() ); |
|
} |
|
} |
|
} |
|
|
|
memset( &header, 0, sizeof(VTFFileHeader_t) ); |
|
buf.Get( &header, sizeof(VTFFileBaseHeader_t) ); |
|
if ( !buf.IsValid() ) |
|
{ |
|
Warning( "*** Error unserializing VTF file... is the file empty?\n" ); |
|
return false; |
|
} |
|
|
|
// Validity check |
|
if ( Q_strncmp( header.fileTypeString, "VTF", 4 ) ) |
|
{ |
|
Warning( "*** Tried to load a non-VTF file as a VTF file!\n" ); |
|
return false; |
|
} |
|
|
|
if ( header.version[0] != VTF_MAJOR_VERSION ) |
|
{ |
|
Warning( "*** Encountered VTF file with an invalid version!\n" ); |
|
return false; |
|
} |
|
|
|
if ( !ReadHeaderFromBufferPastBaseHeader( buf, header ) ) |
|
{ |
|
Warning( "*** Encountered VTF file with an invalid full header!\n" ); |
|
return false; |
|
} |
|
|
|
// version fixups |
|
switch ( header.version[1] ) |
|
{ |
|
case 0: |
|
case 1: |
|
header.depth = 1; |
|
// fall-through |
|
case 2: |
|
header.numResources = 0; |
|
// fall-through |
|
case 3: |
|
header.flags &= VERSIONED_VTF_FLAGS_MASK_7_3; |
|
// fall-through |
|
case 4: |
|
case VTF_MINOR_VERSION: |
|
break; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Unserialization |
|
//----------------------------------------------------------------------------- |
|
bool CVTFTexture::Unserialize( CUtlBuffer &buf, bool bHeaderOnly, int nSkipMipLevels ) |
|
{ |
|
return UnserializeEx( buf, bHeaderOnly, 0, nSkipMipLevels ); |
|
} |
|
|
|
bool CVTFTexture::UnserializeEx( CUtlBuffer &buf, bool bHeaderOnly, int nForceFlags, int nSkipMipLevels ) |
|
{ |
|
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s (header only: %d, nForceFlags: %d, skipMips: %d)", __FUNCTION__, bHeaderOnly ? 1 : 0, nForceFlags, nSkipMipLevels ); |
|
|
|
// When unserializing, we can skip a certain number of mip levels, |
|
// and we also can just load everything but the image data |
|
VTFFileHeader_t header; |
|
|
|
if ( !ReadHeader( buf, header ) ) |
|
return false; |
|
|
|
// Pretend these flags are also set. |
|
header.flags |= nForceFlags; |
|
|
|
if ( (header.flags & TEXTUREFLAGS_ENVMAP) && (header.width != header.height) ) |
|
{ |
|
Warning( "*** Encountered VTF non-square cubemap!\n" ); |
|
return false; |
|
} |
|
if ( (header.flags & TEXTUREFLAGS_ENVMAP) && (header.depth != 1) ) |
|
{ |
|
Warning( "*** Encountered VTF volume texture cubemap!\n" ); |
|
return false; |
|
} |
|
if ( header.width <= 0 || header.height <= 0 || header.depth <= 0 ) |
|
{ |
|
Warning( "*** Encountered VTF invalid texture size!\n" ); |
|
return false; |
|
} |
|
if ( ( header.imageFormat < IMAGE_FORMAT_UNKNOWN ) || ( header.imageFormat >= NUM_IMAGE_FORMATS ) ) |
|
{ |
|
Warning( "*** Encountered VTF invalid image format!\n" ); |
|
return false; |
|
} |
|
|
|
// If the header says we should be doing a texture allocation of more than 32M, just tell the caller we failed. |
|
const int cMaxImageSizeLog2 = Q_log2( 32 * 1024 * 1024 ); |
|
if ( ( Q_log2( header.width ) + Q_log2( header.height ) + Q_log2( header.depth ) + Q_log2( header.numFrames ) > cMaxImageSizeLog2 ) || ( header.numResources > MAX_RSRC_DICTIONARY_ENTRIES ) ) |
|
{ |
|
STAGING_ONLY_EXEC( DevWarning( "Asked for a large texture to be created (%d h x %d w x %d d x %d f). Nope.\n", header.width, header.height, header.depth, header.numFrames ) ); |
|
return false; |
|
} |
|
|
|
m_nWidth = header.width; |
|
m_nHeight = header.height; |
|
m_nDepth = header.depth; |
|
m_Format = header.imageFormat; |
|
m_nFlags = header.flags; |
|
m_nFrameCount = header.numFrames; |
|
|
|
|
|
m_nFaceCount = (m_nFlags & TEXTUREFLAGS_ENVMAP) ? CUBEMAP_FACE_COUNT : 1; |
|
|
|
// NOTE: We're going to store space for all mip levels, even if we don't |
|
// have data on disk for them. This is for backward compatibility |
|
m_nMipCount = ComputeMipCount(); |
|
|
|
m_nFinestMipmapLevel = 0; |
|
m_nCoarsestMipmapLevel = m_nMipCount - 1; |
|
|
|
m_vecReflectivity = header.reflectivity; |
|
m_flBumpScale = header.bumpScale; |
|
|
|
// FIXME: Why is this needed? |
|
m_iStartFrame = header.startFrame; |
|
|
|
// This is to make sure old-format .vtf files are read properly |
|
m_nVersion[0] = header.version[0]; |
|
m_nVersion[1] = header.version[1]; |
|
|
|
if ( header.lowResImageWidth == 0 || header.lowResImageHeight == 0 ) |
|
{ |
|
m_nLowResImageWidth = 0; |
|
m_nLowResImageHeight = 0; |
|
} |
|
else |
|
{ |
|
m_nLowResImageWidth = header.lowResImageWidth; |
|
m_nLowResImageHeight = header.lowResImageHeight; |
|
} |
|
m_LowResImageFormat = header.lowResImageFormat; |
|
|
|
// invalid image format |
|
if ( ( m_LowResImageFormat < IMAGE_FORMAT_UNKNOWN ) || ( m_LowResImageFormat >= NUM_IMAGE_FORMATS ) ) |
|
return false; |
|
|
|
// Keep the allocated memory chunks of data |
|
if ( int( header.numResources ) < m_arrResourcesData.Count() ) |
|
{ |
|
m_arrResourcesData_ForReuse.EnsureCapacity( m_arrResourcesData_ForReuse.Count() + m_arrResourcesData.Count() - header.numResources ); |
|
for ( ResourceMemorySection const *pRms = &m_arrResourcesData[ header.numResources ], |
|
*pRmsEnd = m_arrResourcesData.Base() + m_arrResourcesData.Count(); pRms < pRmsEnd; ++ pRms ) |
|
{ |
|
if ( pRms->m_pData ) |
|
{ |
|
int idxReuse = m_arrResourcesData_ForReuse.AddToTail( *pRms ); |
|
m_arrResourcesData_ForReuse[ idxReuse ].m_nDataLength = 0; // Data for reuse shouldn't have length set |
|
} |
|
} |
|
} |
|
m_arrResourcesData.SetCount( header.numResources ); |
|
|
|
// Read the dictionary of resources info |
|
if ( header.numResources > 0 ) |
|
{ |
|
m_arrResourcesInfo.RemoveAll(); |
|
m_arrResourcesInfo.SetCount( header.numResources ); |
|
|
|
buf.Get( m_arrResourcesInfo.Base(), m_arrResourcesInfo.Count() * sizeof( ResourceEntryInfo ) ); |
|
if ( !buf.IsValid() ) |
|
return false; |
|
|
|
if ( IsX360() ) |
|
{ |
|
// Byte-swap the dictionary data offsets |
|
for ( int k = 0; k < m_arrResourcesInfo.Count(); ++ k ) |
|
{ |
|
ResourceEntryInfo &rei = m_arrResourcesInfo[k]; |
|
if ( ( rei.eType & RSRCF_HAS_NO_DATA_CHUNK ) == 0 ) |
|
{ |
|
m_Swap.SwapBufferToTargetEndian( &rei.resData ); |
|
} |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
// Older version (7.0 - 7.2): |
|
// - low-res image data first (optional) |
|
// - then image data |
|
m_arrResourcesInfo.RemoveAll(); |
|
|
|
// Low-res image data |
|
int nLowResImageSize = ImageLoader::GetMemRequired( m_nLowResImageWidth, |
|
m_nLowResImageHeight, 1, m_LowResImageFormat, false ); |
|
if ( nLowResImageSize ) |
|
{ |
|
ResourceEntryInfo &rei = *FindOrCreateResourceEntryInfo( VTF_LEGACY_RSRC_LOW_RES_IMAGE ); |
|
rei.resData = buf.TellGet(); |
|
} |
|
|
|
// Image data |
|
ResourceEntryInfo &rei = *FindOrCreateResourceEntryInfo( VTF_LEGACY_RSRC_IMAGE ); |
|
rei.resData = buf.TellGet() + nLowResImageSize; |
|
} |
|
|
|
// Caller wants the header component only, avoids reading large image data sets |
|
if ( bHeaderOnly ) |
|
return true; |
|
|
|
// Load the low res image |
|
if ( ResourceEntryInfo const *pLowResDataInfo = FindResourceEntryInfo( VTF_LEGACY_RSRC_LOW_RES_IMAGE ) ) |
|
{ |
|
buf.SeekGet( CUtlBuffer::SEEK_HEAD, pLowResDataInfo->resData ); |
|
if ( !LoadLowResData( buf ) ) |
|
return false; |
|
} |
|
|
|
// Load any new resources |
|
if ( !LoadNewResources( buf ) ) |
|
{ |
|
return false; |
|
} |
|
|
|
// Load the image data |
|
if ( ResourceEntryInfo const *pImageDataInfo = FindResourceEntryInfo( VTF_LEGACY_RSRC_IMAGE ) ) |
|
{ |
|
buf.SeekGet( CUtlBuffer::SEEK_HEAD, pImageDataInfo->resData ); |
|
if ( !LoadImageData( buf, header, nSkipMipLevels ) ) |
|
return false; |
|
} |
|
else |
|
{ |
|
// No image data |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
void CVTFTexture::GetMipmapRange( int* pOutFinest, int* pOutCoarsest ) |
|
{ |
|
if ( pOutFinest ) |
|
*pOutFinest = m_nFinestMipmapLevel; |
|
|
|
if ( pOutCoarsest ) |
|
*pOutCoarsest = m_nCoarsestMipmapLevel; |
|
} |
|
|
|
bool CVTFTexture::LoadNewResources( CUtlBuffer &buf ) |
|
{ |
|
// Load the new resources |
|
for ( int idxRsrc = 0; idxRsrc < m_arrResourcesInfo.Count(); ++idxRsrc ) |
|
{ |
|
ResourceEntryInfo &rei = m_arrResourcesInfo[ idxRsrc ]; |
|
ResourceMemorySection &rms = m_arrResourcesData[ idxRsrc ]; |
|
|
|
if ( ( rei.eType & RSRCF_HAS_NO_DATA_CHUNK ) == 0 ) |
|
{ |
|
switch( rei.eType ) |
|
{ |
|
case VTF_LEGACY_RSRC_LOW_RES_IMAGE: |
|
case VTF_LEGACY_RSRC_IMAGE: |
|
// these legacy resources are loaded differently |
|
continue; |
|
|
|
default: |
|
buf.SeekGet( CUtlBuffer::SEEK_HEAD, rei.resData ); |
|
if ( !rms.LoadData( buf, m_Swap ) ) |
|
return false; |
|
} |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
|
|
ResourceEntryInfo const *CVTFTexture::FindResourceEntryInfo( uint32 eType ) const |
|
{ |
|
Assert( ( eType & RSRCF_MASK ) == 0 ); |
|
|
|
ResourceEntryInfo const *pRange[2]; |
|
pRange[0] = m_arrResourcesInfo.Base(); |
|
pRange[1] = pRange[0] + m_arrResourcesInfo.Count(); |
|
|
|
if ( IsPC() ) |
|
{ |
|
// Quick-search in a sorted array |
|
ResourceEntryInfo const *pMid; |
|
find_routine: |
|
if ( pRange[0] != pRange[1] ) |
|
{ |
|
pMid = pRange[0] + ( pRange[1] - pRange[0] ) / 2; |
|
if ( int diff = int( pMid->eType & ~RSRCF_MASK ) - int( eType ) ) |
|
{ |
|
int off = !( diff > 0 ); |
|
pRange[ !off ] = pMid + off; |
|
goto find_routine; |
|
} |
|
else |
|
return pMid; |
|
} |
|
else |
|
return NULL; |
|
} |
|
else |
|
{ |
|
// 360 eschews a sorted format due to endian issues |
|
// use a linear search for compatibility with reading pc formats |
|
for ( ; pRange[0] < pRange[1]; ++pRange[0] ) |
|
{ |
|
if ( ( pRange[0]->eType & ~RSRCF_MASK ) == eType ) |
|
return pRange[0]; |
|
} |
|
} |
|
|
|
return NULL; |
|
} |
|
|
|
ResourceEntryInfo * CVTFTexture::FindResourceEntryInfo( uint32 eType ) |
|
{ |
|
return const_cast< ResourceEntryInfo * >( |
|
( ( CVTFTexture const * ) this )->FindResourceEntryInfo( eType ) ); |
|
} |
|
|
|
ResourceEntryInfo * CVTFTexture::FindOrCreateResourceEntryInfo( uint32 eType ) |
|
{ |
|
Assert( ( eType & RSRCF_MASK ) == 0 ); |
|
|
|
int k = 0; |
|
for ( ; k < m_arrResourcesInfo.Count(); ++ k ) |
|
{ |
|
uint32 rsrcType = ( m_arrResourcesInfo[ k ].eType & ~RSRCF_MASK ); |
|
if ( rsrcType == eType ) |
|
{ |
|
// found |
|
return &m_arrResourcesInfo[ k ]; |
|
} |
|
|
|
// sort for PC only, 360 uses linear sort for compatibility with PC endian |
|
if ( IsPC() ) |
|
{ |
|
if ( rsrcType > eType ) |
|
break; |
|
} |
|
} |
|
|
|
ResourceEntryInfo rei; |
|
memset( &rei, 0, sizeof( rei ) ); |
|
rei.eType = eType; |
|
|
|
// Inserting before "k" |
|
if ( m_arrResourcesData_ForReuse.Count() ) |
|
{ |
|
m_arrResourcesData.InsertBefore( k, m_arrResourcesData_ForReuse[ m_arrResourcesData_ForReuse.Count() - 1 ] ); |
|
m_arrResourcesData_ForReuse.FastRemove( m_arrResourcesData_ForReuse.Count() - 1 ); |
|
} |
|
else |
|
{ |
|
m_arrResourcesData.InsertBefore( k ); |
|
} |
|
|
|
m_arrResourcesInfo.InsertBefore( k, rei ); |
|
return &m_arrResourcesInfo[k]; |
|
} |
|
|
|
bool CVTFTexture::RemoveResourceEntryInfo( uint32 eType ) |
|
{ |
|
Assert( ( eType & RSRCF_MASK ) == 0 ); |
|
|
|
for ( int k = 0; k < m_arrResourcesInfo.Count(); ++ k ) |
|
{ |
|
if ( ( m_arrResourcesInfo[ k ].eType & ~RSRCF_MASK ) == eType ) |
|
{ |
|
m_arrResourcesInfo.Remove( k ); |
|
|
|
if ( m_arrResourcesData[k].m_pData ) |
|
{ |
|
int idxReuse = m_arrResourcesData_ForReuse.AddToTail( m_arrResourcesData[k] ); |
|
m_arrResourcesData_ForReuse[ idxReuse ].m_nDataLength = 0; // Data for reuse shouldn't have length set |
|
} |
|
|
|
m_arrResourcesData.Remove( k ); |
|
|
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Serialization of image data |
|
//----------------------------------------------------------------------------- |
|
bool CVTFTexture::WriteImageData( CUtlBuffer &buf ) |
|
{ |
|
// NOTE: We load the bits this way because we store the bits in memory |
|
// differently that the way they are stored on disk; we store on disk |
|
// differently so we can only load up |
|
// NOTE: The smallest mip levels are stored first!! |
|
for (int iMip = m_nMipCount; --iMip >= 0; ) |
|
{ |
|
int iMipSize = ComputeMipSize( iMip ); |
|
|
|
for (int iFrame = 0; iFrame < m_nFrameCount; ++iFrame) |
|
{ |
|
for (int iFace = 0; iFace < m_nFaceCount; ++iFace) |
|
{ |
|
unsigned char *pMipBits = ImageData( iFrame, iFace, iMip ); |
|
buf.Put( pMipBits, iMipSize ); |
|
} |
|
} |
|
} |
|
|
|
return buf.IsValid(); |
|
} |
|
|
|
// Inserts padding to have a multiple of "iAlignment" bytes in the buffer |
|
// Returns number of pad bytes written |
|
static int PadBuffer( CUtlBuffer &buf, int iAlignment ) |
|
{ |
|
unsigned int uiCurrentBytes = buf.TellPut(); |
|
int iPadBytes = AlignValue( uiCurrentBytes, iAlignment ) - uiCurrentBytes; |
|
|
|
// Fill data |
|
for ( int i=0; i<iPadBytes; i++ ) |
|
{ |
|
buf.PutChar( '\0' ); |
|
} |
|
|
|
buf.SeekPut( CUtlBuffer::SEEK_HEAD, uiCurrentBytes + iPadBytes ); |
|
|
|
return iPadBytes; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Serialization |
|
//----------------------------------------------------------------------------- |
|
bool CVTFTexture::Serialize( CUtlBuffer &buf ) |
|
{ |
|
if ( IsX360() ) |
|
{ |
|
// Unsupported path, 360 has no reason and cannot serialize |
|
Assert( 0 ); |
|
return false; |
|
} |
|
|
|
if ( !m_pImageData ) |
|
{ |
|
Warning("*** Unable to serialize... have no image data!\n"); |
|
return false; |
|
} |
|
|
|
VTFFileHeader_t header; |
|
memset( &header, 0, sizeof( header ) ); |
|
Q_strncpy( header.fileTypeString, "VTF", 4 ); |
|
header.version[0] = VTF_MAJOR_VERSION; |
|
header.version[1] = VTF_MINOR_VERSION; |
|
header.headerSize = sizeof(VTFFileHeader_t) + m_arrResourcesInfo.Count() * sizeof( ResourceEntryInfo ); |
|
|
|
header.width = m_nWidth; |
|
header.height = m_nHeight; |
|
header.depth = m_nDepth; |
|
header.flags = m_nFlags; |
|
header.numFrames = m_nFrameCount; |
|
header.numMipLevels = m_nMipCount; |
|
header.imageFormat = m_Format; |
|
VectorCopy( m_vecReflectivity, header.reflectivity ); |
|
header.bumpScale = m_flBumpScale; |
|
|
|
// FIXME: Why is this needed? |
|
header.startFrame = m_iStartFrame; |
|
|
|
header.lowResImageWidth = m_nLowResImageWidth; |
|
header.lowResImageHeight = m_nLowResImageHeight; |
|
header.lowResImageFormat = m_LowResImageFormat; |
|
|
|
header.numResources = m_arrResourcesInfo.Count(); |
|
|
|
buf.Put( &header, sizeof(VTFFileHeader_t) ); |
|
if ( !buf.IsValid() ) |
|
return false; |
|
|
|
// Write the dictionary of resource entry infos |
|
int iSeekOffsetResInfoFixup = buf.TellPut(); |
|
buf.Put( m_arrResourcesInfo.Base(), m_arrResourcesInfo.Count() * sizeof( ResourceEntryInfo ) ); |
|
if ( !buf.IsValid() ) |
|
return false; |
|
|
|
// Write the low res image first |
|
if ( ResourceEntryInfo *pRei = FindResourceEntryInfo( VTF_LEGACY_RSRC_LOW_RES_IMAGE ) ) |
|
{ |
|
pRei->resData = buf.TellPut(); |
|
|
|
Assert( m_pLowResImageData ); |
|
int iLowResImageSize = ImageLoader::GetMemRequired( m_nLowResImageWidth, |
|
m_nLowResImageHeight, 1, m_LowResImageFormat, false ); |
|
buf.Put( m_pLowResImageData, iLowResImageSize ); |
|
if ( !buf.IsValid() ) |
|
return false; |
|
} |
|
|
|
// Serialize the new resources |
|
for ( int iRsrc = 0; iRsrc < m_arrResourcesInfo.Count(); ++ iRsrc ) |
|
{ |
|
ResourceEntryInfo &rei = m_arrResourcesInfo[ iRsrc ]; |
|
|
|
switch ( rei.eType ) |
|
{ |
|
case VTF_LEGACY_RSRC_LOW_RES_IMAGE: |
|
case VTF_LEGACY_RSRC_IMAGE: |
|
// written differently |
|
continue; |
|
|
|
default: |
|
{ |
|
if ( rei.eType & RSRCF_HAS_NO_DATA_CHUNK ) |
|
continue; |
|
rei.resData = buf.TellPut(); |
|
ResourceMemorySection &rms = m_arrResourcesData[ iRsrc ]; |
|
if ( !rms.WriteData( buf ) ) |
|
return false; |
|
} |
|
} |
|
} |
|
|
|
// Write image data last |
|
if ( ResourceEntryInfo *pRei = FindResourceEntryInfo( VTF_LEGACY_RSRC_IMAGE ) ) |
|
{ |
|
pRei->resData = buf.TellPut(); |
|
WriteImageData( buf ); |
|
} |
|
else |
|
return false; |
|
|
|
// Now fixup the resources dictionary |
|
int iTotalBytesPut = buf.TellPut(); |
|
buf.SeekPut( CUtlBuffer::SEEK_HEAD, iSeekOffsetResInfoFixup ); |
|
buf.Put( m_arrResourcesInfo.Base(), m_arrResourcesInfo.Count() * sizeof( ResourceEntryInfo ) ); |
|
buf.SeekPut( CUtlBuffer::SEEK_HEAD, iTotalBytesPut ); |
|
|
|
// Return if the buffer is valid |
|
return buf.IsValid(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Attributes... |
|
//----------------------------------------------------------------------------- |
|
int CVTFTexture::Width() const |
|
{ |
|
return m_nWidth; |
|
} |
|
|
|
int CVTFTexture::Height() const |
|
{ |
|
return m_nHeight; |
|
} |
|
|
|
int CVTFTexture::Depth() const |
|
{ |
|
return m_nDepth; |
|
} |
|
|
|
int CVTFTexture::MipCount() const |
|
{ |
|
return m_nMipCount; |
|
} |
|
|
|
ImageFormat CVTFTexture::Format() const |
|
{ |
|
return m_Format; |
|
} |
|
|
|
int CVTFTexture::FaceCount() const |
|
{ |
|
return m_nFaceCount; |
|
} |
|
|
|
int CVTFTexture::FrameCount() const |
|
{ |
|
return m_nFrameCount; |
|
} |
|
|
|
int CVTFTexture::Flags() const |
|
{ |
|
return m_nFlags; |
|
} |
|
|
|
bool CVTFTexture::IsCubeMap() const |
|
{ |
|
return (m_nFlags & TEXTUREFLAGS_ENVMAP) != 0; |
|
} |
|
|
|
bool CVTFTexture::IsNormalMap() const |
|
{ |
|
return (m_nFlags & TEXTUREFLAGS_NORMAL) != 0; |
|
} |
|
|
|
bool CVTFTexture::IsVolumeTexture() const |
|
{ |
|
return (m_nDepth > 1); |
|
} |
|
|
|
float CVTFTexture::BumpScale() const |
|
{ |
|
return m_flBumpScale; |
|
} |
|
|
|
const Vector &CVTFTexture::Reflectivity() const |
|
{ |
|
return m_vecReflectivity; |
|
} |
|
|
|
unsigned char *CVTFTexture::ImageData() |
|
{ |
|
return m_pImageData; |
|
} |
|
|
|
int CVTFTexture::LowResWidth() const |
|
{ |
|
return m_nLowResImageWidth; |
|
} |
|
|
|
int CVTFTexture::LowResHeight() const |
|
{ |
|
return m_nLowResImageHeight; |
|
} |
|
|
|
ImageFormat CVTFTexture::LowResFormat() const |
|
{ |
|
return m_LowResImageFormat; |
|
} |
|
|
|
unsigned char *CVTFTexture::LowResImageData() |
|
{ |
|
return m_pLowResImageData; |
|
} |
|
|
|
int CVTFTexture::RowSizeInBytes( int nMipLevel ) const |
|
{ |
|
int nWidth = (m_nWidth >> nMipLevel); |
|
if (nWidth < 1) |
|
{ |
|
nWidth = 1; |
|
} |
|
return ImageLoader::SizeInBytes( m_Format ) * nWidth; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// returns the size of one face of a particular mip level |
|
//----------------------------------------------------------------------------- |
|
int CVTFTexture::FaceSizeInBytes( int nMipLevel ) const |
|
{ |
|
int nWidth = (m_nWidth >> nMipLevel); |
|
if (nWidth < 1) |
|
{ |
|
nWidth = 1; |
|
} |
|
int nHeight = (m_nHeight >> nMipLevel); |
|
if (nHeight < 1) |
|
{ |
|
nHeight = 1; |
|
} |
|
return ImageLoader::SizeInBytes( m_Format ) * nWidth * nHeight; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Returns a pointer to the data associated with a particular frame, face, and mip level |
|
//----------------------------------------------------------------------------- |
|
unsigned char *CVTFTexture::ImageData( int iFrame, int iFace, int iMipLevel ) |
|
{ |
|
Assert( m_pImageData ); |
|
int iOffset = GetImageOffset( iFrame, iFace, iMipLevel, m_Format ); |
|
return &m_pImageData[iOffset]; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Returns a pointer to the data associated with a particular frame, face, mip level, and offset |
|
//----------------------------------------------------------------------------- |
|
unsigned char *CVTFTexture::ImageData( int iFrame, int iFace, int iMipLevel, int x, int y, int z ) |
|
{ |
|
#ifdef _DEBUG |
|
int nWidth, nHeight, nDepth; |
|
ComputeMipLevelDimensions( iMipLevel, &nWidth, &nHeight, &nDepth ); |
|
Assert( (x >= 0) && (x <= nWidth) && (y >= 0) && (y <= nHeight) && (z >= 0) && (z <= nDepth) ); |
|
#endif |
|
|
|
int nFaceBytes = FaceSizeInBytes( iMipLevel ); |
|
int nRowBytes = RowSizeInBytes( iMipLevel ); |
|
int nTexelBytes = ImageLoader::SizeInBytes( m_Format ); |
|
|
|
unsigned char *pMipBits = ImageData( iFrame, iFace, iMipLevel ); |
|
pMipBits += z * nFaceBytes + y * nRowBytes + x * nTexelBytes; |
|
return pMipBits; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Computes the size (in bytes) of a single mipmap of a single face of a single frame |
|
//----------------------------------------------------------------------------- |
|
inline int CVTFTexture::ComputeMipSize( int iMipLevel, ImageFormat fmt ) const |
|
{ |
|
Assert( iMipLevel < m_nMipCount ); |
|
int w, h, d; |
|
ComputeMipLevelDimensions( iMipLevel, &w, &h, &d ); |
|
return ImageLoader::GetMemRequired( w, h, d, fmt, false ); |
|
} |
|
|
|
int CVTFTexture::ComputeMipSize( int iMipLevel ) const |
|
{ |
|
// Version for the public interface; don't want to expose the fmt parameter |
|
return ComputeMipSize( iMipLevel, m_Format ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Computes the size of a single face of a single frame |
|
// All mip levels starting at the specified mip level are included |
|
//----------------------------------------------------------------------------- |
|
inline int CVTFTexture::ComputeFaceSize( int iStartingMipLevel, ImageFormat fmt ) const |
|
{ |
|
int iSize = 0; |
|
int w = m_nWidth; |
|
int h = m_nHeight; |
|
int d = m_nDepth; |
|
|
|
for( int i = 0; i < m_nMipCount; ++i ) |
|
{ |
|
if (i >= iStartingMipLevel) |
|
{ |
|
iSize += ImageLoader::GetMemRequired( w, h, d, fmt, false ); |
|
} |
|
w >>= 1; |
|
h >>= 1; |
|
d >>= 1; |
|
if ( w < 1 ) |
|
{ |
|
w = 1; |
|
} |
|
if ( h < 1 ) |
|
{ |
|
h = 1; |
|
} |
|
if ( d < 1 ) |
|
{ |
|
d = 1; |
|
} |
|
} |
|
return iSize; |
|
} |
|
|
|
int CVTFTexture::ComputeFaceSize( int iStartingMipLevel ) const |
|
{ |
|
// Version for the public interface; don't want to expose the fmt parameter |
|
return ComputeFaceSize( iStartingMipLevel, m_Format ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Computes the total size of all faces, all frames |
|
//----------------------------------------------------------------------------- |
|
inline int CVTFTexture::ComputeTotalSize( ImageFormat fmt ) const |
|
{ |
|
// Compute the number of bytes required to store a single face/frame |
|
int iMemRequired = ComputeFaceSize( 0, fmt ); |
|
|
|
// Now compute the total image size |
|
return m_nFaceCount * m_nFrameCount * iMemRequired; |
|
} |
|
|
|
int CVTFTexture::ComputeTotalSize( ) const |
|
{ |
|
// Version for the public interface; don't want to expose the fmt parameter |
|
return ComputeTotalSize( m_Format ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Computes the location of a particular frame, face, and mip level |
|
//----------------------------------------------------------------------------- |
|
int CVTFTexture::GetImageOffset( int iFrame, int iFace, int iMipLevel, ImageFormat fmt ) const |
|
{ |
|
Assert( iFrame < m_nFrameCount ); |
|
Assert( iFace < m_nFaceCount ); |
|
Assert( iMipLevel < m_nMipCount ); |
|
|
|
int i; |
|
int iOffset = 0; |
|
|
|
if ( IsX360() && ( m_nVersion[0] == VTF_X360_MAJOR_VERSION ) ) |
|
{ |
|
// 360 data is stored same as disk, 1x1 up to NxN |
|
// get to the right miplevel |
|
int iMipWidth, iMipHeight, iMipDepth; |
|
for ( i = m_nMipCount - 1; i > iMipLevel; --i ) |
|
{ |
|
ComputeMipLevelDimensions( i, &iMipWidth, &iMipHeight, &iMipDepth ); |
|
int iMipLevelSize = ImageLoader::GetMemRequired( iMipWidth, iMipHeight, iMipDepth, fmt, false ); |
|
iOffset += m_nFrameCount * m_nFaceCount * iMipLevelSize; |
|
} |
|
|
|
// get to the right frame |
|
ComputeMipLevelDimensions( iMipLevel, &iMipWidth, &iMipHeight, &iMipDepth ); |
|
int nFaceSize = ImageLoader::GetMemRequired( iMipWidth, iMipHeight, iMipDepth, fmt, false ); |
|
iOffset += iFrame * m_nFaceCount * nFaceSize; |
|
|
|
// get to the right face |
|
iOffset += iFace * nFaceSize; |
|
|
|
return iOffset; |
|
} |
|
|
|
// get to the right frame |
|
int iFaceSize = ComputeFaceSize( 0, fmt ); |
|
iOffset = iFrame * m_nFaceCount * iFaceSize; |
|
|
|
// Get to the right face |
|
iOffset += iFace * iFaceSize; |
|
|
|
// Get to the right mip level |
|
for (i = 0; i < iMipLevel; ++i) |
|
{ |
|
iOffset += ComputeMipSize( i, fmt ); |
|
} |
|
|
|
return iOffset; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Computes the dimensions of a particular mip level |
|
//----------------------------------------------------------------------------- |
|
void CVTFTexture::ComputeMipLevelDimensions( int iMipLevel, int *pMipWidth, int *pMipHeight, int *pMipDepth ) const |
|
{ |
|
Assert( iMipLevel < m_nMipCount ); |
|
|
|
*pMipWidth = m_nWidth >> iMipLevel; |
|
*pMipHeight = m_nHeight >> iMipLevel; |
|
*pMipDepth = m_nDepth >> iMipLevel; |
|
if ( *pMipWidth < 1 ) |
|
{ |
|
*pMipWidth = 1; |
|
} |
|
if ( *pMipHeight < 1 ) |
|
{ |
|
*pMipHeight = 1; |
|
} |
|
if ( *pMipDepth < 1 ) |
|
{ |
|
*pMipDepth = 1; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Computes the size of a subrect at a particular mip level |
|
//----------------------------------------------------------------------------- |
|
void CVTFTexture::ComputeMipLevelSubRect( Rect_t *pSrcRect, int nMipLevel, Rect_t *pSubRect ) const |
|
{ |
|
Assert( pSrcRect->x >= 0 && pSrcRect->y >= 0 && |
|
(pSrcRect->x + pSrcRect->width <= m_nWidth) && |
|
(pSrcRect->y + pSrcRect->height <= m_nHeight) ); |
|
|
|
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; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Converts the texture's image format. Use IMAGE_FORMAT_DEFAULT |
|
// if you want to be able to use various tool functions below |
|
//----------------------------------------------------------------------------- |
|
void CVTFTexture::ConvertImageFormat( ImageFormat fmt, bool bNormalToDUDV ) |
|
{ |
|
if ( !m_pImageData ) |
|
{ |
|
return; |
|
} |
|
|
|
if ( fmt == IMAGE_FORMAT_DEFAULT ) |
|
{ |
|
fmt = IMAGE_FORMAT_RGBA8888; |
|
} |
|
|
|
if ( bNormalToDUDV && !( fmt == IMAGE_FORMAT_UV88 || fmt == IMAGE_FORMAT_UVWQ8888 || fmt == IMAGE_FORMAT_UVLX8888 ) ) |
|
{ |
|
Assert( 0 ); |
|
return; |
|
} |
|
|
|
if ( m_Format == fmt ) |
|
{ |
|
return; |
|
} |
|
|
|
if ( IsX360() && ( m_nVersion[0] == VTF_X360_MAJOR_VERSION ) ) |
|
{ |
|
// 360 textures should be baked in final format |
|
Assert( 0 ); |
|
return; |
|
} |
|
|
|
// FIXME: Should this be re-written to not do an allocation? |
|
int iConvertedSize = ComputeTotalSize( fmt ); |
|
|
|
unsigned char *pConvertedImage = new unsigned char[ iConvertedSize ]; |
|
|
|
// This can happen for large, bogus textures. |
|
if ( !pConvertedImage ) |
|
return; |
|
|
|
for (int iMip = 0; iMip < m_nMipCount; ++iMip) |
|
{ |
|
int nMipWidth, nMipHeight, nMipDepth; |
|
ComputeMipLevelDimensions( iMip, &nMipWidth, &nMipHeight, &nMipDepth ); |
|
|
|
int nSrcFaceStride = ImageLoader::GetMemRequired( nMipWidth, nMipHeight, 1, m_Format, false ); |
|
int nDstFaceStride = ImageLoader::GetMemRequired( nMipWidth, nMipHeight, 1, fmt, false ); |
|
|
|
for (int iFrame = 0; iFrame < m_nFrameCount; ++iFrame) |
|
{ |
|
for (int iFace = 0; iFace < m_nFaceCount; ++iFace) |
|
{ |
|
unsigned char *pSrcData = ImageData( iFrame, iFace, iMip ); |
|
unsigned char *pDstData = pConvertedImage + |
|
GetImageOffset( iFrame, iFace, iMip, fmt ); |
|
|
|
for ( int z = 0; z < nMipDepth; ++z, pSrcData += nSrcFaceStride, pDstData += nDstFaceStride ) |
|
{ |
|
if( bNormalToDUDV ) |
|
{ |
|
if( fmt == IMAGE_FORMAT_UV88 ) |
|
{ |
|
ImageLoader::ConvertNormalMapRGBA8888ToDUDVMapUV88( pSrcData, |
|
nMipWidth, nMipHeight, pDstData ); |
|
} |
|
else if( fmt == IMAGE_FORMAT_UVWQ8888 ) |
|
{ |
|
ImageLoader::ConvertNormalMapRGBA8888ToDUDVMapUVWQ8888( pSrcData, |
|
nMipWidth, nMipHeight, pDstData ); |
|
} |
|
else if ( fmt == IMAGE_FORMAT_UVLX8888 ) |
|
{ |
|
ImageLoader::ConvertNormalMapRGBA8888ToDUDVMapUVLX8888( pSrcData, |
|
nMipWidth, nMipHeight, pDstData ); |
|
} |
|
else |
|
{ |
|
Assert( 0 ); |
|
return; |
|
} |
|
} |
|
else |
|
{ |
|
ImageLoader::ConvertImageFormat( pSrcData, m_Format, |
|
pDstData, fmt, nMipWidth, nMipHeight ); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
if ( !AllocateImageData(iConvertedSize) ) |
|
return; |
|
|
|
memcpy( m_pImageData, pConvertedImage, iConvertedSize ); |
|
m_Format = fmt; |
|
|
|
if ( !ImageLoader::IsCompressed( fmt ) ) |
|
{ |
|
int nAlphaBits = ImageLoader::ImageFormatInfo( fmt ).m_NumAlphaBits; |
|
if ( nAlphaBits > 1 ) |
|
{ |
|
m_nFlags |= TEXTUREFLAGS_EIGHTBITALPHA; |
|
m_nFlags &= ~TEXTUREFLAGS_ONEBITALPHA; |
|
} |
|
if ( nAlphaBits <= 1 ) |
|
{ |
|
m_nFlags &= ~TEXTUREFLAGS_EIGHTBITALPHA; |
|
if ( nAlphaBits == 0 ) |
|
{ |
|
m_nFlags &= ~TEXTUREFLAGS_ONEBITALPHA; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
// Only DXT5 has alpha bits |
|
if ( ( fmt == IMAGE_FORMAT_DXT1 ) || ( fmt == IMAGE_FORMAT_ATI2N ) || ( fmt == IMAGE_FORMAT_ATI1N ) ) |
|
{ |
|
m_nFlags &= ~(TEXTUREFLAGS_ONEBITALPHA|TEXTUREFLAGS_EIGHTBITALPHA); |
|
} |
|
} |
|
|
|
delete [] pConvertedImage; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Enums + structures related to conversion from cube to spheremap |
|
//----------------------------------------------------------------------------- |
|
struct SphereCalc_t |
|
{ |
|
Vector dir; |
|
float m_flRadius; |
|
float m_flOORadius; |
|
float m_flRadiusSq; |
|
LookDir_t m_LookDir; |
|
Vector m_vecLookDir; |
|
unsigned char m_pColor[4]; |
|
unsigned char **m_ppCubeFaces; |
|
int m_iSize; |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
// Methods associated with computing a spheremap from a cubemap |
|
// |
|
//----------------------------------------------------------------------------- |
|
static void CalcInit( SphereCalc_t *pCalc, int iSize, unsigned char **ppCubeFaces, LookDir_t lookDir = LOOK_DOWN_Z ) |
|
{ |
|
// NOTE: Width + height should be the same |
|
pCalc->m_flRadius = iSize * 0.5f; |
|
pCalc->m_flRadiusSq = pCalc->m_flRadius * pCalc->m_flRadius; |
|
pCalc->m_flOORadius = 1.0f / pCalc->m_flRadius; |
|
pCalc->m_LookDir = lookDir; |
|
pCalc->m_ppCubeFaces = ppCubeFaces; |
|
pCalc->m_iSize = iSize; |
|
|
|
switch( lookDir) |
|
{ |
|
case LOOK_DOWN_X: |
|
pCalc->m_vecLookDir.Init( 1, 0, 0 ); |
|
break; |
|
|
|
case LOOK_DOWN_NEGX: |
|
pCalc->m_vecLookDir.Init( -1, 0, 0 ); |
|
break; |
|
|
|
case LOOK_DOWN_Y: |
|
pCalc->m_vecLookDir.Init( 0, 1, 0 ); |
|
break; |
|
|
|
case LOOK_DOWN_NEGY: |
|
pCalc->m_vecLookDir.Init( 0, -1, 0 ); |
|
break; |
|
|
|
case LOOK_DOWN_Z: |
|
pCalc->m_vecLookDir.Init( 0, 0, 1 ); |
|
break; |
|
|
|
case LOOK_DOWN_NEGZ: |
|
pCalc->m_vecLookDir.Init( 0, 0, -1 ); |
|
break; |
|
} |
|
} |
|
|
|
static void TransformNormal( SphereCalc_t *pCalc, Vector& normal ) |
|
{ |
|
Vector vecTemp = normal; |
|
|
|
switch( pCalc->m_LookDir) |
|
{ |
|
// Look down +x |
|
case LOOK_DOWN_X: |
|
normal[0] = vecTemp[2]; |
|
normal[2] = -vecTemp[0]; |
|
break; |
|
|
|
// Look down -x |
|
case LOOK_DOWN_NEGX: |
|
normal[0] = -vecTemp[2]; |
|
normal[2] = vecTemp[0]; |
|
break; |
|
|
|
// Look down +y |
|
case LOOK_DOWN_Y: |
|
normal[0] = -vecTemp[0]; |
|
normal[1] = vecTemp[2]; |
|
normal[2] = vecTemp[1]; |
|
break; |
|
|
|
// Look down -y |
|
case LOOK_DOWN_NEGY: |
|
normal[0] = vecTemp[0]; |
|
normal[1] = -vecTemp[2]; |
|
normal[2] = vecTemp[1]; |
|
break; |
|
|
|
// Look down +z |
|
case LOOK_DOWN_Z: |
|
return; |
|
|
|
// Look down -z |
|
case LOOK_DOWN_NEGZ: |
|
normal[0] = -vecTemp[0]; |
|
normal[2] = -vecTemp[2]; |
|
break; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Given a iFace normal, determine which cube iFace to sample |
|
//----------------------------------------------------------------------------- |
|
static int CalcFaceIndex( const Vector& normal ) |
|
{ |
|
float absx, absy, absz; |
|
|
|
absx = normal[0] >= 0 ? normal[0] : -normal[0]; |
|
absy = normal[1] >= 0 ? normal[1] : -normal[1]; |
|
absz = normal[2] >= 0 ? normal[2] : -normal[2]; |
|
|
|
if ( absx > absy ) |
|
{ |
|
if ( absx > absz ) |
|
{ |
|
// left/right |
|
if ( normal[0] >= 0 ) |
|
return CUBEMAP_FACE_RIGHT; |
|
return CUBEMAP_FACE_LEFT; |
|
} |
|
} |
|
else |
|
{ |
|
if ( absy > absz ) |
|
{ |
|
// front / back |
|
if ( normal[1] >= 0 ) |
|
return CUBEMAP_FACE_BACK; |
|
return CUBEMAP_FACE_FRONT; |
|
} |
|
} |
|
|
|
// top / bottom |
|
if ( normal[2] >= 0 ) |
|
return CUBEMAP_FACE_UP; |
|
return CUBEMAP_FACE_DOWN; |
|
} |
|
|
|
static void CalcColor( SphereCalc_t *pCalc, int iFace, const Vector &normal, unsigned char *color ) |
|
{ |
|
float x, y, w; |
|
|
|
int size = pCalc->m_iSize; |
|
float hw = 0.5 * size; |
|
|
|
if ( (iFace == CUBEMAP_FACE_LEFT) || (iFace == CUBEMAP_FACE_RIGHT) ) |
|
{ |
|
w = hw / normal[0]; |
|
x = -normal[2]; |
|
y = -normal[1]; |
|
if ( iFace == CUBEMAP_FACE_LEFT ) |
|
y = -y; |
|
} |
|
else if ( (iFace == CUBEMAP_FACE_FRONT) || (iFace == CUBEMAP_FACE_BACK) ) |
|
{ |
|
w = hw / normal[1]; |
|
x = normal[0]; |
|
y = normal[2]; |
|
if ( iFace == CUBEMAP_FACE_FRONT ) |
|
x = -x; |
|
} |
|
else |
|
{ |
|
w = hw / normal[2]; |
|
x = -normal[0]; |
|
y = -normal[1]; |
|
if ( iFace == CUBEMAP_FACE_UP ) |
|
x = -x; |
|
} |
|
|
|
x = (x * w) + hw - 0.5; |
|
y = (y * w) + hw - 0.5; |
|
|
|
int u = (int)(x+0.5); |
|
int v = (int)(y+0.5); |
|
|
|
if ( u < 0 ) u = 0; |
|
else if ( u > (size-1) ) u = (size-1); |
|
|
|
if ( v < 0 ) v = 0; |
|
else if ( v > (size-1) ) v = (size-1); |
|
|
|
int offset = (v * size + u) * 4; |
|
|
|
unsigned char *pPix = pCalc->m_ppCubeFaces[iFace] + offset; |
|
color[0] = pPix[0]; |
|
color[1] = pPix[1]; |
|
color[2] = pPix[2]; |
|
color[3] = pPix[3]; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Computes the spheremap color at a particular (x,y) texcoord |
|
//----------------------------------------------------------------------------- |
|
static void CalcSphereColor( SphereCalc_t *pCalc, float x, float y ) |
|
{ |
|
Vector normal; |
|
float flRadiusSq = x*x + y*y; |
|
if (flRadiusSq > pCalc->m_flRadiusSq) |
|
{ |
|
// Force a glancing reflection |
|
normal.Init( 0, 1, 0 ); |
|
} |
|
else |
|
{ |
|
// Compute the z distance based on x*x + y*y + z*z = r*r |
|
float z = sqrt( pCalc->m_flRadiusSq - flRadiusSq ); |
|
|
|
// Here's the untransformed surface normal |
|
normal.Init( x, y, z ); |
|
normal *= pCalc->m_flOORadius; |
|
} |
|
|
|
// Transform the normal based on the actual view direction |
|
TransformNormal( pCalc, normal ); |
|
|
|
// Compute the reflection vector (full spheremap solution) |
|
// R = 2 * (N dot L)N - L |
|
Vector vecReflect; |
|
float nDotL = DotProduct( normal, pCalc->m_vecLookDir ); |
|
VectorMA( pCalc->m_vecLookDir, -2.0f * nDotL, normal, vecReflect ); |
|
vecReflect *= -1.0f; |
|
|
|
int iFace = CalcFaceIndex( vecReflect ); |
|
CalcColor( pCalc, iFace, vecReflect, pCalc->m_pColor ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Computes the spheremap color at a particular (x,y) texcoord |
|
//----------------------------------------------------------------------------- |
|
static void CalcHemisphereColor( SphereCalc_t *pCalc, float x, float y ) |
|
{ |
|
Vector normal; |
|
float flRadiusSq = x*x + y*y; |
|
if (flRadiusSq > pCalc->m_flRadiusSq) |
|
{ |
|
normal.Init( x, y, 0.0f ); |
|
VectorNormalize( normal ); |
|
normal *= pCalc->m_flRadiusSq; |
|
flRadiusSq = pCalc->m_flRadiusSq; |
|
} |
|
|
|
// Compute the z distance based on x*x + y*y + z*z = r*r |
|
float z = sqrt( pCalc->m_flRadiusSq - flRadiusSq ); |
|
|
|
// Here's the untransformed surface normal |
|
normal.Init( x, y, z ); |
|
normal *= pCalc->m_flOORadius; |
|
|
|
// Transform the normal based on the actual view direction |
|
TransformNormal( pCalc, normal ); |
|
|
|
// printf( "x: %f y: %f normal: %f %f %f\n", x, y, normal.x, normal.y, normal.z ); |
|
|
|
/* |
|
// Compute the reflection vector (full spheremap solution) |
|
// R = 2 * (N dot L)N - L |
|
Vector vecReflect; |
|
float nDotL = DotProduct( normal, pCalc->m_vecLookDir ); |
|
VectorMA( pCalc->m_vecLookDir, -2.0f * nDotL, normal, vecReflect ); |
|
vecReflect *= -1.0f; |
|
*/ |
|
|
|
int iFace = CalcFaceIndex( normal ); |
|
CalcColor( pCalc, iFace, normal, pCalc->m_pColor ); |
|
#if 0 |
|
pCalc->m_pColor[0] = normal[0] * 127 + 127; |
|
pCalc->m_pColor[1] = normal[1] * 127 + 127; |
|
pCalc->m_pColor[2] = normal[2] * 127 + 127; |
|
#endif |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Makes a single frame of spheremap |
|
//----------------------------------------------------------------------------- |
|
void CVTFTexture::ComputeSpheremapFrame( unsigned char **ppCubeFaces, unsigned char *pSpheremap, LookDir_t lookDir ) |
|
{ |
|
SphereCalc_t sphere; |
|
CalcInit( &sphere, m_nWidth, ppCubeFaces, lookDir ); |
|
int offset = 0; |
|
for ( int y = 0; y < m_nHeight; y++ ) |
|
{ |
|
for ( int x = 0; x < m_nWidth; x++ ) |
|
{ |
|
int r = 0, g = 0, b = 0, a = 0; |
|
float u = (float)x - m_nWidth * 0.5f; |
|
float v = m_nHeight * 0.5f - (float)y; |
|
|
|
CalcSphereColor( &sphere, u, v ); |
|
r += sphere.m_pColor[0]; |
|
g += sphere.m_pColor[1]; |
|
b += sphere.m_pColor[2]; |
|
a += sphere.m_pColor[3]; |
|
|
|
CalcSphereColor( &sphere, u + 0.25, v ); |
|
r += sphere.m_pColor[0]; |
|
g += sphere.m_pColor[1]; |
|
b += sphere.m_pColor[2]; |
|
a += sphere.m_pColor[3]; |
|
|
|
v += 0.25; |
|
CalcSphereColor( &sphere, u + 0.25, v ); |
|
r += sphere.m_pColor[0]; |
|
g += sphere.m_pColor[1]; |
|
b += sphere.m_pColor[2]; |
|
a += sphere.m_pColor[3]; |
|
|
|
CalcSphereColor( &sphere, u, v ); |
|
r += sphere.m_pColor[0]; |
|
g += sphere.m_pColor[1]; |
|
b += sphere.m_pColor[2]; |
|
a += sphere.m_pColor[3]; |
|
|
|
pSpheremap[ offset + 0 ] = r >> 2; |
|
pSpheremap[ offset + 1 ] = g >> 2; |
|
pSpheremap[ offset + 2 ] = b >> 2; |
|
pSpheremap[ offset + 3 ] = a >> 2; |
|
offset += 4; |
|
} |
|
} |
|
} |
|
|
|
void CVTFTexture::ComputeHemispheremapFrame( unsigned char **ppCubeFaces, unsigned char *pSpheremap, LookDir_t lookDir ) |
|
{ |
|
SphereCalc_t sphere; |
|
CalcInit( &sphere, m_nWidth, ppCubeFaces, lookDir ); |
|
int offset = 0; |
|
for ( int y = 0; y < m_nHeight; y++ ) |
|
{ |
|
for ( int x = 0; x < m_nWidth; x++ ) |
|
{ |
|
int r = 0, g = 0, b = 0, a = 0; |
|
float u = (float)x - m_nWidth * 0.5f; |
|
float v = m_nHeight * 0.5f - (float)y; |
|
|
|
CalcHemisphereColor( &sphere, u, v ); |
|
r += sphere.m_pColor[0]; |
|
g += sphere.m_pColor[1]; |
|
b += sphere.m_pColor[2]; |
|
a += sphere.m_pColor[3]; |
|
|
|
CalcHemisphereColor( &sphere, u + 0.25, v ); |
|
r += sphere.m_pColor[0]; |
|
g += sphere.m_pColor[1]; |
|
b += sphere.m_pColor[2]; |
|
a += sphere.m_pColor[3]; |
|
|
|
v += 0.25; |
|
CalcHemisphereColor( &sphere, u + 0.25, v ); |
|
r += sphere.m_pColor[0]; |
|
g += sphere.m_pColor[1]; |
|
b += sphere.m_pColor[2]; |
|
a += sphere.m_pColor[3]; |
|
|
|
CalcHemisphereColor( &sphere, u, v ); |
|
r += sphere.m_pColor[0]; |
|
g += sphere.m_pColor[1]; |
|
b += sphere.m_pColor[2]; |
|
a += sphere.m_pColor[3]; |
|
|
|
pSpheremap[ offset + 0 ] = r >> 2; |
|
pSpheremap[ offset + 1 ] = g >> 2; |
|
pSpheremap[ offset + 2 ] = b >> 2; |
|
pSpheremap[ offset + 3 ] = a >> 2; |
|
offset += 4; |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Generate spheremap based on the current images (only works for cubemaps) |
|
// The look dir indicates the direction of the center of the sphere |
|
//----------------------------------------------------------------------------- |
|
void CVTFTexture::GenerateSpheremap( LookDir_t lookDir ) |
|
{ |
|
if (!IsCubeMap()) |
|
return; |
|
|
|
// HDRFIXME: Need to re-enable this. |
|
// Assert( m_Format == IMAGE_FORMAT_RGBA8888 ); |
|
|
|
// We'll be doing our work in IMAGE_FORMAT_RGBA8888 mode 'cause it's easier |
|
unsigned char *pCubeMaps[6]; |
|
|
|
// Allocate the bits for the spheremap |
|
Assert( m_nDepth == 1 ); |
|
int iMemRequired = ComputeFaceSize( 0, IMAGE_FORMAT_RGBA8888 ); |
|
unsigned char *pSphereMapBits = new unsigned char [ iMemRequired ]; |
|
|
|
// Generate a spheremap for each frame of the cubemap |
|
for (int iFrame = 0; iFrame < m_nFrameCount; ++iFrame) |
|
{ |
|
// Point to our own textures (highest mip level) |
|
for (int iFace = 0; iFace < 6; ++iFace) |
|
{ |
|
pCubeMaps[iFace] = ImageData( iFrame, iFace, 0 ); |
|
} |
|
|
|
// Compute the spheremap of the top LOD |
|
// HDRFIXME: Make this work? |
|
if( m_Format == IMAGE_FORMAT_RGBA8888 ) |
|
{ |
|
ComputeSpheremapFrame( pCubeMaps, pSphereMapBits, lookDir ); |
|
} |
|
|
|
// Compute the mip levels of the spheremap, converting from RGBA8888 to our format |
|
unsigned char *pFinalSphereMapBits = ImageData( iFrame, CUBEMAP_FACE_SPHEREMAP, 0 ); |
|
ImageLoader::GenerateMipmapLevels( pSphereMapBits, pFinalSphereMapBits, |
|
m_nWidth, m_nHeight, m_nDepth, m_Format, 2.2, 2.2, m_nMipCount ); |
|
} |
|
|
|
// Free memory |
|
delete [] pSphereMapBits; |
|
} |
|
|
|
void CVTFTexture::GenerateHemisphereMap( unsigned char *pSphereMapBitsRGBA, int targetWidth, |
|
int targetHeight, LookDir_t lookDir, int iFrame ) |
|
{ |
|
Assert( m_Format == IMAGE_FORMAT_RGBA8888 ); |
|
|
|
unsigned char *pCubeMaps[6]; |
|
|
|
// Point to our own textures (highest mip level) |
|
for (int iFace = 0; iFace < 6; ++iFace) |
|
{ |
|
pCubeMaps[iFace] = ImageData( iFrame, iFace, 0 ); |
|
} |
|
|
|
// Compute the spheremap of the top LOD |
|
ComputeHemispheremapFrame( pCubeMaps, pSphereMapBitsRGBA, lookDir ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Rotate the image depending on what iFace we've got... |
|
// We need to do this because we define the cube textures in a different |
|
// format from DX8. |
|
//----------------------------------------------------------------------------- |
|
static void FixCubeMapFacing( unsigned char* pImage, int cubeFaceID, int size, ImageFormat fmt ) |
|
{ |
|
int retVal; |
|
switch( cubeFaceID ) |
|
{ |
|
case CUBEMAP_FACE_RIGHT: // +x |
|
retVal = ImageLoader::RotateImageLeft( pImage, pImage, size, fmt ); |
|
Assert( retVal ); |
|
retVal = ImageLoader::FlipImageVertically( pImage, pImage, size, size, fmt ); |
|
Assert( retVal ); |
|
break; |
|
|
|
case CUBEMAP_FACE_LEFT: // -x |
|
retVal = ImageLoader::RotateImageLeft( pImage, pImage, size, fmt ); |
|
Assert( retVal ); |
|
retVal = ImageLoader::FlipImageHorizontally( pImage, pImage, size, size, fmt ); |
|
Assert( retVal ); |
|
break; |
|
|
|
case CUBEMAP_FACE_BACK: // +y |
|
retVal = ImageLoader::RotateImage180( pImage, pImage, size, fmt ); |
|
Assert( retVal ); |
|
retVal = ImageLoader::FlipImageHorizontally( pImage, pImage, size, size, fmt ); |
|
Assert( retVal ); |
|
break; |
|
|
|
case CUBEMAP_FACE_FRONT: // -y |
|
retVal = ImageLoader::FlipImageHorizontally( pImage, pImage, size, size, fmt ); |
|
Assert( retVal ); |
|
break; |
|
|
|
case CUBEMAP_FACE_UP: // +z |
|
retVal = ImageLoader::RotateImageLeft( pImage, pImage, size, fmt ); |
|
Assert( retVal ); |
|
retVal = ImageLoader::FlipImageVertically( pImage, pImage, size, size, fmt ); |
|
Assert( retVal ); |
|
break; |
|
|
|
case CUBEMAP_FACE_DOWN: // -z |
|
retVal = ImageLoader::FlipImageHorizontally( pImage, pImage, size, size, fmt ); |
|
Assert( retVal ); |
|
retVal = ImageLoader::RotateImageLeft( pImage, pImage, size, fmt ); |
|
Assert( retVal ); |
|
break; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Fixes the cubemap faces orientation from our standard to what the material system needs |
|
//----------------------------------------------------------------------------- |
|
void CVTFTexture::FixCubemapFaceOrientation( ) |
|
{ |
|
if (!IsCubeMap()) |
|
return; |
|
|
|
Assert( !ImageLoader::IsCompressed( m_Format ) ); |
|
for (int iMipLevel = 0; iMipLevel < m_nMipCount; ++iMipLevel) |
|
{ |
|
int iMipSize, iTemp, nDepth; |
|
ComputeMipLevelDimensions( iMipLevel, &iMipSize, &iTemp, &nDepth ); |
|
Assert( (iMipSize == iTemp) && (nDepth == 1) ); |
|
|
|
for (int iFrame = 0; iFrame < m_nFrameCount; ++iFrame) |
|
{ |
|
for (int iFace = 0; iFace < 6; ++iFace) |
|
{ |
|
FixCubeMapFacing( ImageData( iFrame, iFace, iMipLevel ), iFace, iMipSize, m_Format ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
void CVTFTexture::NormalizeTopMipLevel() |
|
{ |
|
if( !( m_nFlags & TEXTUREFLAGS_NORMAL ) ) |
|
return; |
|
|
|
int nSrcWidth, nSrcHeight, nSrcDepth; |
|
int srcMipLevel = 0; |
|
ComputeMipLevelDimensions( srcMipLevel, &nSrcWidth, &nSrcHeight, &nSrcDepth ); |
|
for (int iFrame = 0; iFrame < m_nFrameCount; ++iFrame) |
|
{ |
|
for (int iFace = 0; iFace < m_nFaceCount; ++iFace) |
|
{ |
|
unsigned char *pSrcLevel = ImageData( iFrame, iFace, srcMipLevel ); |
|
ImageLoader::NormalizeNormalMapRGBA8888( pSrcLevel, nSrcWidth * nSrcHeight * nSrcDepth ); |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Generates mipmaps from the base mip levels |
|
//----------------------------------------------------------------------------- |
|
void CVTFTexture::GenerateMipmaps() |
|
{ |
|
// Go ahead and generate mipmaps even if we don't want 'em in the vtf. |
|
// if( ( Flags() & ( TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_NOLOD ) ) == ( TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_NOLOD ) ) |
|
// { |
|
// return; |
|
// } |
|
|
|
Assert( m_Format == IMAGE_FORMAT_RGBA8888 || m_Format == IMAGE_FORMAT_RGB323232F || m_Format == IMAGE_FORMAT_RGBA32323232F ); |
|
|
|
// FIXME: Should we be doing anything special for normalmaps other than a final normalization pass? |
|
ImageLoader::ResampleInfo_t info; |
|
info.m_nSrcWidth = m_nWidth; |
|
info.m_nSrcHeight = m_nHeight; |
|
info.m_nSrcDepth = m_nDepth; |
|
info.m_flSrcGamma = 2.2f; |
|
info.m_flDestGamma = 2.2f; |
|
info.m_nFlags = 0; |
|
bool bNormalMap = ( Flags() & TEXTUREFLAGS_NORMAL ) || ( m_Options.flags0 & VtfProcessingOptions::OPT_NORMAL_DUDV ); |
|
bool bAlphaTest = ( ( m_Options.flags0 & VtfProcessingOptions::OPT_MIP_ALPHATEST ) != 0 ); |
|
|
|
if ( bAlphaTest ) |
|
{ |
|
info.m_nFlags |= ImageLoader::RESAMPLE_ALPHATEST; |
|
if ( m_flAlphaThreshhold >= 0 ) |
|
{ |
|
info.m_flAlphaThreshhold = m_flAlphaThreshhold; |
|
} |
|
if ( m_flAlphaHiFreqThreshhold >= 0 ) |
|
{ |
|
info.m_flAlphaHiFreqThreshhold = m_flAlphaHiFreqThreshhold; |
|
} |
|
} |
|
|
|
if ( m_Options.flags0 & VtfProcessingOptions::OPT_FILTER_NICE ) |
|
{ |
|
info.m_nFlags |= ImageLoader::RESAMPLE_NICE_FILTER; |
|
} |
|
|
|
if ( Flags() & TEXTUREFLAGS_CLAMPS ) |
|
{ |
|
info.m_nFlags |= ImageLoader::RESAMPLE_CLAMPS; |
|
} |
|
|
|
if ( Flags() & TEXTUREFLAGS_CLAMPT ) |
|
{ |
|
info.m_nFlags |= ImageLoader::RESAMPLE_CLAMPT; |
|
} |
|
|
|
if ( Flags() & TEXTUREFLAGS_CLAMPU ) |
|
{ |
|
info.m_nFlags |= ImageLoader::RESAMPLE_CLAMPU; |
|
} |
|
|
|
// Compute how many mips are above "visible mip0" |
|
int numMipsClampedLod = 0; |
|
if ( TextureLODControlSettings_t const *pLodSettings = ( TextureLODControlSettings_t const * ) GetResourceData( VTF_RSRC_TEXTURE_LOD_SETTINGS, NULL ) ) |
|
{ |
|
int iClampX = 1 << min( pLodSettings->m_ResolutionClampX, pLodSettings->m_ResolutionClampX_360 ); |
|
int iClampY = 1 << min( pLodSettings->m_ResolutionClampX, pLodSettings->m_ResolutionClampX_360 ); |
|
|
|
while ( iClampX < m_nWidth || iClampY < m_nHeight ) |
|
{ |
|
++ numMipsClampedLod; |
|
iClampX <<= 1; |
|
iClampY <<= 1; |
|
} |
|
} |
|
|
|
for ( int iMipLevel = 1; iMipLevel < m_nMipCount; ++iMipLevel ) |
|
{ |
|
ComputeMipLevelDimensions( iMipLevel, &info.m_nDestWidth, &info.m_nDestHeight, &info.m_nDestDepth ); |
|
|
|
if ( m_Options.flags0 & VtfProcessingOptions::OPT_PREMULT_COLOR_ONEOVERMIP ) |
|
{ |
|
for ( int ch = 0; ch < 3; ++ ch ) |
|
info.m_flColorScale[ch] = 1.0f / ( float )( 1 << iMipLevel ); |
|
} |
|
|
|
// don't use the 0th mip level since NICE filtering blows up! |
|
int nSrcMipLevel = iMipLevel - 4; |
|
if ( nSrcMipLevel < 0 ) |
|
nSrcMipLevel = 0; |
|
|
|
// Decay options |
|
bool bMipBlendActive = false; |
|
char chChannels[4] = { 'R', 'G', 'B', 'A' }; |
|
for ( int ch = 0; ch < 4; ++ ch ) |
|
{ |
|
int iLastNonDecayMip = numMipsClampedLod + int( m_Options.numNotDecayMips[ch] ); |
|
if ( iLastNonDecayMip > m_nMipCount ) |
|
iLastNonDecayMip = m_nMipCount - 1; |
|
int numDecayMips = m_nMipCount - iLastNonDecayMip - 1; |
|
if ( numDecayMips < 1 ) |
|
numDecayMips = 1; |
|
|
|
// Decay is only active starting from numDecayMips |
|
if ( !( ( ( iMipLevel == m_nMipCount - 1 ) || ( iMipLevel > iLastNonDecayMip ) ) && // last 1x1 mip or past clamped and skipped |
|
( m_Options.flags0 & ( VtfProcessingOptions::OPT_DECAY_R << ch ) ) ) ) // the channel has decay |
|
continue; |
|
|
|
// Color goal |
|
info.m_flColorGoal[ch] = m_Options.clrDecayGoal[ch]; |
|
|
|
// Color scale |
|
if ( iMipLevel == m_nMipCount - 1 ) |
|
{ |
|
info.m_flColorScale[ch] = 0.0f; |
|
} |
|
else if ( m_Options.flags0 & ( VtfProcessingOptions::OPT_DECAY_EXP_R << ch ) ) |
|
{ |
|
info.m_flColorScale[ch] = pow( m_Options.fDecayExponentBase[ch], iMipLevel - iLastNonDecayMip ); |
|
} |
|
else |
|
{ |
|
info.m_flColorScale[ch] = 1.0f - float( iMipLevel - iLastNonDecayMip ) / float( numDecayMips ); |
|
} |
|
|
|
if ( !bMipBlendActive ) |
|
{ |
|
bMipBlendActive = true; |
|
printf( "Blending mip%d %dx%d to", iMipLevel, info.m_nDestWidth, info.m_nDestHeight ); |
|
} |
|
|
|
printf( " %c=%d ~%d%%", chChannels[ch], m_Options.clrDecayGoal[ch], int( (1.f - info.m_flColorScale[ch]) * 100.0f + 0.5f ) ); |
|
} |
|
if ( bMipBlendActive ) |
|
printf( "\n" ); |
|
|
|
if ( bNormalMap ) |
|
{ |
|
info.m_nFlags |= ImageLoader::RESAMPLE_NORMALMAP; |
|
// Normal maps xyz decays to 127.f |
|
for ( int ch = 0; ch < 3; ++ ch ) |
|
info.m_flColorGoal[ch] = 127.0f; |
|
} |
|
|
|
for ( int iFrame = 0; iFrame < m_nFrameCount; ++iFrame ) |
|
{ |
|
for ( int iFace = 0; iFace < m_nFaceCount; ++iFace ) |
|
{ |
|
unsigned char *pSrcLevel = ImageData( iFrame, iFace, nSrcMipLevel ); |
|
unsigned char *pDstLevel = ImageData( iFrame, iFace, iMipLevel ); |
|
|
|
info.m_pSrc = pSrcLevel; |
|
info.m_pDest = pDstLevel; |
|
ComputeMipLevelDimensions( nSrcMipLevel, &info.m_nSrcWidth, &info.m_nSrcHeight, &info.m_nSrcDepth ); |
|
if( m_Format == IMAGE_FORMAT_RGBA32323232F ) |
|
{ |
|
ImageLoader::ResampleRGBA32323232F( info ); |
|
} |
|
else if( m_Format == IMAGE_FORMAT_RGB323232F ) |
|
{ |
|
ImageLoader::ResampleRGB323232F( info ); |
|
} |
|
else |
|
{ |
|
ImageLoader::ResampleRGBA8888( info ); |
|
} |
|
if ( Flags() & TEXTUREFLAGS_NORMAL ) |
|
{ |
|
ImageLoader::NormalizeNormalMapRGBA8888( pDstLevel, info.m_nDestWidth * info.m_nDestHeight * info.m_nDestDepth ); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
void CVTFTexture::PutOneOverMipLevelInAlpha() |
|
{ |
|
Assert( m_Format == IMAGE_FORMAT_RGBA8888 ); |
|
|
|
for (int iMipLevel = 0; iMipLevel < m_nMipCount; ++iMipLevel) |
|
{ |
|
int nMipWidth, nMipHeight, nMipDepth; |
|
ComputeMipLevelDimensions( iMipLevel, &nMipWidth, &nMipHeight, &nMipDepth ); |
|
int size = nMipWidth * nMipHeight * nMipDepth; |
|
unsigned char ooMipLevel = ( unsigned char )( 255.0f * ( 1.0f / ( float )( 1 << iMipLevel ) ) ); |
|
|
|
for (int iFrame = 0; iFrame < m_nFrameCount; ++iFrame) |
|
{ |
|
for (int iFace = 0; iFace < m_nFaceCount; ++iFace) |
|
{ |
|
unsigned char *pDstLevel = ImageData( iFrame, iFace, iMipLevel ); |
|
unsigned char *pDst; |
|
for( pDst = pDstLevel; pDst < pDstLevel + size * 4; pDst += 4 ) |
|
{ |
|
pDst[3] = ooMipLevel; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Computes the reflectivity |
|
//----------------------------------------------------------------------------- |
|
void CVTFTexture::ComputeReflectivity( ) |
|
{ |
|
// HDRFIXME: fix this when we ahve a new intermediate format |
|
if( m_Format != IMAGE_FORMAT_RGBA8888 ) |
|
{ |
|
m_vecReflectivity.Init( 0.2f, 0.2f, 0.2f ); |
|
return; |
|
} |
|
|
|
Assert( m_Format == IMAGE_FORMAT_RGBA8888 ); |
|
|
|
int divisor = 0; |
|
m_vecReflectivity.Init( 0.0f, 0.0f, 0.0f ); |
|
for( int iFrame = 0; iFrame < m_nFrameCount; ++iFrame ) |
|
{ |
|
for( int iFace = 0; iFace < m_nFaceCount; ++iFace ) |
|
{ |
|
Vector vecFaceReflect; |
|
unsigned char* pSrc = ImageData( iFrame, iFace, 0 ); |
|
int nNumPixels = m_nWidth * m_nHeight * m_nDepth; |
|
|
|
VectorClear( vecFaceReflect ); |
|
for (int i = 0; i < nNumPixels; ++i, pSrc += 4 ) |
|
{ |
|
vecFaceReflect[0] += TextureToLinear( pSrc[0] ); |
|
vecFaceReflect[1] += TextureToLinear( pSrc[1] ); |
|
vecFaceReflect[2] += TextureToLinear( pSrc[2] ); |
|
} |
|
|
|
vecFaceReflect /= nNumPixels; |
|
|
|
m_vecReflectivity += vecFaceReflect; |
|
++divisor; |
|
} |
|
} |
|
m_vecReflectivity /= divisor; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Computes the alpha flags |
|
//----------------------------------------------------------------------------- |
|
void CVTFTexture::ComputeAlphaFlags() |
|
{ |
|
// HDRFIXME: hack hack hack |
|
if( m_Format != IMAGE_FORMAT_RGBA8888 ) |
|
{ |
|
m_nFlags &= ~( TEXTUREFLAGS_EIGHTBITALPHA | TEXTUREFLAGS_ONEBITALPHA ); |
|
m_Options.flags0 &= ~( VtfProcessingOptions::OPT_MIP_ALPHATEST ); |
|
return; |
|
} |
|
Assert( m_Format == IMAGE_FORMAT_RGBA8888 ); |
|
|
|
m_nFlags &= ~(TEXTUREFLAGS_EIGHTBITALPHA | TEXTUREFLAGS_ONEBITALPHA); |
|
|
|
if( m_Options.flags0 & VtfProcessingOptions::OPT_SET_ALPHA_ONEOVERMIP ) |
|
{ |
|
m_nFlags |= TEXTUREFLAGS_EIGHTBITALPHA; |
|
return; |
|
} |
|
|
|
for( int iFrame = 0; iFrame < m_nFrameCount; ++iFrame ) |
|
{ |
|
for( int iFace = 0; iFace < m_nFaceCount; ++iFace ) |
|
{ |
|
for( int iMipLevel = 0; iMipLevel < m_nMipCount; ++iMipLevel ) |
|
{ |
|
// If we're all 0 or all 255, assume it's opaque |
|
bool bHasZero = false; |
|
bool bHas255 = false; |
|
|
|
unsigned char* pSrcBits = ImageData( iFrame, iFace, iMipLevel ); |
|
|
|
int nMipWidth, nMipHeight, nMipDepth; |
|
ComputeMipLevelDimensions( iMipLevel, &nMipWidth, &nMipHeight, &nMipDepth ); |
|
int nNumPixels = nMipWidth * nMipHeight * nMipDepth; |
|
|
|
while ( --nNumPixels >= 0 ) |
|
{ |
|
if ( pSrcBits[3] == 0 ) |
|
{ |
|
bHasZero = true; |
|
} |
|
else if ( pSrcBits[3] == 255 ) |
|
{ |
|
bHas255 = true; |
|
} |
|
else |
|
{ |
|
// Have grey at all? 8 bit alpha baby |
|
m_nFlags &= ~TEXTUREFLAGS_ONEBITALPHA; |
|
m_nFlags |= TEXTUREFLAGS_EIGHTBITALPHA; |
|
return; |
|
} |
|
|
|
pSrcBits += 4; |
|
} |
|
|
|
// If we have both 0 at 255, we're at least one-bit alpha |
|
if ( bHasZero && bHas255 ) |
|
{ |
|
m_nFlags |= TEXTUREFLAGS_ONEBITALPHA; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Gets the texture all internally consistent assuming you've loaded |
|
// mip 0 of all faces of all frames |
|
//----------------------------------------------------------------------------- |
|
void CVTFTexture::PostProcess( bool bGenerateSpheremap, LookDir_t lookDir, bool bAllowFixCubemapOrientation ) |
|
{ |
|
// HDRFIXME: Make sure that all of the below functions check for the proper formats if we get rid of this assert. |
|
// Assert( m_Format == IMAGE_FORMAT_RGBA8888 ); |
|
|
|
// Set up the cube map faces |
|
if (IsCubeMap()) |
|
{ |
|
// Rotate the cubemaps so they're appropriate for the material system |
|
if ( bAllowFixCubemapOrientation ) |
|
FixCubemapFaceOrientation(); |
|
|
|
// FIXME: We could theoretically not compute spheremap mip levels |
|
// in generate spheremaps; should we? The trick is when external |
|
// clients can be expected to call it |
|
|
|
// Compute the spheremap fallback for cubemaps if we weren't able to load up one... |
|
if (bGenerateSpheremap) |
|
GenerateSpheremap(lookDir); |
|
} |
|
|
|
// Normalize the top mip level if necessary. |
|
NormalizeTopMipLevel(); |
|
|
|
// Generate mipmap levels |
|
GenerateMipmaps(); |
|
|
|
if( m_Options.flags0 & VtfProcessingOptions::OPT_SET_ALPHA_ONEOVERMIP ) |
|
{ |
|
PutOneOverMipLevelInAlpha(); |
|
} |
|
|
|
// Compute reflectivity |
|
ComputeReflectivity(); |
|
|
|
// Are we 8-bit or 1-bit alpha? |
|
// NOTE: We have to do this *after* computing the spheremap fallback for |
|
// cubemaps or it'll throw the flags off |
|
ComputeAlphaFlags(); |
|
} |
|
|
|
void CVTFTexture::SetPostProcessingSettings( VtfProcessingOptions const *pOptions ) |
|
{ |
|
memset( &m_Options, 0, sizeof( m_Options ) ); |
|
memcpy( &m_Options, pOptions, min( (uint32)sizeof( m_Options ), pOptions->cbSize ) ); |
|
m_Options.cbSize = sizeof( m_Options ); |
|
|
|
// Optionally perform the fixups |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Generate the low-res image bits |
|
//----------------------------------------------------------------------------- |
|
bool CVTFTexture::ConstructLowResImage() |
|
{ |
|
// HDRFIXME: hack hack hack |
|
if( m_Format != IMAGE_FORMAT_RGBA8888 ) |
|
{ |
|
return true; |
|
} |
|
Assert( m_Format == IMAGE_FORMAT_RGBA8888 ); |
|
Assert( m_pLowResImageData ); |
|
|
|
CUtlMemory<unsigned char> lowResSizeImage; |
|
lowResSizeImage.EnsureCapacity( m_nLowResImageWidth * m_nLowResImageHeight * 4 ); |
|
|
|
ImageLoader::ResampleInfo_t info; |
|
info.m_pSrc = ImageData(0, 0, 0); |
|
info.m_pDest = lowResSizeImage.Base(); |
|
info.m_nSrcWidth = m_nWidth; |
|
info.m_nSrcHeight = m_nHeight; |
|
info.m_nDestWidth = m_nLowResImageWidth; |
|
info.m_nDestHeight = m_nLowResImageHeight; |
|
info.m_flSrcGamma = 2.2f; |
|
info.m_flDestGamma = 2.2f; |
|
info.m_nFlags = ImageLoader::RESAMPLE_NICE_FILTER; |
|
|
|
if( !ImageLoader::ResampleRGBA8888( info ) ) |
|
return false; |
|
|
|
// convert to the low-res size version with the correct image format |
|
unsigned char *tmpImage = lowResSizeImage.Base(); |
|
return ImageLoader::ConvertImageFormat( tmpImage, IMAGE_FORMAT_RGBA8888, |
|
m_pLowResImageData, m_LowResImageFormat, m_nLowResImageWidth, m_nLowResImageHeight ); |
|
} |
|
|
|
// ----------------------------------------------------------------------------- |
|
// Cubemap edge-filtering functions. |
|
// ----------------------------------------------------------------------------- |
|
void CVTFTexture::SetupFaceVert( int iMipLevel, int iVert, CEdgePos &out ) |
|
{ |
|
int nMipWidth, nMipHeight, nMipDepth; |
|
ComputeMipLevelDimensions( iMipLevel, &nMipWidth, &nMipHeight, &nMipDepth ); |
|
|
|
out.x = out.y = 0; |
|
if ( iVert == 0 || iVert == 3 ) |
|
{ |
|
out.y = nMipHeight - 1; |
|
} |
|
|
|
if ( iVert == 2 || iVert == 3 ) |
|
{ |
|
out.x = nMipWidth - 1; |
|
} |
|
} |
|
|
|
void CVTFTexture::SetupEdgeIncrement( CEdgePos &start, CEdgePos &end, CEdgePos &inc ) |
|
{ |
|
inc.x = inc.y = 0; |
|
if ( start.x != end.x ) |
|
{ |
|
Assert( start.y == end.y ); |
|
inc.x = (start.x < end.x) ? 1 : -1; |
|
} |
|
else if ( start.y != end.y ) |
|
{ |
|
Assert( start.x == end.x ); |
|
inc.y = (start.y < end.y) ? 1 : -1; |
|
} |
|
else |
|
{ |
|
Assert( false ); |
|
} |
|
} |
|
|
|
void CVTFTexture::SetupTextureEdgeIncrements( |
|
int iMipLevel, |
|
int iFace1Edge, |
|
int iFace2Edge, |
|
bool bFlipFace2Edge, |
|
CEdgeIncrements *incs ) |
|
{ |
|
// Figure out the coordinates of the verts we're blending. |
|
SetupFaceVert( iMipLevel, iFace1Edge, incs->iFace1Start ); |
|
SetupFaceVert( iMipLevel, (iFace1Edge+1)%4, incs->iFace1End ); |
|
|
|
if ( bFlipFace2Edge ) |
|
{ |
|
SetupFaceVert( iMipLevel, (iFace2Edge+1)%4, incs->iFace2Start ); |
|
SetupFaceVert( iMipLevel, iFace2Edge, incs->iFace2End ); |
|
} |
|
else |
|
{ |
|
SetupFaceVert( iMipLevel, iFace2Edge, incs->iFace2Start ); |
|
SetupFaceVert( iMipLevel, (iFace2Edge+1)%4, incs->iFace2End ); |
|
} |
|
|
|
// Figure out the increments from start to end. |
|
SetupEdgeIncrement( incs->iFace1Start, incs->iFace1End, incs->iFace1Inc ); |
|
SetupEdgeIncrement( incs->iFace2Start, incs->iFace2End, incs->iFace2Inc ); |
|
} |
|
|
|
void BlendTexels( unsigned char **texels, int nTexels ) |
|
{ |
|
int sum[4] = { 0, 0, 0, 0 }; |
|
int i; |
|
for ( i=0; i < nTexels; i++ ) |
|
{ |
|
sum[0] += texels[i][0]; |
|
sum[1] += texels[i][1]; |
|
sum[2] += texels[i][2]; |
|
sum[3] += texels[i][3]; |
|
} |
|
for ( i=0; i < nTexels; i++ ) |
|
{ |
|
texels[i][0] = (unsigned char)( sum[0] / nTexels ); |
|
texels[i][1] = (unsigned char)( sum[1] / nTexels ); |
|
texels[i][2] = (unsigned char)( sum[2] / nTexels ); |
|
texels[i][3] = (unsigned char)( sum[3] / nTexels ); |
|
} |
|
} |
|
|
|
void CVTFTexture::BlendCubeMapFaceEdges( |
|
int iFrame, |
|
int iMipLevel, |
|
const CEdgeMatch *pMatch ) |
|
{ |
|
int nMipWidth, nMipHeight, nMipDepth; |
|
ComputeMipLevelDimensions( iMipLevel, &nMipWidth, &nMipHeight, &nMipDepth ); |
|
Assert( nMipDepth == 1 ); |
|
if ( nMipWidth <= 1 || nMipHeight <= 1 ) |
|
return; |
|
|
|
unsigned char *pFace1Data = ImageData( iFrame, pMatch->m_iFaces[0], iMipLevel ); |
|
unsigned char *pFace2Data = ImageData( iFrame, pMatch->m_iFaces[1], iMipLevel ); |
|
|
|
CEdgeIncrements incs; |
|
SetupTextureEdgeIncrements( iMipLevel, pMatch->m_iEdges[0], pMatch->m_iEdges[1], pMatch->m_bFlipFace2Edge, &incs ); |
|
|
|
// Do all pixels but the first and the last one (those will be handled when blending corners). |
|
CEdgePos iFace1Cur = incs.iFace1Start + incs.iFace1Inc; |
|
CEdgePos iFace2Cur = incs.iFace2Start + incs.iFace2Inc; |
|
|
|
if ( m_Format == IMAGE_FORMAT_DXT1 || m_Format == IMAGE_FORMAT_DXT5 ) |
|
{ |
|
if ( iFace1Cur != incs.iFace1End ) |
|
{ |
|
while ( iFace1Cur != incs.iFace1End ) |
|
{ |
|
// Copy the palette index from image 1 to image 2. |
|
S3PaletteIndex paletteIndex = S3TC_GetPaletteIndex( pFace1Data, m_Format, nMipWidth, iFace1Cur.x, iFace1Cur.y ); |
|
S3TC_SetPaletteIndex( pFace2Data, m_Format, nMipWidth, iFace2Cur.x, iFace2Cur.y, paletteIndex ); |
|
|
|
iFace1Cur += incs.iFace1Inc; |
|
iFace2Cur += incs.iFace2Inc; |
|
} |
|
} |
|
} |
|
else if ( m_Format == IMAGE_FORMAT_RGBA8888 ) |
|
{ |
|
if ( iFace1Cur != incs.iFace1End ) |
|
{ |
|
while ( iFace1Cur != incs.iFace1End ) |
|
{ |
|
// Now we know the 2 pixels. Average them and copy the averaged value to both pixels. |
|
unsigned char *texels[2] = |
|
{ |
|
pFace1Data + ((iFace1Cur.y * nMipWidth) + iFace1Cur.x) * 4, |
|
pFace2Data + ((iFace2Cur.y * nMipWidth) + iFace2Cur.x) * 4 |
|
}; |
|
|
|
BlendTexels( texels, 2 ); |
|
|
|
iFace1Cur += incs.iFace1Inc; |
|
iFace2Cur += incs.iFace2Inc; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
Error( "BlendCubeMapFaceEdges: unsupported image format (%d)", (int)m_Format ); |
|
} |
|
} |
|
|
|
void CVTFTexture::BlendCubeMapFaceCorners( |
|
int iFrame, |
|
int iMipLevel, |
|
const CCornerMatch *pMatch ) |
|
{ |
|
int nMipWidth, nMipHeight, nMipDepth; |
|
ComputeMipLevelDimensions( iMipLevel, &nMipWidth, &nMipHeight, &nMipDepth ); |
|
Assert( nMipDepth == 1 ); |
|
|
|
// Setup the coordinates of each texel. |
|
CEdgePos texelPos[3]; |
|
unsigned char *pImageData[3]; |
|
int iEdge; |
|
for ( iEdge=0; iEdge < 3; iEdge++ ) |
|
{ |
|
SetupFaceVert( iMipLevel, pMatch->m_iFaceEdges[iEdge], texelPos[iEdge] ); |
|
pImageData[iEdge] = ImageData( iFrame, pMatch->m_iFaces[iEdge], iMipLevel ); |
|
} |
|
|
|
if ( m_Format == IMAGE_FORMAT_DXT1 || m_Format == IMAGE_FORMAT_DXT5 ) |
|
{ |
|
if ( nMipWidth < 4 || nMipHeight < 4 ) |
|
return; |
|
|
|
// Copy the first palette index to the other blocks. |
|
S3PaletteIndex paletteIndex = S3TC_GetPaletteIndex( pImageData[0], m_Format, nMipWidth, texelPos[0].x, texelPos[0].y ); |
|
S3TC_SetPaletteIndex( pImageData[1], m_Format, nMipWidth, texelPos[1].x, texelPos[1].y, paletteIndex ); |
|
S3TC_SetPaletteIndex( pImageData[2], m_Format, nMipWidth, texelPos[2].x, texelPos[2].y, paletteIndex ); |
|
} |
|
else if ( m_Format == IMAGE_FORMAT_RGBA8888 ) |
|
{ |
|
// Setup pointers to the 3 corner texels. |
|
unsigned char *texels[3]; |
|
for ( iEdge=0; iEdge < 3; iEdge++ ) |
|
{ |
|
CEdgePos facePos; |
|
SetupFaceVert( iMipLevel, pMatch->m_iFaceEdges[iEdge], facePos ); |
|
|
|
texels[iEdge] = pImageData[iEdge]; |
|
texels[iEdge] += (facePos.y * nMipWidth + facePos.x) * 4; |
|
} |
|
|
|
// Now blend the texels. |
|
BlendTexels( texels, 3 ); |
|
} |
|
else |
|
{ |
|
Assert( false ); |
|
} |
|
} |
|
|
|
void CVTFTexture::BuildCubeMapMatchLists( |
|
CEdgeMatch edgeMatches[NUM_EDGE_MATCHES], |
|
CCornerMatch cornerMatches[NUM_CORNER_MATCHES], |
|
bool bSkybox ) |
|
{ |
|
|
|
int **faceVertsList = bSkybox ? g_skybox_FaceVerts : g_FaceVerts; |
|
|
|
// For each face, look for matching edges on other faces. |
|
int nTotalEdgesMatched = 0; |
|
for ( int iFace = 0; iFace < 6; iFace++ ) |
|
{ |
|
for ( int iEdge=0; iEdge < 4; iEdge++ ) |
|
{ |
|
int i1 = faceVertsList[iFace][iEdge]; |
|
int i2 = faceVertsList[iFace][(iEdge+1)%4]; |
|
|
|
// Only look for faces with indices < what we have so we don't do each edge twice. |
|
for ( int iOtherFace=0; iOtherFace < iFace; iOtherFace++ ) |
|
{ |
|
for ( int iOtherEdge=0; iOtherEdge < 4; iOtherEdge++ ) |
|
{ |
|
int o1 = faceVertsList[iOtherFace][iOtherEdge]; |
|
int o2 = faceVertsList[iOtherFace][(iOtherEdge+1)%4]; |
|
|
|
if ( (i1 == o1 && i2 == o2) || (i2 == o1 && i1 == o2) ) |
|
{ |
|
CEdgeMatch *pMatch = &edgeMatches[nTotalEdgesMatched]; |
|
|
|
pMatch->m_iFaces[0] = iFace; |
|
pMatch->m_iEdges[0] = iEdge; |
|
|
|
pMatch->m_iFaces[1] = iOtherFace; |
|
pMatch->m_iEdges[1] = iOtherEdge; |
|
|
|
pMatch->m_iCubeVerts[0] = o1; |
|
pMatch->m_iCubeVerts[1] = o2; |
|
|
|
pMatch->m_bFlipFace2Edge = i1 != o1; |
|
|
|
++nTotalEdgesMatched; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
Assert( nTotalEdgesMatched == 12 ); |
|
|
|
// For each corner vert, find the 3 edges touching it. |
|
for ( int iVert=0; iVert < NUM_CORNER_MATCHES; iVert++ ) |
|
{ |
|
int iTouchingFace = 0; |
|
|
|
for ( int iFace=0; iFace < 6; iFace++ ) |
|
{ |
|
for ( int iFaceVert=0; iFaceVert < 4; iFaceVert++ ) |
|
{ |
|
if ( faceVertsList[iFace][iFaceVert] == iVert ) |
|
{ |
|
cornerMatches[iVert].m_iFaces[iTouchingFace] = iFace; |
|
cornerMatches[iVert].m_iFaceEdges[iTouchingFace] = iFaceVert; |
|
++iTouchingFace; |
|
} |
|
} |
|
} |
|
Assert( iTouchingFace == 3 ); |
|
} |
|
} |
|
|
|
void CVTFTexture::BlendCubeMapEdgePalettes( |
|
int iFrame, |
|
int iMipLevel, |
|
const CEdgeMatch *pMatch ) |
|
{ |
|
Assert( m_Format == IMAGE_FORMAT_DXT1 || m_Format == IMAGE_FORMAT_DXT5 ); |
|
|
|
int nMipWidth, nMipHeight, nMipDepth; |
|
ComputeMipLevelDimensions( iMipLevel, &nMipWidth, &nMipHeight, &nMipDepth ); |
|
Assert( nMipDepth == 1 ); |
|
if ( nMipWidth <= 8 || nMipHeight <= 8 ) |
|
return; |
|
|
|
unsigned char *pFace1Data = ImageData( iFrame, pMatch->m_iFaces[0], iMipLevel ); |
|
unsigned char *pFace2Data = ImageData( iFrame, pMatch->m_iFaces[1], iMipLevel ); |
|
S3RGBA *pFace1Original = &m_OriginalData[ GetImageOffset( iFrame, pMatch->m_iFaces[0], iMipLevel, IMAGE_FORMAT_RGBA8888 ) / 4 ]; |
|
S3RGBA *pFace2Original = &m_OriginalData[ GetImageOffset( iFrame, pMatch->m_iFaces[1], iMipLevel, IMAGE_FORMAT_RGBA8888 ) / 4 ]; |
|
|
|
CEdgeIncrements incs; |
|
SetupTextureEdgeIncrements( iMipLevel, pMatch->m_iEdges[0], pMatch->m_iEdges[1], pMatch->m_bFlipFace2Edge, &incs ); |
|
|
|
// Divide the coordinates by 4 since we're dealing with S3 blocks here. |
|
incs.iFace1Start /= 4; incs.iFace1End /= 4; incs.iFace2Start /= 4; incs.iFace2End /= 4; |
|
|
|
// Now walk along the edges, blending the edge pixels. |
|
CEdgePos iFace1Cur = incs.iFace1Start + incs.iFace1Inc; |
|
CEdgePos iFace2Cur = incs.iFace2Start + incs.iFace2Inc; |
|
while ( iFace1Cur != incs.iFace1End ) // We intentionally want to not process the last block here.. |
|
{ |
|
// Merge the palette of these two blocks. |
|
char *blocks[2] = |
|
{ |
|
S3TC_GetBlock( pFace1Data, m_Format, nMipWidth>>2, iFace1Cur.x, iFace1Cur.y ), |
|
S3TC_GetBlock( pFace2Data, m_Format, nMipWidth>>2, iFace2Cur.x, iFace2Cur.y ) |
|
}; |
|
|
|
S3RGBA *originals[2] = |
|
{ |
|
&pFace1Original[(iFace1Cur.y * 4 * nMipWidth) + iFace1Cur.x * 4], |
|
&pFace2Original[(iFace2Cur.y * 4 * nMipWidth) + iFace2Cur.x * 4] |
|
}; |
|
|
|
S3TC_MergeBlocks( |
|
blocks, |
|
originals, |
|
2, |
|
nMipWidth*4, |
|
m_Format ); |
|
|
|
iFace1Cur += incs.iFace1Inc; |
|
iFace2Cur += incs.iFace2Inc; |
|
} |
|
} |
|
|
|
void CVTFTexture::BlendCubeMapCornerPalettes( |
|
int iFrame, |
|
int iMipLevel, |
|
const CCornerMatch *pMatch ) |
|
{ |
|
int nMipWidth, nMipHeight, nMipDepth; |
|
ComputeMipLevelDimensions( iMipLevel, &nMipWidth, &nMipHeight, &nMipDepth ); |
|
Assert( nMipDepth == 1 ); |
|
if ( nMipWidth < 4 || nMipHeight < 4 ) |
|
return; |
|
|
|
// Now setup an S3TC block pointer for each of the corner blocks on each face. |
|
char *blocks[3]; |
|
S3RGBA *originals[3]; |
|
|
|
for ( int iEdge=0; iEdge < 3; iEdge++ ) |
|
{ |
|
CEdgePos facePos; |
|
SetupFaceVert( iMipLevel, pMatch->m_iFaceEdges[iEdge], facePos ); |
|
facePos /= 4; // To get the S3 block index. |
|
|
|
int iFaceIndex = pMatch->m_iFaces[iEdge]; |
|
unsigned char *pFaceData = ImageData( iFrame, iFaceIndex, iMipLevel ); |
|
S3RGBA *pFaceOriginal = &m_OriginalData[ GetImageOffset( iFrame, iFaceIndex, iMipLevel, IMAGE_FORMAT_RGBA8888 ) / 4 ]; |
|
|
|
blocks[iEdge] = S3TC_GetBlock( pFaceData, m_Format, nMipWidth>>2, facePos.x, facePos.y ); |
|
originals[iEdge] = &pFaceOriginal[ (facePos.y * 4 * nMipWidth) + facePos.x * 4 ]; |
|
} |
|
|
|
S3TC_MergeBlocks( |
|
blocks, |
|
originals, |
|
3, |
|
nMipWidth*4, |
|
m_Format ); |
|
} |
|
|
|
void CVTFTexture::MatchCubeMapS3TCPalettes( |
|
CEdgeMatch edgeMatches[NUM_EDGE_MATCHES], |
|
CCornerMatch cornerMatches[NUM_CORNER_MATCHES] |
|
) |
|
{ |
|
for (int iMipLevel = 0; iMipLevel < m_nMipCount; ++iMipLevel) |
|
{ |
|
for (int iFrame = 0; iFrame < m_nFrameCount; ++iFrame) |
|
{ |
|
// First, match all the edge palettes (this part skips the first and last 4 texels |
|
// along the edge since those S3 blocks are handled in the corner case). |
|
for ( int iEdgeMatch=0; iEdgeMatch < NUM_EDGE_MATCHES; iEdgeMatch++ ) |
|
{ |
|
BlendCubeMapEdgePalettes( |
|
iFrame, |
|
iMipLevel, |
|
&edgeMatches[iEdgeMatch] ); |
|
} |
|
|
|
for ( int iCornerMatch=0; iCornerMatch < NUM_CORNER_MATCHES; iCornerMatch++ ) |
|
{ |
|
BlendCubeMapCornerPalettes( |
|
iFrame, |
|
iMipLevel, |
|
&cornerMatches[iCornerMatch] ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
void CVTFTexture::MatchCubeMapBorders( int iStage, ImageFormat finalFormat, bool bSkybox ) |
|
{ |
|
// HDRFIXME: hack hack hack |
|
if( m_Format != IMAGE_FORMAT_RGBA8888 ) |
|
{ |
|
return; |
|
} |
|
if ( !IsCubeMap() ) |
|
return; |
|
|
|
Assert( IsCubeMap() ); |
|
Assert( m_nFaceCount >= 6 ); |
|
|
|
if ( iStage == 1 ) |
|
{ |
|
// Stage 1 is while the image is still RGBA8888. If we're not going to S3 compress the image, |
|
// then it is easiest to match the borders now. |
|
Assert( m_Format == IMAGE_FORMAT_RGBA8888 ); |
|
if ( finalFormat == IMAGE_FORMAT_DXT1 || finalFormat == IMAGE_FORMAT_DXT5 ) |
|
{ |
|
// If we're going to S3 compress the image eventually, then store off the original version |
|
// because we can use that while matching the S3 compressed edges (we have to do some tricky |
|
// repalettizing). |
|
int nTotalBytes = ComputeTotalSize(); |
|
m_OriginalData.SetSize( nTotalBytes / 4 ); |
|
memcpy( m_OriginalData.Base(), ImageData(), nTotalBytes ); |
|
|
|
// Swap R and B in these because IMAGE_FORMAT_RGBA8888 is swapped from the way S3RGBAs are. |
|
for ( int i=0; i < nTotalBytes/4; i++ ) |
|
V_swap( m_OriginalData[i].r, m_OriginalData[i].b ); |
|
|
|
return; |
|
} |
|
else |
|
{ |
|
// Drop down below and do the edge matching. |
|
} |
|
} |
|
else |
|
{ |
|
if ( finalFormat == IMAGE_FORMAT_DXT1 || finalFormat == IMAGE_FORMAT_DXT5 ) |
|
{ |
|
Assert( m_Format == finalFormat ); |
|
} |
|
else |
|
{ |
|
// If we're not winding up S3 compressed, then we already fixed the cubemap borders. |
|
return; |
|
} |
|
} |
|
|
|
// Figure out |
|
CEdgeMatch edgeMatches[NUM_EDGE_MATCHES]; |
|
CCornerMatch cornerMatches[NUM_CORNER_MATCHES]; |
|
|
|
BuildCubeMapMatchLists( edgeMatches, cornerMatches, bSkybox ); |
|
|
|
// If we're S3 compressed, then during the first pass, we need to match the palettes of all |
|
// bordering S3 blocks. |
|
if ( m_Format == IMAGE_FORMAT_DXT1 || m_Format == IMAGE_FORMAT_DXT5 ) |
|
{ |
|
MatchCubeMapS3TCPalettes( edgeMatches, cornerMatches ); |
|
} |
|
|
|
for (int iMipLevel = 0; iMipLevel < m_nMipCount; ++iMipLevel) |
|
{ |
|
for (int iFrame = 0; iFrame < m_nFrameCount; ++iFrame) |
|
{ |
|
for ( int iEdgeMatch=0; iEdgeMatch < NUM_EDGE_MATCHES; iEdgeMatch++ ) |
|
{ |
|
BlendCubeMapFaceEdges( |
|
iFrame, |
|
iMipLevel, |
|
&edgeMatches[iEdgeMatch] ); |
|
} |
|
|
|
for ( int iCornerMatch=0; iCornerMatch < NUM_CORNER_MATCHES; iCornerMatch++ ) |
|
{ |
|
BlendCubeMapFaceCorners( |
|
iFrame, |
|
iMipLevel, |
|
&cornerMatches[iCornerMatch] ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
|
|
/* |
|
|
|
Test code used to draw the cubemap into a scratchpad file. Useful for debugging, or at least |
|
it was once. |
|
|
|
IScratchPad3D *pPad = ScratchPad3D_Create(); |
|
|
|
int nMipWidth, nMipHeight; |
|
ComputeMipLevelDimensions( 0, &nMipWidth, &nMipHeight ); |
|
|
|
CUtlVector<unsigned char> data; |
|
data.SetSize( nMipWidth*nMipHeight ); |
|
|
|
float cubeSize = 200; |
|
Vector vertPositions[8] = |
|
{ |
|
Vector( 0, cubeSize, 0 ), |
|
Vector( 0, cubeSize, cubeSize ), |
|
Vector( cubeSize, 0, 0 ), |
|
Vector( cubeSize, 0, cubeSize ), |
|
|
|
Vector( 0, 0, 0 ), |
|
Vector( 0, 0, cubeSize ), |
|
Vector( cubeSize, cubeSize, 0 ), |
|
Vector( cubeSize, cubeSize, cubeSize ) |
|
}; |
|
char *faceNames[6] = { "right","left","back","front","up","down" }; |
|
|
|
for ( int iVert=0; iVert < 8; iVert++ ) |
|
{ |
|
char str[512]; |
|
Q_snprintf( str, sizeof( str ), "%d", iVert ); |
|
CTextParams params; |
|
params.m_flLetterWidth = 20; |
|
params.m_vPos = vertPositions[iVert]; |
|
pPad->DrawText( str, params ); |
|
} |
|
|
|
for ( int iFace=0; iFace < 6; iFace++ ) |
|
{ |
|
unsigned char *pFace1Data = ImageData( 0, iFace, 0 ); |
|
for ( int y=0; y < nMipHeight; y++ ) |
|
{ |
|
for( int x=0; x < nMipWidth; x++ ) |
|
{ |
|
S3PaletteIndex index = S3TC_GetPaletteIndex( |
|
pFace1Data, |
|
m_Format, |
|
nMipWidth, |
|
x, y ); |
|
|
|
const char *pBlock = S3TC_GetBlock( pFace1Data, m_Format, nMipWidth/4, x/4, y/4 ); |
|
unsigned char a0 = pBlock[0]; |
|
unsigned char a1 = pBlock[1]; |
|
|
|
if ( index.m_AlphaIndex == 0 ) |
|
{ |
|
data[y*nMipWidth+x] = a0; |
|
} |
|
else if ( index.m_AlphaIndex == 1 ) |
|
{ |
|
data[y*nMipWidth+x] = a1; |
|
} |
|
else if ( a0 > a1 ) |
|
{ |
|
data[y*nMipWidth+x] = ((8-(int)index.m_AlphaIndex)*a0 + ((int)index.m_AlphaIndex-1)*a1) / 7; |
|
} |
|
else |
|
{ |
|
if ( index.m_AlphaIndex == 6 ) |
|
data[y*nMipWidth+x] = 0; |
|
else if ( index.m_AlphaIndex == 7 ) |
|
data[y*nMipWidth+x] = 255; |
|
else |
|
data[y*nMipWidth+x] = ((6-(int)index.m_AlphaIndex)*a0 + ((int)index.m_AlphaIndex-1)*a1) / 5; |
|
} |
|
} |
|
} |
|
|
|
Vector vCorners[4]; |
|
for ( int iCorner=0; iCorner < 4; iCorner++ ) |
|
vCorners[iCorner] = vertPositions[g_FaceVerts[iFace][iCorner]]; |
|
|
|
pPad->DrawImageBW( data.Base(), nMipWidth, nMipHeight, nMipWidth, false, true, vCorners ); |
|
|
|
CTextParams params; |
|
params.m_vPos = (vCorners[0] + vCorners[1] + vCorners[2] + vCorners[3]) / 4; |
|
params.m_bCentered = true; |
|
params.m_vColor.Init( 1, 0, 0 ); |
|
params.m_bTwoSided = true; |
|
params.m_flLetterWidth = 10; |
|
|
|
Vector vNormal = (vCorners[1] - vCorners[0]).Cross( vCorners[2] - vCorners[1] ); |
|
VectorNormalize( vNormal ); |
|
params.m_vPos += vNormal*5; |
|
VectorAngles( vNormal, params.m_vAngles ); |
|
|
|
pPad->DrawText( faceNames[iFace], params ); |
|
|
|
pPad->Flush(); |
|
} |
|
*/ |
|
|
|
|