void HandleWorkUnitCompleted( CDSInfo *pInfo, int iSource, WUIndexType iWorkUnit, MessageBuffer *pBuf )
{
VMPITracker_WorkUnitCompleted( ( int ) iWorkUnit, iSource );
if ( g_pCurDistributorMaster->HandleWorkUnitResults( iWorkUnit ) )
{
if ( g_iVMPIVerboseLevel >= 1 )
Msg( "-" );
++ g_nCompletedWUs;
++ g_wuCountByProcess[iSource];
++ g_totalWUCountByProcess[iSource];
// Let the master process the incoming WU data.
if ( pBuf )
{
pInfo->m_MasterInfo.m_ReceiveFn( iWorkUnit, pBuf, iSource );
}
UpdatePacifier( float( g_nCompletedWUs ) / pInfo->m_nWorkUnits );
}
else
{
// Ignore it if we already got the results for this work unit.
++ g_nDuplicatedWUs;
if ( g_iVMPIVerboseLevel >= 1 )
Msg( "*" );
}
}
void EndPacifier( bool bCarriageReturn )
{
UpdatePacifier(1);
if( bCarriageReturn )
Msg("\n");
}
//-----------------------------------------------------------------------------
// Computes lighting for the detail props
//-----------------------------------------------------------------------------
void ComputeDetailPropLighting( int iThread )
{
// illuminate them all
DetailObjectLump_t* pProps;
int count = UnserializeDetailProps( pProps );
if (!count)
return;
// unserialize the lump that we aren't computing.
if( g_bHDR )
{
UnserializeDetailPropLighting( GAMELUMP_DETAIL_PROP_LIGHTING, GAMELUMP_DETAIL_PROP_LIGHTING_VERSION, s_DetailPropLightStyleLumpLDR );
}
else
{
UnserializeDetailPropLighting( GAMELUMP_DETAIL_PROP_LIGHTING_HDR, GAMELUMP_DETAIL_PROP_LIGHTING_HDR_VERSION, s_DetailPropLightStyleLumpHDR );
}
StartPacifier("Computing detail prop lighting : ");
for (int i = 0; i < count; ++i)
{
UpdatePacifier( (float)i / (float)count );
ComputeLighting( pProps[i], iThread );
}
// Write detail prop lightstyle lump...
WriteDetailLightingLumps();
EndPacifier( true );
}
//-----------------------------------------------------------------------------
// Computes lighting for the static props.
// Must be after all other surface lighting has been computed for the indirect sampling.
//-----------------------------------------------------------------------------
void CVradStaticPropMgr::ComputeLighting( int iThread )
{
// illuminate them all
int count = m_StaticProps.Count();
if ( !count )
{
// nothing to do
return;
}
StartPacifier( "Computing static prop lighting : " );
// ensure any traces against us are ignored because we have no inherit lighting contribution
m_bIgnoreStaticPropTrace = true;
for (int i = 0; i < count; ++i)
{
UpdatePacifier( (float)i / (float)count );
ComputeLighting( m_StaticProps[i], iThread, i );
}
// restore default
m_bIgnoreStaticPropTrace = false;
// save data to bsp
SerializeLighting();
EndPacifier( true );
}
void ComputePerLeafAmbientLighting()
{
// Figure out which lights should go in the per-leaf ambient cubes.
int nInAmbientCube = 0;
int nSurfaceLights = 0;
for ( int i=0; i < *pNumworldlights; i++ )
{
dworldlight_t *wl = &dworldlights[i];
if ( IsLeafAmbientSurfaceLight( wl ) )
wl->flags |= DWL_FLAGS_INAMBIENTCUBE;
else
wl->flags &= ~DWL_FLAGS_INAMBIENTCUBE;
if ( wl->type == emit_surface )
++nSurfaceLights;
if ( wl->flags & DWL_FLAGS_INAMBIENTCUBE )
++nInAmbientCube;
}
Msg( "%d of %d (%d%% of) surface lights went in leaf ambient cubes.\n", nInAmbientCube, nSurfaceLights, nSurfaceLights ? ((nInAmbientCube*100) / nSurfaceLights) : 0 );
g_pLeafAmbientLighting->SetCount( numleafs );
StartPacifier( "ComputePerLeafAmbientLighting: " );
for ( int leafID = 0; leafID < numleafs; leafID++ )
{
dleaf_t *pLeaf = &dleafs[leafID];
Vector cube[6];
Vector center = ( Vector( pLeaf->mins[0], pLeaf->mins[1], pLeaf->mins[2] ) + Vector( pLeaf->maxs[0], pLeaf->maxs[1], pLeaf->maxs[2] ) ) * 0.5f;
#if MAKE_LIGHT_BELOW_WATER_MATCH_LIGHT_ABOVE_WATER
if (pLeaf->contents & CONTENTS_WATER)
{
center.z=pLeaf->maxs[2]+1;
int above_leaf=PointLeafnum( center);
dleaf_t *pLeaf = &dleafs[above_leaf];
center = ( Vector( pLeaf->mins[0], pLeaf->mins[1], pLeaf->mins[2] ) + Vector( pLeaf->maxs[0], pLeaf->maxs[1], pLeaf->maxs[2] ) ) * 0.5f;
}
#endif
ComputeAmbientFromSphericalSamples( center, cube );
for ( int i = 0; i < 6; i++ )
{
VectorToColorRGBExp32( cube[i], (*g_pLeafAmbientLighting)[leafID].m_Color[i] );
}
UpdatePacifier( (float)leafID / numleafs );
}
EndPacifier( true );
}
/*
=============
GetThreadWork
=============
*/
int GetThreadWork (void)
{
int r;
ThreadLock ();
if (dispatch == workcount)
{
ThreadUnlock ();
return -1;
}
UpdatePacifier( (float)dispatch / workcount );
r = dispatch;
dispatch++;
ThreadUnlock ();
return r;
}
//-----------------------------------------------------------------------------
// Places Detail Objects in the level
//-----------------------------------------------------------------------------
void EmitDetailModels()
{
StartPacifier("Placing detail props : ");
// Place stuff on each face
dface_t* pFace = dfaces;
for (int j = 0; j < numfaces; ++j)
{
UpdatePacifier( (float)j / (float)numfaces );
// Get at the material associated with this face
texinfo_t* pTexInfo = &texinfo[pFace[j].texinfo];
dtexdata_t* pTexData = GetTexData( pTexInfo->texdata );
// Try to get at the material
bool found;
MaterialSystemMaterial_t handle =
FindOriginalMaterial( TexDataStringTable_GetString( pTexData->nameStringTableID ),
&found, false );
if (!found)
continue;
// See if its got any detail objects on it
const char* pDetailType = GetMaterialVar( handle, "%detailtype" );
if (!pDetailType)
continue;
// Get the detail type...
DetailObject_t search;
search.m_Name = pDetailType;
int objectType = s_DetailObjectDict.Find(search);
if (objectType < 0)
{
Warning("Material %s uses unknown detail object type %s!\n",
TexDataStringTable_GetString( pTexData->nameStringTableID ),
pDetailType);
continue;
}
// Emit objects on a particular face
DetailObject_t& detail = s_DetailObjectDict[objectType];
if (pFace[j].dispinfo < 0)
{
EmitDetailObjectsOnFace( &pFace[j], detail );
}
else
{
// Get a CCoreDispInfo. All we need is the triangles and lightmap texture coordinates.
mapdispinfo_t *pMapDisp = &mapdispinfo[pFace[j].dispinfo];
CCoreDispInfo coreDispInfo;
DispMapToCoreDispInfo( pMapDisp, &coreDispInfo, &pFace[j] );
EmitDetailObjectsOnDisplacementFace( &pFace[j], detail, coreDispInfo );
}
}
// Emit specifically specified detail props
Vector origin;
QAngle angles;
Vector2D pos[2];
Vector2D tex[2];
for (int i = 0; i < num_entities; ++i)
{
char* pEntity = ValueForKey(&entities[i], "classname");
if (!strcmp(pEntity, "detail_prop") || !strcmp(pEntity, "prop_detail"))
{
GetVectorForKey( &entities[i], "origin", origin );
GetAnglesForKey( &entities[i], "angles", angles );
char* pModelName = ValueForKey( &entities[i], "model" );
int nOrientation = IntForKey( &entities[i], "detailOrientation" );
AddDetailToLump( pModelName, origin, angles, nOrientation );
// strip this ent from the .bsp file
entities[i].epairs = 0;
continue;
}
if (!strcmp(pEntity, "prop_detail_sprite"))
{
GetVectorForKey( &entities[i], "origin", origin );
GetAnglesForKey( &entities[i], "angles", angles );
int nOrientation = IntForKey( &entities[i], "detailOrientation" );
GetVector2DForKey( &entities[i], "position_ul", pos[0] );
GetVector2DForKey( &entities[i], "position_lr", pos[1] );
GetVector2DForKey( &entities[i], "tex_ul", tex[0] );
GetVector2DForKey( &entities[i], "tex_size", tex[1] );
float flTextureSize = FloatForKey( &entities[i], "tex_total_size" );
tex[1].x += tex[0].x - 0.5f;
tex[1].y += tex[0].y - 0.5f;
tex[0].x += 0.5f;
tex[0].y += 0.5f;
tex[0] /= flTextureSize;
tex[1] /= flTextureSize;
AddDetailSpriteToLump( origin, angles, nOrientation, pos, tex, 1.0f );
// strip this ent from the .bsp file
entities[i].epairs = 0;
continue;
}
}
EndPacifier( true );
}
void StartPacifier( char const *pPrefix )
{
Msg( "%s", pPrefix );
g_LastPacifierDrawn = -1;
UpdatePacifier( 0.001f );
}
