Backups/csgo-2018-source
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
93f753e8ef
csgo-2018-source/materialobjects/dmeamalgtexture.cpp

938 lines
27 KiB
C++
Raw Normal View History

uid issue
2021-07-25 12:11:47 +08:00
//===== Copyright <20> 2005-2006, Valve Corporation, All rights reserved. ======//
//
// Purpose: build a sheet data file and a large image out of multiple images
//
//===========================================================================//
#include "materialobjects/dmeamalgtexture.h"
#include "bitmap/floatbitmap.h"
#include "tier2/fileutils.h"
#include "datamodel/dmelementfactoryhelper.h"
#include "materialobjects/dmesheetsequence.h"
#include "resourcefile/schema/sheet.g.h"
#include "resourcefile/resourcestream.h"
#include "materialobjects/dmeimage.h"
#include "bitmap/psheet.h"
#include "tier0/dbg.h"
//-----------------------------------------------------------------------------
// Helper functions
//-----------------------------------------------------------------------------
static int GetChannelIndexFromChar( char c )
{
// r->0 b->1 g->2 a->3 else -1
static char s_ChannelIDs[] = "rgba";
char const *pChanChar = strchr( s_ChannelIDs, c );
if ( ! pChanChar )
{
Warning( " bad channel name '%c'\n", c );
return -1;
}
else
{
return pChanChar - s_ChannelIDs;
}
}
//-----------------------------------------------------------------------------
// Clear the contents of the channel
//-----------------------------------------------------------------------------
static void ZeroChannel( FloatBitMap_t *newBitmap, FloatBitMap_t *pBitmap, int nDestChannel )
{
for ( int y = 0; y < newBitmap->NumRows(); y++ )
{
for ( int x = 0; x < newBitmap->NumCols(); x++ )
{
pBitmap->Pixel( x, y, 0, nDestChannel ) = 0;
}
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static void CopyChannel( FloatBitMap_t *newBitmap, FloatBitMap_t *pBitmap, int nSrcChannel, int nDestChannel )
{
for ( int y = 0; y < newBitmap->NumRows(); y++ )
{
for ( int x = 0; x < newBitmap->NumCols(); x++ )
{
pBitmap->Pixel( x, y, 0, nDestChannel ) = newBitmap->Pixel( x, y, 0, nSrcChannel );
}
}
}
//-----------------------------------------------------------------------------
// Get a full path to fname that is under mod/content/materialsrc
// This is where all tgas live.
//-----------------------------------------------------------------------------
void GetFullPathUsingMaterialsrcContent( const char * fname, char *pFullTGAFileNameDest, int fullPathBufferSize )
{
char localTexturePath[MAX_PATH];
Q_snprintf( localTexturePath, sizeof(localTexturePath), "materialsrc\\%s", fname );
const char *result = g_pFullFileSystem->RelativePathToFullPath( localTexturePath, "CONTENT", pFullTGAFileNameDest, fullPathBufferSize );
if ( result == NULL )
{
Warning( "CDataModel: Unable to generate full path for file %s\n", fname );
pFullTGAFileNameDest = NULL;
}
}
//-----------------------------------------------------------------------------
// Get a full path to fname that is under the current directory.
// mksheet is meant to be run from a dir that contains all the tga files
// referred to by the .mks file. This fxn lets it find the local files.
//-----------------------------------------------------------------------------
void GetFullPathUsingCurrentDir( const char * fname, char *pFullTGAFileNameDest, int fullPathBufferSize )
{
char pDir[MAX_PATH];
if ( g_pFullFileSystem->GetCurrentDirectory( pDir, sizeof(pDir) ) )
{
CUtlString fullPathName = pDir;
fullPathName += "\\";
fullPathName += fname;
Q_strncpy( pFullTGAFileNameDest, fullPathName.Get(), fullPathBufferSize );
}
else
{
Warning( "CDataModel: Unable to generate full path for file %s\n", fname );
pFullTGAFileNameDest = NULL;
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static FloatBitMap_t *CreateFloatBitmap( const char *pFilename, bool bUseCurrentDir = false )
{
if ( strchr( pFilename, ',' ) == NULL )
{
char fullTGAFileName[ MAX_PATH ];
if ( Q_IsAbsolutePath( pFilename ) )
{
Q_strncpy( fullTGAFileName, pFilename, sizeof( fullTGAFileName ) );
}
else
{
if ( bUseCurrentDir )
{
GetFullPathUsingCurrentDir( pFilename, fullTGAFileName, sizeof(fullTGAFileName) );
}
else
{
GetFullPathUsingMaterialsrcContent( pFilename, fullTGAFileName, sizeof(fullTGAFileName) );
}
}
if ( fullTGAFileName == NULL )
{
Warning( "CDataModel: Unable to generate full path for file %s\n", pFilename );
}
return new FloatBitMap_t( fullTGAFileName );
}
// Warning this is Untested not in use currently.
// parse extended specifications
CUtlVector<char *> Images;
V_SplitString( pFilename, ",", Images );
FloatBitMap_t *pBitmap = NULL;
// now, process bitmaps, performing copy operations specified by {} syntax
for( int i = 0; i < Images.Count(); i++ )
{
char fnamebuf[MAX_PATH];
strcpy( fnamebuf, Images[i] );
char * pBrace = strchr( fnamebuf, '{' );
if ( pBrace )
{
*pBrace = 0; // null it
pBrace++; // point at control specifier
char *pEndBrace = strchr( pBrace, '}' );
if ( ! pEndBrace )
{
Msg( "bad extended bitmap synax (no close brace) - %s \n", Images[i] );
}
}
FloatBitMap_t newBitmap( fnamebuf );
if ( !pBitmap )
{
// first image sets size
pBitmap = new FloatBitMap_t( &newBitmap );
}
// now, process operation specifiers of the form "{chan=chan}" or "{chan=0}"
if ( pBrace && ( pBrace[1] == '=' ) )
{
int nDstChan = GetChannelIndexFromChar( pBrace[0] );
if ( nDstChan != -1 )
{
if ( pBrace[2] == '0' )
{
// zero the channel
ZeroChannel( &newBitmap, pBitmap, nDstChan );
}
else
{
int nSrcChan = GetChannelIndexFromChar( pBrace[2] );
if ( nSrcChan != -1 )
{
// perform the channel copy
CopyChannel( &newBitmap, pBitmap, nSrcChan, nDstChan );
}
}
}
}
}
return pBitmap;
}
//-----------------------------------------------------------------------------
// Expose this class to the scene database
//-----------------------------------------------------------------------------
IMPLEMENT_ELEMENT_FACTORY( DmeAmalgamatedTexture, CDmeAmalgamatedTexture );
void CDmeAmalgamatedTexture::OnConstruction()
{
m_ImageList.Init( this, "images" );
m_ePackingMode.InitAndSet( this, "packmode", PCKM_FLAT );
m_Sequences.Init( this, "sequences" );
m_nWidth.Init( this, "width" );
m_nHeight.Init( this, "height" );
m_pPackedImage.Init( this, "packedImage" );
m_SequenceCount = 0;
}
void CDmeAmalgamatedTexture::OnDestruction()
{
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeAmalgamatedTexture::Init( const char *pShtFileName, bool bUseCurrentDir )
{
CDisableUndoScopeGuard sg;
m_pCurSequence = NULL;
// Load up the image bitmaps.
char pFullDir[MAX_PATH];
Q_strncpy( pFullDir, pShtFileName, sizeof(pFullDir) );
Q_StripFilename( pFullDir );
char pFullPath[MAX_PATH];
for( int i = 0; i < m_ImageList.Count(); i++ )
{
// FIXME: Ugh!
const char *pImageName = m_ImageList[i]->GetName();
if ( bUseCurrentDir && Q_IsAbsolutePath( pShtFileName ) )
{
Q_ComposeFileName( pFullDir, pImageName, pFullPath, sizeof(pFullPath) );
pImageName = pFullPath;
}
m_ImageList[i]->m_pImage = CreateFloatBitmap( pImageName, bUseCurrentDir );
}
m_SequenceCount = 0;
}
//-----------------------------------------------------------------------------
// Whether the frames loop or not
//-----------------------------------------------------------------------------
void CDmeAmalgamatedTexture::SetCurrentSequenceClamp( bool bState )
{
if ( m_pCurSequence )
{
m_pCurSequence->m_Clamp = bState;
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CDmeAmalgamatedTexture::GetPackingMode()
{
return m_ePackingMode;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeAmalgamatedTexture::SetPackingMode( int eMode )
{
// Assign the packing mode read in to member var.
if ( !m_Sequences.Count() )
{
m_ePackingMode = eMode;
}
else if ( m_ePackingMode != eMode )
{
// Allow special changes:
// flat -> rgb+a
if ( m_ePackingMode == PCKM_FLAT && eMode == PCKM_RGB_A )
{
m_ePackingMode = eMode;
}
// everything else
else
{
Warning( "*** line error: incompatible packmode change when %d sequences already defined!\n", m_Sequences.Count() );
}
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CDmeAmalgamatedTexture::CreateNewSequence( int mode )
{
m_pCurSequence = CreateElement<CDmeSheetSequence>( "", GetFileId() );
m_pCurSequence->m_nSequenceNumber = m_SequenceCount;
m_SequenceCount++;
SetSequenceType( mode );
m_Sequences.AddToTail( m_pCurSequence );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int CDmeAmalgamatedTexture::GetSequenceType()
{
return m_pCurSequence->m_eMode;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CDmeAmalgamatedTexture::SetSequenceType( int eMode )
{
m_pCurSequence->m_eMode = eMode;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CDmeAmalgamatedTexture::CurrentSequenceExists()
{
return m_pCurSequence != NULL;
}
//-----------------------------------------------------------------------------
// Validate that image packing is correct
//-----------------------------------------------------------------------------
void CDmeAmalgamatedTexture::ValidateImagePacking( CDmeSheetImage *pBitmap, char *pImageName )
{
if ( m_ePackingMode == PCKM_RGB_A )
{
for ( uint16 idx = 0; idx < pBitmap->m_mapSequences.Count(); ++idx )
{
CDmeSheetSequence *pSeq = pBitmap->FindSequence( idx );
Assert( pSeq );
if ( pSeq->m_eMode != SQM_RGBA &&
pSeq->m_eMode != m_pCurSequence->m_eMode )
{
Warning( "*** line error: 'rgb+a' packing cannot pack image '%s' belonging to sequences %d and %d!\n",
pImageName,
pSeq->m_nSequenceNumber,
m_pCurSequence->m_nSequenceNumber );
}
}
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CDmeAmalgamatedTexture::CreateFrame( CUtlVector<char *> &imageNames, float ftime )
{
CDmeSheetSequenceFrame *pNewFrame = CreateElement<CDmeSheetSequenceFrame>( "", GetFileId() );
pNewFrame->m_fDisplayTime = ftime;
for ( int i = 0; i < imageNames.Count(); i++ )
{
Assert( imageNames.Count() <= MAX_IMAGES_PER_FRAME );
AddImage( pNewFrame, imageNames[i] );
}
m_pCurSequence->m_Frames.AddToTail( pNewFrame->GetHandle() );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CDmeAmalgamatedTexture::AddImage( CDmeSheetSequenceFrame *pNewSequenceFrame, char *pImageName )
{
// Store the image in the image list, this is a string - bitmap mapping.
CDmeSheetImage *pBitmap = FindImage( pImageName );
if ( !pBitmap )
{
CDmeSheetImage *pBitmap = CreateElement<CDmeSheetImage>( pImageName, GetFileId() );
pBitmap->m_pImage = CreateFloatBitmap( pImageName );
m_ImageList.AddToTail( pBitmap );
}
pBitmap = FindImage( pImageName );
Assert( pBitmap );
pNewSequenceFrame->m_pSheetImages.AddToTail( pBitmap );
ValidateImagePacking( pBitmap, pImageName );
pBitmap->m_mapSequences.AddToTail( m_pCurSequence);
}
//-----------------------------------------------------------------------------
// Calls packimages with different widths to find the best size.
//-----------------------------------------------------------------------------
bool CDmeAmalgamatedTexture::DetermineBestPacking()
{
int nBestWidth = -1;
int nBestSize = (1 << 30 );
int nBestSquareness = ( 1 << 30 ); // how square the texture is
for( int nTryWidth = 2048; nTryWidth >= 64; nTryWidth >>= 1 )
{
bool bSuccess = PackImages( false, nTryWidth );
if ( !bSuccess )
break;
// Msg( "Packing option: %d x %d (%d pixels)\n", m_nWidth.Get(), m_nHeight.Get(), m_nWidth.Get() * m_nHeight.Get() );
bool bPreferThisPack = false;
int thisSize = m_nHeight * m_nWidth;
int thisSquareness = ( m_nWidth.Get() == m_nHeight.Get() ) ? 1 : ( m_nHeight / m_nWidth + m_nWidth / m_nHeight );
if ( thisSize < nBestSize )
{
while ( (nTryWidth >> 1) >= m_nWidth )
nTryWidth >>= 1;
bPreferThisPack = true;
}
else if ( thisSize == nBestSize && thisSquareness < nBestSquareness )
{
bPreferThisPack = true;
}
if ( bPreferThisPack )
{
nBestWidth = nTryWidth;
nBestSize = thisSize;
nBestSquareness = thisSquareness;
}
}
if ( nBestWidth < 0 )
{
Warning( "Packing error: failed to pack images!\n" );
return false;
}
m_nWidth = nBestWidth;
m_nHeight = nBestSize / nBestWidth;
// Msg( "Best option: %d x %d (%d pixels)%s\n", m_nWidth.Get(), m_nHeight.Get(), m_nWidth.Get() * m_nHeight.Get(), ( m_nWidth.Get() == m_nHeight.Get() ) ? " : square texture" : "" );
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CDmeAmalgamatedTexture::PackImages( bool bGenerateImage, int nWidth )
{
if ( !m_pPackedImage )
{
m_pPackedImage = CreateElement< CDmeImage >( GetName(), GetFileId() );
}
switch ( m_ePackingMode )
{
case PCKM_FLAT:
return PackImagesFlat( bGenerateImage, nWidth );
case PCKM_RGB_A:
return PackImagesRGBA( bGenerateImage, nWidth );
case PCKM_INVALID:
default:
return false;
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CDmeAmalgamatedTexture::PackImagesFlat( bool bGenerateImage, int nWidth )
{
int nMaxWidth = nWidth;
int nMaxHeight = 2048;
// !! bug !! packing algorithm is dumb and no error checking is done!
FloatBitMap_t &output = m_pPackedImage->BeginFloatBitmapModification();
if ( bGenerateImage )
{
output.Init( nMaxWidth, nMaxHeight );
}
int cur_line = 0;
int cur_column = 0;
int next_line = 0;
int max_column_written = 0;
for ( int i = 0; i < m_ImageList.Count(); i++ )
{
CDmeSheetImage &sheetImage = *(m_ImageList[i]);
if ( sheetImage.m_pImage == NULL )
{
Warning( "CDataModel: Image %s was not loaded! Unable to pack.\n", sheetImage.GetName() );
m_pPackedImage->EndFloatBitmapModification();
return false;
}
if ( cur_column + sheetImage.m_pImage->NumCols() > nMaxWidth )
{
// no room!
cur_column = 0;
cur_line = next_line;
next_line = cur_line;
}
// now, pack
if ( ( cur_column + sheetImage.m_pImage->NumCols() > nMaxWidth ) ||
( cur_line + sheetImage.m_pImage->NumRows() > nMaxHeight ) )
{
m_pPackedImage->EndFloatBitmapModification();
return false; // didn't fit! doh
}
sheetImage.m_XCoord = cur_column;
sheetImage.m_YCoord = cur_line;
if ( bGenerateImage ) // don't actually pack the pixel if we're not keeping them
{
int ic[4];
int nc = sheetImage.m_pImage->ComputeValidAttributeList( ic );
for ( int y = 0; y < sheetImage.m_pImage->NumRows(); y++ )
{
for ( int x = 0; x < sheetImage.m_pImage->NumCols(); x++ )
{
for ( int c = 0; c < nc; c++ )
{
output.Pixel( x + cur_column, y + cur_line, 0, ic[c] ) = sheetImage.m_pImage->Pixel( x, y, 0, ic[c] );
}
}
}
}
next_line = MAX( next_line, cur_line + sheetImage.m_pImage->NumRows() );
cur_column += sheetImage.m_pImage->NumCols();
max_column_written = MAX( max_column_written, cur_column );
}
// now, truncate height
int h = 1;
for( h; h < next_line; h *= 2 )
;
// truncate width;
int w = 1;
for( 1; w < max_column_written; w *= 2 )
;
if ( bGenerateImage )
{
output.Crop( 0, 0, 0, w, h, 1 );
}
// Store these for UV calculation later on
m_nHeight = h;
m_nWidth = w;
m_pPackedImage->EndFloatBitmapModification();
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CDmeAmalgamatedTexture::PackImagesRGBA( bool bGenerateImage, int nWidth )
{
int nMaxWidth = nWidth;
int nMaxHeight = 2048;
// !! bug !! packing algorithm is dumb and no error checking is done!
FloatBitMap_t &output = m_pPackedImage->BeginFloatBitmapModification();
if ( bGenerateImage )
{
output.Init( nMaxWidth, nMaxHeight );
}
int cur_line[2] = {0};
int cur_column[2] = {0};
int next_line[2] = {0};
int max_column_written[2] = {0};
bool bPackingRGBA = true;
for ( int i = 0; i < m_ImageList.Count(); i++ )
{
CDmeSheetImage &sheetImage = *( m_ImageList[i] );
if ( sheetImage.m_pImage == NULL )
{
Warning( "CDataModel: Image %s was not loaded! Unable to pack.\n", sheetImage.GetName() );
m_pPackedImage->EndFloatBitmapModification();
return false;
}
int idxfrm;
CDmeSheetSequence *pSequence = sheetImage.FindSequence( 0 );
Assert( pSequence );
int eMode = pSequence->m_eMode;
switch ( eMode )
{
case SQM_RGB:
idxfrm = 0;
bPackingRGBA = false;
break;
case SQM_ALPHA:
idxfrm = 1;
bPackingRGBA = false;
break;
case SQM_RGBA:
if ( !bPackingRGBA )
{
Msg( "*** error when packing 'rgb+a', bad sequence %d encountered for image '%s' after all rgba frames packed!\n",
pSequence->m_nSequenceNumber,
m_ImageList[i]->GetName() );
m_pPackedImage->EndFloatBitmapModification();
return false;
}
idxfrm = 0;
break;
default:
{
Msg( "*** error when packing 'rgb+a', bad sequence %d encountered for image '%s'!\n",
pSequence->m_nSequenceNumber,
m_ImageList[i]->GetName() );
m_pPackedImage->EndFloatBitmapModification();
return false;
}
}
if ( cur_column[idxfrm] + sheetImage.m_pImage->NumCols() > nMaxWidth )
{
// no room!
cur_column[idxfrm] = 0;
cur_line[idxfrm] = next_line[idxfrm];
next_line[idxfrm] = cur_line[idxfrm];
}
// now, pack
if ( ( cur_column[idxfrm] + sheetImage.m_pImage->NumCols() > nMaxWidth ) ||
( cur_line[idxfrm] + sheetImage.m_pImage->NumRows() > nMaxHeight ) )
{
return false; // didn't fit! doh
}
sheetImage.m_XCoord = cur_column[idxfrm];
sheetImage.m_YCoord = cur_line[idxfrm];
if ( bGenerateImage ) // don't actually pack the pixel if we're not keeping them
{
for ( int y = 0; y < sheetImage.m_pImage->NumRows(); y++ )
{
for ( int x = 0; x < sheetImage.m_pImage->NumCols(); x++ )
{
for ( int c = 0; c < 4; c++ )
{
switch ( eMode )
{
case SQM_RGB:
if ( c < 3 )
goto setpx;
break;
case SQM_ALPHA:
if ( c == 3 )
goto setpx;
break;
case SQM_RGBA:
if ( c < 4 )
goto setpx;
break;
setpx:
output.Pixel( x + cur_column[idxfrm], y + cur_line[idxfrm], 0, c ) = sheetImage.m_pImage->Pixel(x, y, 0, c);
break;
}
}
}
}
}
next_line[idxfrm] = MAX( next_line[idxfrm], cur_line[idxfrm] + sheetImage.m_pImage->NumRows() );
cur_column[idxfrm] += sheetImage.m_pImage->NumCols();
max_column_written[idxfrm] = MAX( max_column_written[idxfrm], cur_column[idxfrm] );
if ( bPackingRGBA )
{
cur_line[1] = cur_line[0];
cur_column[1] = cur_column[0];
next_line[1] = next_line[0];
max_column_written[1] = max_column_written[0];
}
}
// now, truncate height
int h = 1;
for ( int idxfrm = 0; idxfrm < 2; ++idxfrm )
{
for ( h; h < next_line[idxfrm]; h *= 2 )
continue;
}
// truncate width;
int w = 1;
for ( int idxfrm = 0; idxfrm < 2; ++idxfrm )
{
for ( w; w < max_column_written[idxfrm]; w *= 2 )
continue;
}
if ( bGenerateImage )
{
output.Crop( 0, 0, 0, w, h, 1 );
}
// Store these for UV calculation later on
m_nHeight = h;
m_nWidth = w;
m_pPackedImage->EndFloatBitmapModification();
return true;
}
//-----------------------------------------------------------------------------
// Write out .sht file.
//-----------------------------------------------------------------------------
bool CDmeAmalgamatedTexture::WriteTGA( const char *pFileName )
{
if ( !pFileName )
goto tgaWriteFailed;
if ( !m_pPackedImage )
goto tgaWriteFailed;
if ( !m_pPackedImage->FloatBitmap()->WriteTGAFile( pFileName ) )
goto tgaWriteFailed;
Msg( "Ok: successfully saved TGA \"%s\"\n", pFileName );
return true;
tgaWriteFailed:
Msg( "Error: failed to save TGA \"%s\"!\n", pFileName );
return false;
}
//-----------------------------------------------------------------------------
// Write out .sht file.
//-----------------------------------------------------------------------------
void CDmeAmalgamatedTexture::WriteFile( const char *pFileName, bool bVerbose )
{
if ( !pFileName )
{
Msg( "Error: No output filename set!\n" );
return;
}
COutputFile Outfile( pFileName );
if ( !Outfile.IsOk() )
{
Msg( "Error: failed to write SHT \"%s\"!\n", pFileName );
return;
}
Outfile.PutInt( 1 ); // version #
Outfile.PutInt( m_Sequences.Count() );
// Debugging.
if ( bVerbose )
{
Msg( "1\n");
Msg( "m_Sequences.Count() %d\n", m_Sequences.Count());
}
for ( int i = 0; i < m_Sequences.Count(); i++ )
{
Outfile.PutInt( m_Sequences[i]->m_nSequenceNumber );
int nSeqFlags = 0;
if ( m_Sequences[i]->m_Clamp )
{
nSeqFlags |= SEQ_FLAG_CLAMP;
}
if ( m_Sequences[i]->m_eMode == SQM_RGB )
{
nSeqFlags |= SEQ_FLAG_NO_ALPHA;
}
else if ( m_Sequences[i]->m_eMode == SQM_ALPHA )
{
nSeqFlags |= SEQ_FLAG_NO_COLOR;
}
Outfile.PutInt( nSeqFlags );
Outfile.PutInt( m_Sequences[i]->m_Frames.Count() );
// write total sequence length
float fTotal = 0.0;
for ( int j = 0; j < m_Sequences[i]->m_Frames.Count(); j++ )
{
fTotal += m_Sequences[i]->m_Frames[j]->m_fDisplayTime;
}
Outfile.PutFloat( fTotal );
// Debugging.
if ( bVerbose )
{
Msg( "m_Sequences[%d]->m_nSequenceNumber %d\n", i, m_Sequences[i]->m_nSequenceNumber.Get() );
Msg( "m_Sequences[%d]->m_Clamp %d\n", i, m_Sequences[i]->m_Clamp?1:0 );
Msg( "m_Sequences[%d] flags %d\n", i, nSeqFlags );
Msg( "m_Sequences[%d]->m_Frames.Count() %d\n", i, m_Sequences[i]->m_Frames.Count());
Msg( "fTotal %f\n", fTotal );
}
for( int j = 0; j < m_Sequences[i]->m_Frames.Count(); j++ )
{
Outfile.PutFloat( m_Sequences[i]->m_Frames[j]->m_fDisplayTime );
if ( bVerbose )
{
Msg( "m_Sequences[%d]->m_Frames[%d]->m_fDisplayTime %f\n", i, j, m_Sequences[i]->m_Frames[j]->m_fDisplayTime.Get() );
}
// output texture coordinates
Assert( m_Sequences[i]->m_Frames[j]->m_pSheetImages.Count() > 0 );
for( int t = 0; t < m_Sequences[i]->m_Frames[j]->m_pSheetImages.Count(); t++ )
{
//xmin
Outfile.PutFloat( UCoord( m_Sequences[i]->m_Frames[j]->m_pSheetImages[t]->m_XCoord ) );
//ymin
Outfile.PutFloat( VCoord( m_Sequences[i]->m_Frames[j]->m_pSheetImages[t]->m_YCoord ) );
//xmax
Outfile.PutFloat(
UCoord( m_Sequences[i]->m_Frames[j]->m_pSheetImages[t]->m_XCoord +
m_Sequences[i]->m_Frames[j]->m_pSheetImages[t]->m_pImage->NumCols() - 1 ));
//ymax
Outfile.PutFloat(
VCoord( m_Sequences[i]->m_Frames[j]->m_pSheetImages[t]->m_YCoord +
m_Sequences[i]->m_Frames[j]->m_pSheetImages[t]->m_pImage->NumRows() - 1 ));
// Debugging.
if ( bVerbose )
{
Msg( "xmin %f\n", UCoord( m_Sequences[i]->m_Frames[j]->m_pSheetImages[t]->m_XCoord ) );
Msg( "ymin %f\n", VCoord( m_Sequences[i]->m_Frames[j]->m_pSheetImages[t]->m_YCoord ) );
Msg( "xmax %f\n", UCoord( m_Sequences[i]->m_Frames[j]->m_pSheetImages[t]->m_XCoord +
m_Sequences[i]->m_Frames[j]->m_pSheetImages[t]->m_pImage->NumCols() - 1 ) );
Msg( "ymax %f\n", VCoord( m_Sequences[i]->m_Frames[j]->m_pSheetImages[t]->m_YCoord +
m_Sequences[i]->m_Frames[j]->m_pSheetImages[t]->m_pImage->NumRows() - 1 ) );
}
}
// Sequenceframes must have 4 entries in the .sht file.
// We store up to 4 in the dme elements
// Add in the missing entries as dummy data.
for( int t = m_Sequences[i]->m_Frames[j]->m_pSheetImages.Count(); t < MAX_IMAGES_PER_FRAME; t++ )
{
Outfile.PutFloat(0.0);
Outfile.PutFloat(0.0);
Outfile.PutFloat(0.0);
Outfile.PutFloat(0.0);
// Debugging.
if ( bVerbose )
{
Msg( "xmin %f\nymin %f\nxmax %f\nymax %f\n", 0.0, 0.0, 0.0 ,0.0 );
}
}
}
}
Msg( "Ok: successfully saved SHT \"%s\"\n", pFileName );
}
//-----------------------------------------------------------------------------
// Write out .sht file.
//-----------------------------------------------------------------------------
void *CDmeAmalgamatedTexture::WriteFile( CResourceStream *pStream, ResourceId_t nTextureResourceId )
{
Sheet_t *pSheet = pStream->Allocate< Sheet_t >( 1 );
pSheet->m_hTexture.WriteReference( nTextureResourceId );
int nCount = m_Sequences.Count();
pSheet->m_Sequences = pStream->Allocate< SheetSequence_t >( nCount );
for ( int i = 0; i < nCount; i++ )
{
CDmeSheetSequence *pDmeSeq = m_Sequences[i];
SheetSequence_t &seq = pSheet->m_Sequences[i];
seq.m_nId = pDmeSeq->m_nSequenceNumber;
seq.m_bClamp = pDmeSeq->m_Clamp;
int nFrameCount = pDmeSeq->m_Frames.Count();
seq.m_Frames = pStream->Allocate< SheetSequenceFrame_t >( nFrameCount );
seq.m_flTotalTime = 0.0;
for( int j = 0; j < nFrameCount; j++ )
{
CDmeSheetSequenceFrame *pDmeFrame = pDmeSeq->m_Frames[j];
SheetSequenceFrame_t &frame = seq.m_Frames[i];
// Compute total sequence length
seq.m_flTotalTime += pDmeFrame->m_fDisplayTime;
frame.m_flDisplayTime = pDmeFrame->m_fDisplayTime;
int nImageCount = pDmeFrame->m_pSheetImages.Count();
frame.m_Images = pStream->Allocate< SheetFrameImage_t >( nImageCount );
// output texture coordinates
Assert( nImageCount > 0 );
for( int t = 0; t < nImageCount; t++ )
{
CDmeSheetImage *pDmeImage = pDmeFrame->m_pSheetImages[t];
SheetFrameImage_t &image = frame.m_Images[t];
image.uv[0].x = UCoord( pDmeImage->m_XCoord );
image.uv[0].y = VCoord( pDmeImage->m_YCoord );
image.uv[1].x = UCoord( pDmeImage->m_XCoord + pDmeImage->m_pImage->NumCols() - 1 );
image.uv[1].y = VCoord( pDmeImage->m_YCoord + pDmeImage->m_pImage->NumRows() - 1 );
}
}
}
return pSheet;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
CDmeSheetImage *CDmeAmalgamatedTexture::FindImage( const char *pImageName )
{
int nCount = m_ImageList.Count();
for ( int i = 0; i < nCount; ++i )
{
CDmeSheetImage *pImage = m_ImageList[i];
if ( !Q_stricmp( pImageName, pImage->GetName() ) )
return pImage;
}
return NULL;
}
Reference in New Issue Copy Permalink