vtf.cpp

//========= 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();
	}
*/