3494 lines
96 KiB
C++
3494 lines
96 KiB
C++
//========= 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, VTFFileBaseHeader_t )
|
|
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, VTFFileHeaderV7_1_t )
|
|
DEFINE_FIELD( depth, FIELD_SHORT ),
|
|
END_DATADESC()
|
|
|
|
BEGIN_BYTESWAP_DATADESC_( VTFFileHeaderV7_3_t, VTFFileHeaderV7_2_t )
|
|
DEFINE_FIELD( numResources, FIELD_INTEGER ),
|
|
END_DATADESC()
|
|
|
|
BEGIN_BYTESWAP_DATADESC_( VTFFileHeader_t, VTFFileHeaderV7_2_t )
|
|
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 )
|
|
{
|
|
delete pTexture;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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 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 ( !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 ( IsX360() && ( iFlags & TEXTUREFLAGS_ENVMAP ) )
|
|
{
|
|
// 360 has no reason to support sphere map
|
|
m_nFaceCount = 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))
|
|
{
|
|
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;
|
|
|
|
// For backwards compatibility, we don't read in the spheremap fallback on
|
|
// older format .VTF files...
|
|
int nFacesToRead = m_nFaceCount;
|
|
if ( IsCubeMap() )
|
|
{
|
|
if ((header.version[0] == 7) && (header.version[1] < 1))
|
|
nFacesToRead = 6;
|
|
}
|
|
|
|
// Even if we are preloading partial data, always do the full allocation here. We'll use LOD clamping to ensure we only
|
|
// reference data that is available.
|
|
if ( !AllocateImageData( iImageSize ) )
|
|
return false;
|
|
|
|
// We may only have part of the data available--if so we will stream in the rest later.
|
|
// If we have the data available but we're ignoring it (for example during development), then we
|
|
// need to skip over the data we're ignoring below, otherwise we'll be sad pandas.
|
|
bool bMipDataPresent = true;
|
|
int nFirstAvailableMip = 0;
|
|
int nLastAvailableMip = m_nMipCount - 1;
|
|
TextureStreamSettings_t const *pStreamSettings = ( TextureStreamSettings_t const * ) GetResourceData( VTF_RSRC_TEXTURE_STREAM_SETTINGS, NULL );
|
|
if ( pStreamSettings )
|
|
{
|
|
nFirstAvailableMip = Max( 0, pStreamSettings->m_firstAvailableMip - nSkipMipLevels );
|
|
nLastAvailableMip = Max( 0, pStreamSettings->m_lastAvailableMip - nSkipMipLevels );
|
|
bMipDataPresent = false;
|
|
}
|
|
|
|
// If we have coarse mips but not the fine mips (yet)
|
|
if ( ( header.flags & TEXTUREFLAGS_STREAMABLE ) == TEXTUREFLAGS_STREAMABLE_COARSE )
|
|
{
|
|
nFirstAvailableMip = Max( 0, Max( nFirstAvailableMip, STREAMING_START_MIPMAP ) - nSkipMipLevels );
|
|
}
|
|
|
|
if ( header.flags & TEXTUREFLAGS_STREAMABLE_FINE )
|
|
{
|
|
// Don't need to subtract nSkipMipLevels: m_nMipCount has subtracted that above--assuming this assert doesn't fire.
|
|
Assert( m_nMipCount == header.numMipLevels - nSkipMipLevels );
|
|
nLastAvailableMip = Min( nLastAvailableMip, STREAMING_START_MIPMAP - 1 );
|
|
}
|
|
|
|
// Valid settings?
|
|
Assert( nFirstAvailableMip >= 0 && nFirstAvailableMip <= nLastAvailableMip && nLastAvailableMip < m_nMipCount );
|
|
|
|
// Store the clamp settings
|
|
m_nFinestMipmapLevel = nFirstAvailableMip;
|
|
m_nCoarsestMipmapLevel = nLastAvailableMip;
|
|
|
|
// 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
|
|
for (int iMip = m_nMipCount; --iMip >= 0; )
|
|
{
|
|
// NOTE: This is for older versions...
|
|
if (header.numMipLevels - nSkipMipLevels <= iMip)
|
|
continue;
|
|
|
|
int iMipSize = ComputeMipSize( iMip );
|
|
|
|
// Skip over any levels we don't have data for--we'll get them later.
|
|
if ( iMip > nLastAvailableMip || iMip < nFirstAvailableMip )
|
|
{
|
|
// If the data is there but we're ignoring it, need to update the get pointer.
|
|
if ( bMipDataPresent )
|
|
{
|
|
for ( int iFrame = 0; iFrame < m_nFrameCount; ++iFrame )
|
|
for ( int iFace = 0; iFace < nFacesToRead; ++iFace )
|
|
buf.SeekGet( CUtlBuffer::SEEK_CURRENT, iMipSize );
|
|
}
|
|
continue;
|
|
}
|
|
|
|
for (int iFrame = 0; iFrame < m_nFrameCount; ++iFrame)
|
|
{
|
|
for (int iFace = 0; iFace < nFacesToRead; ++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 );
|
|
}
|
|
}
|
|
}
|
|
|
|
return buf.IsValid();
|
|
}
|
|
|
|
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 )
|
|
{
|
|
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) );
|
|
|
|
#if defined( _X360 ) || defined (POSIX)
|
|
// read 15 dummy bytes to be properly positioned with 7.2 PC data
|
|
byte dummy[15];
|
|
buf.Get( dummy, 15 );
|
|
#endif
|
|
}
|
|
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) );
|
|
|
|
#if defined( _X360 ) || defined (POSIX)
|
|
// read a dummy byte to be properly positioned with 7.0/1 PC data
|
|
byte dummy;
|
|
buf.Get( &dummy, 1 );
|
|
#endif
|
|
}
|
|
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] == 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 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 );
|
|
|
|
// 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_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();
|
|
}
|
|
*/
|
|
|