void CStudioPhysics::ParseKeydata( void )
{
IVPhysicsKeyParser *pParser = physcollision->VPhysicsKeyParserCreate( GetVCollide()->pKeyValues );
while ( !pParser->Finished() )
{
const char *pBlock = pParser->GetCurrentBlockName();
if ( !stricmp( pBlock, "solid" ) )
{
hlmvsolid_t solid;
CSolidParse solidParse;
pParser->ParseSolid( &solid, &solidParse );
solid.surfacePropIndex = FindPhysprop( solid.surfaceprop );
if ( solid.index >= 0 && solid.index < m_listCount )
{
strcpy( m_pList[solid.index].m_boneName, solid.name );
memcpy( &m_pList[solid.index].m_solid, &solid, sizeof(solid) );
}
}
else if ( !stricmp( pBlock, "ragdollconstraint" ) )
{
constraint_ragdollparams_t constraint;
pParser->ParseRagdollConstraint( &constraint, NULL );
if ( constraint.childIndex >= 0 && constraint.childIndex < m_listCount )
{
// In the editor / qc these show up as 5X so that 1.0 is the default
constraint.axes[0].torque *= 5;
constraint.axes[1].torque *= 5;
constraint.axes[2].torque *= 5;
m_pList[constraint.childIndex].m_constraint = constraint;
}
}
else if ( !stricmp( pBlock, "editparams" ) )
{
CEditParse editParse;
pParser->ParseCustom( &m_edit, &editParse );
m_mass = m_edit.totalMass;
}
else if ( !strcmpi( pBlock, "collisionrules" ) )
{
CRagdollCollisionRulesParse rules(this);
pParser->ParseCustom( NULL, &rules );
}
else
{
pParser->SkipBlock();
}
}
physcollision->VPhysicsKeyParserDestroy( pParser );
}
static void RagdollCreateObjects( IPhysicsEnvironment *pPhysEnv, ragdoll_t &ragdoll, const ragdollparams_t ¶ms )
{
ragdoll.listCount = 0;
ragdoll.pGroup = NULL;
ragdoll.allowStretch = params.allowStretch;
memset( ragdoll.list, 0, sizeof(ragdoll.list) );
memset( &ragdoll.animfriction, 0, sizeof(ragdoll.animfriction) );
if ( !params.pCollide || params.pCollide->solidCount > RAGDOLL_MAX_ELEMENTS )
return;
constraint_groupparams_t group;
group.Defaults();
ragdoll.pGroup = pPhysEnv->CreateConstraintGroup( group );
IVPhysicsKeyParser *pParse = physcollision->VPhysicsKeyParserCreate( params.pCollide->pKeyValues );
while ( !pParse->Finished() )
{
const char *pBlock = pParse->GetCurrentBlockName();
if ( !strcmpi( pBlock, "solid" ) )
{
solid_t solid;
pParse->ParseSolid( &solid, &g_SolidSetup );
RagdollAddSolid( pPhysEnv, ragdoll, params, solid );
}
else if ( !strcmpi( pBlock, "ragdollconstraint" ) )
{
constraint_ragdollparams_t constraint;
pParse->ParseRagdollConstraint( &constraint, NULL );
RagdollAddConstraint( pPhysEnv, ragdoll, params, constraint );
}
else if ( !strcmpi( pBlock, "collisionrules" ) )
{
IPhysicsCollisionSet *pSet = physics->FindOrCreateCollisionSet( params.modelIndex, ragdoll.listCount );
CRagdollCollisionRules rules(pSet);
pParse->ParseCustom( (void *)&rules, &rules );
}
else if ( !strcmpi( pBlock, "animatedfriction") )
{
CRagdollAnimatedFriction friction( &ragdoll );
pParse->ParseCustom( (void*)&friction, &friction );
}
else
{
pParse->SkipBlock();
}
}
physcollision->VPhysicsKeyParserDestroy( pParse );
}
void RagdollSetupAnimatedFriction( IPhysicsEnvironment *pPhysEnv, ragdoll_t *ragdoll, int iModelIndex )
{
vcollide_t* pCollide = modelinfo->GetVCollide( iModelIndex );
if ( pCollide )
{
IVPhysicsKeyParser *pParse = physcollision->VPhysicsKeyParserCreate( pCollide->pKeyValues );
while ( !pParse->Finished() )
{
const char *pBlock = pParse->GetCurrentBlockName();
if ( !strcmpi( pBlock, "animatedfriction") )
{
CRagdollAnimatedFriction friction( ragdoll );
pParse->ParseCustom( (void*)&friction, &friction );
}
else
{
pParse->SkipBlock();
}
}
physcollision->VPhysicsKeyParserDestroy( pParse );
}
}
void BuildPropList( const char *pszBlockName, CUtlVector<breakmodel_t> &list, int modelindex, float defBurstScale, int defCollisionGroup )
{
vcollide_t *pCollide = modelinfo->GetVCollide( modelindex );
if ( !pCollide )
return;
IVPhysicsKeyParser *pParse = physcollision->VPhysicsKeyParserCreate( pCollide->pKeyValues );
while ( !pParse->Finished() )
{
CBreakParser breakParser( defBurstScale, defCollisionGroup );
const char *pBlock = pParse->GetCurrentBlockName();
if ( !strcmpi( pBlock, pszBlockName ) )
{
int index = list.AddToTail();
breakmodel_t &breakModel = list[index];
pParse->ParseCustom( &breakModel, &breakParser );
}
else
{
pParse->SkipBlock();
}
}
physcollision->VPhysicsKeyParserDestroy( pParse );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : modelindex -
//-----------------------------------------------------------------------------
void PrecachePropsForModel( int iModel, const char *pszBlockName )
{
vcollide_t *pCollide = modelinfo->GetVCollide( iModel );
if ( !pCollide )
return;
// The scale and group doesn't really matter at the moment, we are just using the parser to get the model name to cache.
CBreakParser breakParser( 1.0, COLLISION_GROUP_NONE );
// Create a parser.
IVPhysicsKeyParser *pParse = physcollision->VPhysicsKeyParserCreate( pCollide->pKeyValues );
while ( !pParse->Finished() )
{
const char *pBlock = pParse->GetCurrentBlockName();
if ( !strcmpi( pBlock, pszBlockName ) )
{
breakmodel_t breakModel;
pParse->ParseCustom( &breakModel, &breakParser );
CBaseEntity::PrecacheModel( breakModel.modelName );
}
else
{
pParse->SkipBlock();
}
}
// Destroy the parser.
physcollision->VPhysicsKeyParserDestroy( pParse );
}
//-----------------------------------------------------------------------------
// Purpose: Parses the vehicle's script for the vehicle view parameters
//-----------------------------------------------------------------------------
bool CPropVehicleChoreoGeneric::ParseViewParams( const char *pScriptName )
{
byte *pFile = UTIL_LoadFileForMe( pScriptName, NULL );
if ( !pFile )
return false;
IVPhysicsKeyParser *pParse = physcollision->VPhysicsKeyParserCreate( (char *)pFile );
CVehicleChoreoViewParser viewParser;
while ( !pParse->Finished() )
{
const char *pBlock = pParse->GetCurrentBlockName();
if ( !strcmpi( pBlock, "vehicle_view" ) )
{
pParse->ParseCustom( &m_vehicleView, &viewParser );
}
else
{
pParse->SkipBlock();
}
}
physcollision->VPhysicsKeyParserDestroy( pParse );
UTIL_FreeFile( pFile );
Precache();
return true;
}
void RagdollSetupCollisions( ragdoll_t &ragdoll, vcollide_t *pCollide, int modelIndex )
{
//we don't need this assert valve! - bitl
//Assert(pCollide);
if (!pCollide)
return;
IPhysicsCollisionSet *pSet = physics->FindCollisionSet( modelIndex );
if ( !pSet )
{
pSet = physics->FindOrCreateCollisionSet( modelIndex, ragdoll.listCount );
if ( !pSet )
return;
bool bFoundRules = false;
IVPhysicsKeyParser *pParse = physcollision->VPhysicsKeyParserCreate( pCollide->pKeyValues );
while ( !pParse->Finished() )
{
const char *pBlock = pParse->GetCurrentBlockName();
if ( !strcmpi( pBlock, "collisionrules" ) )
{
IPhysicsCollisionSet *pSet = physics->FindOrCreateCollisionSet( modelIndex, ragdoll.listCount );
CRagdollCollisionRules rules(pSet);
pParse->ParseCustom( (void *)&rules, &rules );
bFoundRules = true;
}
else
{
pParse->SkipBlock();
}
}
physcollision->VPhysicsKeyParserDestroy( pParse );
if ( !bFoundRules )
{
// these are the default rules - each piece collides with everything
// except immediate parent/constrained object.
int i;
for ( i = 0; i < ragdoll.listCount; i++ )
{
for ( int j = i+1; j < ragdoll.listCount; j++ )
{
pSet->EnableCollisions( i, j );
}
}
for ( i = 0; i < ragdoll.listCount; i++ )
{
int parent = ragdoll.list[i].parentIndex;
if ( parent >= 0 )
{
Assert( ragdoll.list[i].pObject );
Assert( ragdoll.list[i].pConstraint );
pSet->DisableCollisions( i, parent );
}
}
}
}
}
