Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

230 lines
7.6 KiB

//========= 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++;
}
}
}
}
}