mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-22 22:27:05 +00:00
231 lines
7.6 KiB
C++
231 lines
7.6 KiB
C++
|
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
|
//
|
||
|
// Purpose:
|
||
|
//
|
||
|
// $NoKeywords: $
|
||
|
//
|
||
|
//=============================================================================//
|
||
|
|
||
|
#include "vrad.h"
|
||
|
#include "lightmap.h"
|
||
|
|
||
|
#define SAMPLEHASH_NUM_BUCKETS 65536
|
||
|
#define SAMPLEHASH_GROW_SIZE 0
|
||
|
#define SAMPLEHASH_INIT_SIZE 0
|
||
|
|
||
|
int samplesAdded = 0;
|
||
|
int patchSamplesAdded = 0;
|
||
|
static unsigned short g_PatchIterationKey = 0;
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool SampleData_CompareFunc( SampleData_t const &src1, SampleData_t const &src2 )
|
||
|
{
|
||
|
return ( ( src1.x == src2.x ) &&
|
||
|
( src1.y == src2.y ) &&
|
||
|
( src1.z == src2.z ) );
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
unsigned int SampleData_KeyFunc( SampleData_t const &src )
|
||
|
{
|
||
|
return ( src.x + src.y + src.z );
|
||
|
}
|
||
|
|
||
|
|
||
|
CUtlHash<SampleData_t> g_SampleHashTable( SAMPLEHASH_NUM_BUCKETS,
|
||
|
SAMPLEHASH_GROW_SIZE,
|
||
|
SAMPLEHASH_INIT_SIZE,
|
||
|
SampleData_CompareFunc, SampleData_KeyFunc );
|
||
|
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
UtlHashHandle_t SampleData_Find( sample_t *pSample )
|
||
|
{
|
||
|
SampleData_t sampleData;
|
||
|
sampleData.x = ( int )( pSample->pos.x / SAMPLEHASH_VOXEL_SIZE ) * 100;
|
||
|
sampleData.y = ( int )( pSample->pos.y / SAMPLEHASH_VOXEL_SIZE ) * 10;
|
||
|
sampleData.z = ( int )( pSample->pos.z / SAMPLEHASH_VOXEL_SIZE );
|
||
|
|
||
|
return g_SampleHashTable.Find( sampleData );
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
UtlHashHandle_t SampleData_InsertIntoHashTable( sample_t *pSample, SampleHandle_t sampleHandle )
|
||
|
{
|
||
|
SampleData_t sampleData;
|
||
|
sampleData.x = ( int )( pSample->pos.x / SAMPLEHASH_VOXEL_SIZE ) * 100;
|
||
|
sampleData.y = ( int )( pSample->pos.y / SAMPLEHASH_VOXEL_SIZE ) * 10;
|
||
|
sampleData.z = ( int )( pSample->pos.z / SAMPLEHASH_VOXEL_SIZE );
|
||
|
|
||
|
UtlHashHandle_t handle = g_SampleHashTable.AllocEntryFromKey( sampleData );
|
||
|
|
||
|
SampleData_t *pSampleData = &g_SampleHashTable.Element( handle );
|
||
|
pSampleData->x = sampleData.x;
|
||
|
pSampleData->y = sampleData.y;
|
||
|
pSampleData->z = sampleData.z;
|
||
|
pSampleData->m_Samples.AddToTail( sampleHandle );
|
||
|
|
||
|
samplesAdded++;
|
||
|
|
||
|
return handle;
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
UtlHashHandle_t SampleData_AddSample( sample_t *pSample, SampleHandle_t sampleHandle )
|
||
|
{
|
||
|
|
||
|
// find the key -- if it doesn't exist add new sample data to the
|
||
|
// hash table
|
||
|
UtlHashHandle_t handle = SampleData_Find( pSample );
|
||
|
if( handle == g_SampleHashTable.InvalidHandle() )
|
||
|
{
|
||
|
handle = SampleData_InsertIntoHashTable( pSample, sampleHandle );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
SampleData_t *pSampleData = &g_SampleHashTable.Element( handle );
|
||
|
pSampleData->m_Samples.AddToTail( sampleHandle );
|
||
|
|
||
|
samplesAdded++;
|
||
|
}
|
||
|
|
||
|
return handle;
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void SampleData_Log( void )
|
||
|
{
|
||
|
if( g_bLogHashData )
|
||
|
{
|
||
|
g_SampleHashTable.Log( "samplehash.txt" );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
//=============================================================================
|
||
|
//=============================================================================
|
||
|
//
|
||
|
// PatchSample Functions
|
||
|
//
|
||
|
//=============================================================================
|
||
|
//=============================================================================
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
bool PatchSampleData_CompareFunc( PatchSampleData_t const &src1, PatchSampleData_t const &src2 )
|
||
|
{
|
||
|
return ( ( src1.x == src2.x ) &&
|
||
|
( src1.y == src2.y ) &&
|
||
|
( src1.z == src2.z ) );
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
unsigned int PatchSampleData_KeyFunc( PatchSampleData_t const &src )
|
||
|
{
|
||
|
return ( src.x + src.y + src.z );
|
||
|
}
|
||
|
|
||
|
|
||
|
CUtlHash<PatchSampleData_t> g_PatchSampleHashTable( SAMPLEHASH_NUM_BUCKETS,
|
||
|
SAMPLEHASH_GROW_SIZE,
|
||
|
SAMPLEHASH_INIT_SIZE,
|
||
|
PatchSampleData_CompareFunc, PatchSampleData_KeyFunc );
|
||
|
|
||
|
void GetPatchSampleHashXYZ( const Vector &vOrigin, int &x, int &y, int &z )
|
||
|
{
|
||
|
x = ( int )( vOrigin.x / SAMPLEHASH_VOXEL_SIZE );
|
||
|
y = ( int )( vOrigin.y / SAMPLEHASH_VOXEL_SIZE );
|
||
|
z = ( int )( vOrigin.z / SAMPLEHASH_VOXEL_SIZE );
|
||
|
}
|
||
|
|
||
|
|
||
|
unsigned short IncrementPatchIterationKey()
|
||
|
{
|
||
|
if ( g_PatchIterationKey == 0xFFFF )
|
||
|
{
|
||
|
g_PatchIterationKey = 1;
|
||
|
for ( int i=0; i < g_Patches.Count(); i++ )
|
||
|
g_Patches[i].m_IterationKey = 0;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
g_PatchIterationKey++;
|
||
|
}
|
||
|
return g_PatchIterationKey;
|
||
|
}
|
||
|
|
||
|
|
||
|
//-----------------------------------------------------------------------------
|
||
|
//-----------------------------------------------------------------------------
|
||
|
void PatchSampleData_AddSample( CPatch *pPatch, int ndxPatch )
|
||
|
{
|
||
|
int patchSampleMins[3], patchSampleMaxs[3];
|
||
|
|
||
|
#if defined( SAMPLEHASH_USE_AREA_PATCHES )
|
||
|
GetPatchSampleHashXYZ( pPatch->mins, patchSampleMins[0], patchSampleMins[1], patchSampleMins[2] );
|
||
|
GetPatchSampleHashXYZ( pPatch->maxs, patchSampleMaxs[0], patchSampleMaxs[1], patchSampleMaxs[2] );
|
||
|
#else
|
||
|
// If not using area patches, just use the patch's origin to add it to the voxels.
|
||
|
GetPatchSampleHashXYZ( pPatch->origin, patchSampleMins[0], patchSampleMins[1], patchSampleMins[2] );
|
||
|
memcpy( patchSampleMaxs, patchSampleMins, sizeof( patchSampleMaxs ) );
|
||
|
#endif
|
||
|
|
||
|
// Make sure mins are smaller than maxs so we don't iterate for 4 bil.
|
||
|
Assert( patchSampleMins[0] <= patchSampleMaxs[0] && patchSampleMins[1] <= patchSampleMaxs[1] && patchSampleMins[2] <= patchSampleMaxs[2] );
|
||
|
patchSampleMins[0] = min( patchSampleMins[0], patchSampleMaxs[0] );
|
||
|
patchSampleMins[1] = min( patchSampleMins[1], patchSampleMaxs[1] );
|
||
|
patchSampleMins[2] = min( patchSampleMins[2], patchSampleMaxs[2] );
|
||
|
|
||
|
int iterateCoords[3];
|
||
|
for ( iterateCoords[0]=patchSampleMins[0]; iterateCoords[0] <= patchSampleMaxs[0]; iterateCoords[0]++ )
|
||
|
{
|
||
|
for ( iterateCoords[1]=patchSampleMins[1]; iterateCoords[1] <= patchSampleMaxs[1]; iterateCoords[1]++ )
|
||
|
{
|
||
|
for ( iterateCoords[2]=patchSampleMins[2]; iterateCoords[2] <= patchSampleMaxs[2]; iterateCoords[2]++ )
|
||
|
{
|
||
|
// find the key -- if it doesn't exist add new sample data to the
|
||
|
// hash table
|
||
|
PatchSampleData_t iteratePatch;
|
||
|
iteratePatch.x = iterateCoords[0] * 100;
|
||
|
iteratePatch.y = iterateCoords[1] * 10;
|
||
|
iteratePatch.z = iterateCoords[2];
|
||
|
|
||
|
UtlHashHandle_t handle = g_PatchSampleHashTable.Find( iteratePatch );
|
||
|
if( handle == g_PatchSampleHashTable.InvalidHandle() )
|
||
|
{
|
||
|
UtlHashHandle_t handle = g_PatchSampleHashTable.AllocEntryFromKey( iteratePatch );
|
||
|
|
||
|
PatchSampleData_t *pPatchData = &g_PatchSampleHashTable.Element( handle );
|
||
|
pPatchData->x = iteratePatch.x;
|
||
|
pPatchData->y = iteratePatch.y;
|
||
|
pPatchData->z = iteratePatch.z;
|
||
|
pPatchData->m_ndxPatches.AddToTail( ndxPatch );
|
||
|
|
||
|
patchSamplesAdded++;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
PatchSampleData_t *pPatchData = &g_PatchSampleHashTable.Element( handle );
|
||
|
pPatchData->m_ndxPatches.AddToTail( ndxPatch );
|
||
|
|
||
|
patchSamplesAdded++;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|