767 lines
18 KiB
C++
767 lines
18 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================//
|
|
#include "incremental.h"
|
|
#include "lightmap.h"
|
|
|
|
|
|
|
|
static bool g_bFileError = false;
|
|
|
|
|
|
// -------------------------------------------------------------------------------- //
|
|
// Static helpers.
|
|
// -------------------------------------------------------------------------------- //
|
|
|
|
static bool CompareLights( dworldlight_t *a, dworldlight_t *b )
|
|
{
|
|
static float flEpsilon = 1e-7;
|
|
|
|
bool a1 = VectorsAreEqual( a->origin, b->origin, flEpsilon );
|
|
bool a2 = VectorsAreEqual( a->intensity, b->intensity, 1.1f ); // intensities are huge numbers
|
|
bool a3 = VectorsAreEqual( a->normal, b->normal, flEpsilon );
|
|
bool a4 = fabs( a->constant_attn - b->constant_attn ) < flEpsilon;
|
|
bool a5 = fabs( a->linear_attn - b->linear_attn ) < flEpsilon;
|
|
bool a6 = fabs( a->quadratic_attn - b->quadratic_attn ) < flEpsilon;
|
|
bool a7 = fabs( float( a->flags - b->flags ) ) < flEpsilon;
|
|
bool a8 = fabs( a->stopdot - b->stopdot ) < flEpsilon;
|
|
bool a9 = fabs( a->stopdot2 - b->stopdot2 ) < flEpsilon;
|
|
bool a10 = fabs( a->exponent - b->exponent ) < flEpsilon;
|
|
bool a11 = fabs( a->radius - b->radius ) < flEpsilon;
|
|
|
|
return a1 && a2 && a3 && a4 && a5 && a6 && a7 && a8 && a9 && a10 && a11;
|
|
}
|
|
|
|
|
|
long FileOpen( char const *pFilename, bool bRead )
|
|
{
|
|
g_bFileError = false;
|
|
return (long)g_pFileSystem->Open( pFilename, bRead ? "rb" : "wb" );
|
|
}
|
|
|
|
|
|
void FileClose( long fp )
|
|
{
|
|
if( fp )
|
|
g_pFileSystem->Close( (FILE*)fp );
|
|
}
|
|
|
|
|
|
// Returns true if there was an error reading from the file.
|
|
bool FileError()
|
|
{
|
|
return g_bFileError;
|
|
}
|
|
|
|
static inline void FileRead( long fp, void *pOut, int size )
|
|
{
|
|
if( g_bFileError || g_pFileSystem->Read( pOut, size, (FileHandle_t)fp ) != size )
|
|
{
|
|
g_bFileError = true;
|
|
memset( pOut, 0, size );
|
|
}
|
|
}
|
|
|
|
|
|
template<class T>
|
|
static inline void FileRead( long fp, T &out )
|
|
{
|
|
FileRead( fp, &out, sizeof(out) );
|
|
}
|
|
|
|
|
|
static inline void FileWrite( long fp, void const *pData, int size )
|
|
{
|
|
if( g_bFileError || g_pFileSystem->Write( pData, size, (FileHandle_t)fp ) != size )
|
|
{
|
|
g_bFileError = true;
|
|
}
|
|
}
|
|
|
|
|
|
template<class T>
|
|
static inline void FileWrite( long fp, T out )
|
|
{
|
|
FileWrite( fp, &out, sizeof(out) );
|
|
}
|
|
|
|
|
|
IIncremental* GetIncremental()
|
|
{
|
|
static CIncremental inc;
|
|
return &inc;
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------------------- //
|
|
// CIncremental.
|
|
// -------------------------------------------------------------------------------- //
|
|
|
|
CIncremental::CIncremental()
|
|
{
|
|
m_TotalMemory = 0;
|
|
m_pIncrementalFilename = NULL;
|
|
m_pBSPFilename = NULL;
|
|
m_bSuccessfulRun = false;
|
|
}
|
|
|
|
|
|
CIncremental::~CIncremental()
|
|
{
|
|
}
|
|
|
|
|
|
bool CIncremental::Init( char const *pBSPFilename, char const *pIncrementalFilename )
|
|
{
|
|
m_pBSPFilename = pBSPFilename;
|
|
m_pIncrementalFilename = pIncrementalFilename;
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CIncremental::PrepareForLighting()
|
|
{
|
|
if( !m_pBSPFilename )
|
|
return false;
|
|
|
|
// Clear the touched faces list.
|
|
m_FacesTouched.SetSize( numfaces );
|
|
memset( m_FacesTouched.Base(), 0, numfaces );
|
|
|
|
// If we haven't done a complete successful run yet, then we either haven't
|
|
// loaded the lights, or a run was aborted and our lights are half-done so we
|
|
// should reload them.
|
|
if( !m_bSuccessfulRun )
|
|
LoadIncrementalFile();
|
|
|
|
// unmatched = a list of the lights we have
|
|
CUtlLinkedList<int,int> unmatched;
|
|
for( int i=m_Lights.Head(); i != m_Lights.InvalidIndex(); i = m_Lights.Next(i) )
|
|
unmatched.AddToTail( i );
|
|
|
|
// Match the light lists and get rid of lights that we already have all the data for.
|
|
directlight_t *pNext;
|
|
directlight_t **pPrev = &activelights;
|
|
for( directlight_t *dl=activelights; dl != NULL; dl = pNext )
|
|
{
|
|
pNext = dl->next;
|
|
|
|
//float flClosest = 3000000000;
|
|
//CIncLight *pClosest = 0;
|
|
|
|
// Look for this light in our light list.
|
|
int iNextUnmatched, iUnmatched;
|
|
for( iUnmatched=unmatched.Head(); iUnmatched != unmatched.InvalidIndex(); iUnmatched = iNextUnmatched )
|
|
{
|
|
iNextUnmatched = unmatched.Next( iUnmatched );
|
|
|
|
CIncLight *pLight = m_Lights[ unmatched[iUnmatched] ];
|
|
|
|
//float flTest = (pLight->m_Light.origin - dl->light.origin).Length();
|
|
//if( flTest < flClosest )
|
|
//{
|
|
// flClosest = flTest;
|
|
// pClosest = pLight;
|
|
//}
|
|
|
|
if( CompareLights( &dl->light, &pLight->m_Light ) )
|
|
{
|
|
unmatched.Remove( iUnmatched );
|
|
|
|
// Ok, we have this light's data already, yay!
|
|
// Get rid of it from the active light list.
|
|
*pPrev = dl->next;
|
|
free( dl );
|
|
dl = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//bool bTest=false;
|
|
//if(bTest)
|
|
// CompareLights( &dl->light, &pClosest->m_Light );
|
|
|
|
if( iUnmatched == unmatched.InvalidIndex() )
|
|
pPrev = &dl->next;
|
|
}
|
|
|
|
// Remove any of our lights that were unmatched.
|
|
for( int iUnmatched=unmatched.Head(); iUnmatched != unmatched.InvalidIndex(); iUnmatched = unmatched.Next( iUnmatched ) )
|
|
{
|
|
CIncLight *pLight = m_Lights[ unmatched[iUnmatched] ];
|
|
|
|
// First tag faces that it touched so they get recomposited.
|
|
for( unsigned short iFace=pLight->m_LightFaces.Head(); iFace != pLight->m_LightFaces.InvalidIndex(); iFace = pLight->m_LightFaces.Next( iFace ) )
|
|
{
|
|
m_FacesTouched[ pLight->m_LightFaces[iFace]->m_FaceIndex ] = 1;
|
|
}
|
|
|
|
delete pLight;
|
|
m_Lights.Remove( unmatched[iUnmatched] );
|
|
}
|
|
|
|
// Now add a light structure for each new light.
|
|
AddLightsForActiveLights();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CIncremental::ReadIncrementalHeader( long fp, CIncrementalHeader *pHeader )
|
|
{
|
|
int version;
|
|
FileRead( fp, version );
|
|
if( version != INCREMENTALFILE_VERSION )
|
|
return false;
|
|
|
|
int nFaces;
|
|
FileRead( fp, nFaces );
|
|
|
|
pHeader->m_FaceLightmapSizes.SetSize( nFaces );
|
|
FileRead( fp, pHeader->m_FaceLightmapSizes.Base(), sizeof(CIncrementalHeader::CLMSize) * nFaces );
|
|
|
|
return !FileError();
|
|
}
|
|
|
|
|
|
bool CIncremental::WriteIncrementalHeader( long fp )
|
|
{
|
|
int version = INCREMENTALFILE_VERSION;
|
|
FileWrite( fp, version );
|
|
|
|
int nFaces = numfaces;
|
|
FileWrite( fp, nFaces );
|
|
|
|
CIncrementalHeader hdr;
|
|
hdr.m_FaceLightmapSizes.SetSize( nFaces );
|
|
|
|
for( int i=0; i < nFaces; i++ )
|
|
{
|
|
hdr.m_FaceLightmapSizes[i].m_Width = g_pFaces[i].m_LightmapTextureSizeInLuxels[0];
|
|
hdr.m_FaceLightmapSizes[i].m_Height = g_pFaces[i].m_LightmapTextureSizeInLuxels[1];
|
|
}
|
|
|
|
FileWrite( fp, hdr.m_FaceLightmapSizes.Base(), sizeof(CIncrementalHeader::CLMSize) * nFaces );
|
|
|
|
return !FileError();
|
|
}
|
|
|
|
|
|
bool CIncremental::IsIncrementalFileValid()
|
|
{
|
|
long fp = FileOpen( m_pIncrementalFilename, true );
|
|
if( !fp )
|
|
return false;
|
|
|
|
bool bValid = false;
|
|
CIncrementalHeader hdr;
|
|
if( ReadIncrementalHeader( fp, &hdr ) )
|
|
{
|
|
// If the number of faces is the same and their lightmap sizes are the same,
|
|
// then this file is considered a legitimate incremental file.
|
|
if( hdr.m_FaceLightmapSizes.Count() == numfaces )
|
|
{
|
|
int i;
|
|
for( i=0; i < numfaces; i++ )
|
|
{
|
|
if( hdr.m_FaceLightmapSizes[i].m_Width != g_pFaces[i].m_LightmapTextureSizeInLuxels[0] ||
|
|
hdr.m_FaceLightmapSizes[i].m_Height != g_pFaces[i].m_LightmapTextureSizeInLuxels[1] )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Were all faces valid?
|
|
if( i == numfaces )
|
|
bValid = true;
|
|
}
|
|
}
|
|
|
|
FileClose( fp );
|
|
return bValid && !FileError();
|
|
}
|
|
|
|
|
|
void CIncremental::AddLightToFace(
|
|
IncrementalLightID lightID,
|
|
int iFace,
|
|
int iSample,
|
|
int lmSize,
|
|
float dot,
|
|
int iThread )
|
|
{
|
|
// If we're not being used, don't do anything.
|
|
if( !m_pIncrementalFilename )
|
|
return;
|
|
|
|
CIncLight *pLight = m_Lights[lightID];
|
|
|
|
// Check for the 99.99% case in which the face already exists.
|
|
CLightFace *pFace;
|
|
if( pLight->m_pCachedFaces[iThread] &&
|
|
pLight->m_pCachedFaces[iThread]->m_FaceIndex == iFace )
|
|
{
|
|
pFace = pLight->m_pCachedFaces[iThread];
|
|
}
|
|
else
|
|
{
|
|
bool bNew;
|
|
|
|
EnterCriticalSection( &pLight->m_CS );
|
|
pFace = pLight->FindOrCreateLightFace( iFace, lmSize, &bNew );
|
|
LeaveCriticalSection( &pLight->m_CS );
|
|
|
|
pLight->m_pCachedFaces[iThread] = pFace;
|
|
|
|
if( bNew )
|
|
m_TotalMemory += pFace->m_LightValues.Count() * sizeof( pFace->m_LightValues[0] );
|
|
}
|
|
|
|
// Add this into the light's data.
|
|
pFace->m_LightValues[iSample].m_Dot = dot;
|
|
}
|
|
|
|
|
|
unsigned short DecodeCharOrShort( CUtlBuffer *pIn )
|
|
{
|
|
unsigned short val = pIn->GetUnsignedChar();
|
|
if( val & 0x80 )
|
|
{
|
|
val = ((val & 0x7F) << 8) | pIn->GetUnsignedChar();
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
|
|
void EncodeCharOrShort( CUtlBuffer *pBuf, unsigned short val )
|
|
{
|
|
if( (val & 0xFF80) == 0 )
|
|
{
|
|
pBuf->PutUnsignedChar( (unsigned char)val );
|
|
}
|
|
else
|
|
{
|
|
if( val > 32767 )
|
|
val = 32767;
|
|
|
|
pBuf->PutUnsignedChar( (val >> 8) | 0x80 );
|
|
pBuf->PutUnsignedChar( val & 0xFF );
|
|
}
|
|
}
|
|
|
|
|
|
void DecompressLightData( CUtlBuffer *pIn, CUtlVector<CLightValue> *pOut )
|
|
{
|
|
int iOut = 0;
|
|
while( pIn->TellGet() < pIn->TellPut() )
|
|
{
|
|
unsigned char runLength = pIn->GetUnsignedChar();
|
|
unsigned short usVal = DecodeCharOrShort( pIn );
|
|
|
|
while( runLength > 0 )
|
|
{
|
|
--runLength;
|
|
|
|
pOut->Element(iOut).m_Dot = usVal;
|
|
++iOut;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
#pragma warning (disable:4701)
|
|
#endif
|
|
|
|
void CompressLightData(
|
|
CLightValue const *pValues,
|
|
int nValues,
|
|
CUtlBuffer *pBuf )
|
|
{
|
|
unsigned char runLength=0;
|
|
unsigned short flLastValue;
|
|
|
|
for( int i=0; i < nValues; i++ )
|
|
{
|
|
unsigned short flCurValue = (unsigned short)pValues[i].m_Dot;
|
|
|
|
if( i == 0 )
|
|
{
|
|
flLastValue = flCurValue;
|
|
runLength = 1;
|
|
}
|
|
else if( flCurValue == flLastValue && runLength < 255 )
|
|
{
|
|
++runLength;
|
|
}
|
|
else
|
|
{
|
|
pBuf->PutUnsignedChar( runLength );
|
|
EncodeCharOrShort( pBuf, flLastValue );
|
|
|
|
flLastValue = flCurValue;
|
|
runLength = 1;
|
|
}
|
|
}
|
|
|
|
// Write the end..
|
|
if( runLength )
|
|
{
|
|
pBuf->PutUnsignedChar( runLength );
|
|
EncodeCharOrShort( pBuf, flLastValue );
|
|
}
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
#pragma warning (default:4701)
|
|
#endif
|
|
|
|
void MultiplyValues( CUtlVector<CLightValue> &values, float scale )
|
|
{
|
|
for( int i=0; i < values.Count(); i++ )
|
|
values[i].m_Dot *= scale;
|
|
}
|
|
|
|
|
|
void CIncremental::FinishFace(
|
|
IncrementalLightID lightID,
|
|
int iFace,
|
|
int iThread )
|
|
{
|
|
CIncLight *pLight = m_Lights[lightID];
|
|
|
|
// Check for the 99.99% case in which the face already exists.
|
|
CLightFace *pFace;
|
|
if( pLight->m_pCachedFaces[iThread] && pLight->m_pCachedFaces[iThread]->m_FaceIndex == iFace )
|
|
{
|
|
pFace = pLight->m_pCachedFaces[iThread];
|
|
|
|
// Compress the data.
|
|
MultiplyValues( pFace->m_LightValues, pLight->m_flMaxIntensity );
|
|
|
|
pFace->m_CompressedData.SeekPut( CUtlBuffer::SEEK_HEAD, 0 );
|
|
CompressLightData(
|
|
pFace->m_LightValues.Base(),
|
|
pFace->m_LightValues.Count(),
|
|
&pFace->m_CompressedData );
|
|
|
|
#if 0
|
|
// test decompression
|
|
CUtlVector<CLightValue> test;
|
|
test.SetSize( 2048 );
|
|
pFace->m_CompressedData.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );
|
|
DecompressLightData( &pFace->m_CompressedData, &test );
|
|
#endif
|
|
|
|
if( pFace->m_CompressedData.TellPut() == 0 )
|
|
{
|
|
// No contribution.. delete this face from the light.
|
|
EnterCriticalSection( &pLight->m_CS );
|
|
pLight->m_LightFaces.Remove( pFace->m_LightFacesIndex );
|
|
delete pFace;
|
|
LeaveCriticalSection( &pLight->m_CS );
|
|
}
|
|
else
|
|
{
|
|
// Discard the uncompressed data.
|
|
pFace->m_LightValues.Purge();
|
|
m_FacesTouched[ pFace->m_FaceIndex ] = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
bool CIncremental::Finalize()
|
|
{
|
|
// If we're not being used, don't do anything.
|
|
if( !m_pIncrementalFilename || !m_pBSPFilename )
|
|
return false;
|
|
|
|
CUtlVector<CFaceLightList> faceLights;
|
|
LinkLightsToFaces( faceLights );
|
|
|
|
Vector faceLight[(MAX_LIGHTMAP_DIM_WITHOUT_BORDER+2) * (MAX_LIGHTMAP_DIM_WITHOUT_BORDER+2)];
|
|
CUtlVector<CLightValue> faceLightValues;
|
|
faceLightValues.SetSize( (MAX_LIGHTMAP_DIM_WITHOUT_BORDER+2) * (MAX_LIGHTMAP_DIM_WITHOUT_BORDER+2) );
|
|
|
|
// Only update the faces we've touched.
|
|
for( int facenum = 0; facenum < numfaces; facenum++ )
|
|
{
|
|
if( !m_FacesTouched[facenum] || !faceLights[facenum].Count() )
|
|
continue;
|
|
|
|
int w = g_pFaces[facenum].m_LightmapTextureSizeInLuxels[0]+1;
|
|
int h = g_pFaces[facenum].m_LightmapTextureSizeInLuxels[1]+1;
|
|
int nLuxels = w * h;
|
|
assert( nLuxels <= sizeof(faceLight) / sizeof(faceLight[0]) );
|
|
|
|
// Clear the lighting for this face.
|
|
memset( faceLight, 0, nLuxels * sizeof(Vector) );
|
|
|
|
// Composite all the light contributions.
|
|
for( int iFace=0; iFace < faceLights[facenum].Count(); iFace++ )
|
|
{
|
|
CLightFace *pFace = faceLights[facenum][iFace];
|
|
|
|
pFace->m_CompressedData.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );
|
|
DecompressLightData( &pFace->m_CompressedData, &faceLightValues );
|
|
|
|
for( int iSample=0; iSample < nLuxels; iSample++ )
|
|
{
|
|
float flDot = faceLightValues[iSample].m_Dot;
|
|
if( flDot )
|
|
{
|
|
VectorMA(
|
|
faceLight[iSample],
|
|
flDot / pFace->m_pLight->m_flMaxIntensity,
|
|
pFace->m_pLight->m_Light.intensity,
|
|
faceLight[iSample] );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Convert to the floating-point representation in the BSP file.
|
|
Vector *pSrc = faceLight;
|
|
unsigned char *pDest = &(*pdlightdata)[ g_pFaces[facenum].lightofs ];
|
|
|
|
for( int iSample=0; iSample < nLuxels; iSample++ )
|
|
{
|
|
VectorToColorRGBExp32( *pSrc, *( ColorRGBExp32 *)pDest );
|
|
pDest += 4;
|
|
pSrc++;
|
|
}
|
|
}
|
|
|
|
m_bSuccessfulRun = true;
|
|
return true;
|
|
}
|
|
|
|
|
|
void CIncremental::GetFacesTouched( CUtlVector<unsigned char> &touched )
|
|
{
|
|
touched.CopyArray( m_FacesTouched.Base(), m_FacesTouched.Count() );
|
|
}
|
|
|
|
|
|
bool CIncremental::Serialize()
|
|
{
|
|
if( !SaveIncrementalFile() )
|
|
return false;
|
|
|
|
WriteBSPFile( (char*)m_pBSPFilename );
|
|
return true;
|
|
}
|
|
|
|
|
|
void CIncremental::Term()
|
|
{
|
|
m_Lights.PurgeAndDeleteElements();
|
|
m_TotalMemory = 0;
|
|
}
|
|
|
|
|
|
void CIncremental::AddLightsForActiveLights()
|
|
{
|
|
// Create our lights.
|
|
for( directlight_t *dl=activelights; dl != NULL; dl = dl->next )
|
|
{
|
|
CIncLight *pLight = new CIncLight;
|
|
dl->m_IncrementalID = m_Lights.AddToTail( pLight );
|
|
|
|
// Copy the light information.
|
|
pLight->m_Light = dl->light;
|
|
pLight->m_flMaxIntensity = max( dl->light.intensity[0], max( dl->light.intensity[1], dl->light.intensity[2] ) );
|
|
}
|
|
}
|
|
|
|
|
|
bool CIncremental::LoadIncrementalFile()
|
|
{
|
|
Term();
|
|
|
|
if( !IsIncrementalFileValid() )
|
|
return false;
|
|
|
|
long fp = FileOpen( m_pIncrementalFilename, true );
|
|
if( !fp )
|
|
return false;
|
|
|
|
// Read the header.
|
|
CIncrementalHeader hdr;
|
|
if( !ReadIncrementalHeader( fp, &hdr ) )
|
|
{
|
|
FileClose( fp );
|
|
return false;
|
|
}
|
|
|
|
|
|
// Read the lights.
|
|
int nLights;
|
|
FileRead( fp, nLights );
|
|
for( int iLight=0; iLight < nLights; iLight++ )
|
|
{
|
|
CIncLight *pLight = new CIncLight;
|
|
m_Lights.AddToTail( pLight );
|
|
|
|
FileRead( fp, pLight->m_Light );
|
|
pLight->m_flMaxIntensity =
|
|
max( pLight->m_Light.intensity.x,
|
|
max( pLight->m_Light.intensity.y, pLight->m_Light.intensity.z ) );
|
|
|
|
int nFaces;
|
|
FileRead( fp, nFaces );
|
|
assert( nFaces < 70000 );
|
|
|
|
for( int iFace=0; iFace < nFaces; iFace++ )
|
|
{
|
|
CLightFace *pFace = new CLightFace;
|
|
pLight->m_LightFaces.AddToTail( pFace );
|
|
|
|
pFace->m_pLight = pLight;
|
|
FileRead( fp, pFace->m_FaceIndex );
|
|
|
|
int dataSize;
|
|
FileRead( fp, dataSize );
|
|
|
|
pFace->m_CompressedData.SeekPut( CUtlBuffer::SEEK_HEAD, 0 );
|
|
while( dataSize )
|
|
{
|
|
--dataSize;
|
|
|
|
unsigned char ucData;
|
|
FileRead( fp, ucData );
|
|
|
|
pFace->m_CompressedData.PutUnsignedChar( ucData );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
FileClose( fp );
|
|
return !FileError();
|
|
}
|
|
|
|
|
|
bool CIncremental::SaveIncrementalFile()
|
|
{
|
|
long fp = FileOpen( m_pIncrementalFilename, false );
|
|
if( !fp )
|
|
return false;
|
|
|
|
if( !WriteIncrementalHeader( fp ) )
|
|
{
|
|
FileClose( fp );
|
|
return false;
|
|
}
|
|
|
|
// Write the lights.
|
|
int nLights = m_Lights.Count();
|
|
FileWrite( fp, nLights );
|
|
for( int iLight=m_Lights.Head(); iLight != m_Lights.InvalidIndex(); iLight = m_Lights.Next( iLight ) )
|
|
{
|
|
CIncLight *pLight = m_Lights[iLight];
|
|
|
|
FileWrite( fp, pLight->m_Light );
|
|
|
|
int nFaces = pLight->m_LightFaces.Count();
|
|
FileWrite( fp, nFaces );
|
|
for( int iFace=pLight->m_LightFaces.Head(); iFace != pLight->m_LightFaces.InvalidIndex(); iFace = pLight->m_LightFaces.Next( iFace ) )
|
|
{
|
|
CLightFace *pFace = pLight->m_LightFaces[iFace];
|
|
|
|
FileWrite( fp, pFace->m_FaceIndex );
|
|
|
|
int dataSize = pFace->m_CompressedData.TellPut();
|
|
FileWrite( fp, dataSize );
|
|
|
|
pFace->m_CompressedData.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );
|
|
while( dataSize )
|
|
{
|
|
--dataSize;
|
|
FileWrite( fp, pFace->m_CompressedData.GetUnsignedChar() );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
FileClose( fp );
|
|
return !FileError();
|
|
}
|
|
|
|
|
|
void CIncremental::LinkLightsToFaces( CUtlVector<CFaceLightList> &faceLights )
|
|
{
|
|
faceLights.SetSize( numfaces );
|
|
|
|
for( int iLight=m_Lights.Head(); iLight != m_Lights.InvalidIndex(); iLight = m_Lights.Next( iLight ) )
|
|
{
|
|
CIncLight *pLight = m_Lights[iLight];
|
|
|
|
for( int iFace=pLight->m_LightFaces.Head(); iFace != pLight->m_LightFaces.InvalidIndex(); iFace = pLight->m_LightFaces.Next( iFace ) )
|
|
{
|
|
CLightFace *pFace = pLight->m_LightFaces[iFace];
|
|
|
|
if( m_FacesTouched[pFace->m_FaceIndex] )
|
|
faceLights[ pFace->m_FaceIndex ].AddToTail( pFace );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------ //
|
|
// CIncLight
|
|
// ------------------------------------------------------------------ //
|
|
|
|
CIncLight::CIncLight()
|
|
{
|
|
memset( m_pCachedFaces, 0, sizeof(m_pCachedFaces) );
|
|
InitializeCriticalSection( &m_CS );
|
|
}
|
|
|
|
|
|
CIncLight::~CIncLight()
|
|
{
|
|
m_LightFaces.PurgeAndDeleteElements();
|
|
DeleteCriticalSection( &m_CS );
|
|
}
|
|
|
|
|
|
CLightFace* CIncLight::FindOrCreateLightFace( int iFace, int lmSize, bool *bNew )
|
|
{
|
|
if( bNew )
|
|
*bNew = false;
|
|
|
|
|
|
// Look for it.
|
|
for( int i=m_LightFaces.Head(); i != m_LightFaces.InvalidIndex(); i=m_LightFaces.Next(i) )
|
|
{
|
|
CLightFace *pFace = m_LightFaces[i];
|
|
|
|
if( pFace->m_FaceIndex == iFace )
|
|
{
|
|
assert( pFace->m_LightValues.Count() == lmSize );
|
|
return pFace;
|
|
}
|
|
}
|
|
|
|
// Ok, create one.
|
|
CLightFace *pFace = new CLightFace;
|
|
pFace->m_LightFacesIndex = m_LightFaces.AddToTail( pFace );
|
|
pFace->m_pLight = this;
|
|
|
|
pFace->m_FaceIndex = iFace;
|
|
pFace->m_LightValues.SetSize( lmSize );
|
|
memset( pFace->m_LightValues.Base(), 0, sizeof( CLightValue ) * lmSize );
|
|
|
|
if( bNew )
|
|
*bNew = true;
|
|
|
|
return pFace;
|
|
}
|
|
|
|
|