mirror of
https://github.com/celisej567/source-engine.git
synced 2026-01-04 18:09:53 +03:00
make original vphysics copy to track changes
This commit is contained in:
nillerusr
643
vphysics-physx/physics_material.cpp
Normal file
643
vphysics-physx/physics_material.cpp
Normal file
@@ -0,0 +1,643 @@
|
||||
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//
|
||||
//=============================================================================//
|
||||
#include "cbase.h"
|
||||
#include "physics_vehicle.h"
|
||||
|
||||
#include "ivp_material.hxx"
|
||||
#include <ctype.h>
|
||||
#include "utlsymbol.h"
|
||||
#include "tier1/strtools.h"
|
||||
#include "vcollide_parse_private.h"
|
||||
#include "ctype.h"
|
||||
|
||||
// memdbgon must be the last include file in a .cpp file!!!
|
||||
#include "tier0/memdbgon.h"
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: This is the data stored for each material/surface propery list
|
||||
//-----------------------------------------------------------------------------
|
||||
class CSurface : public IVP_Material
|
||||
{
|
||||
public:
|
||||
|
||||
// IVP_Material
|
||||
virtual IVP_DOUBLE get_friction_factor()
|
||||
{
|
||||
return data.physics.friction;
|
||||
}
|
||||
|
||||
virtual IVP_DOUBLE get_elasticity()
|
||||
{
|
||||
return data.physics.elasticity;
|
||||
}
|
||||
virtual const char *get_name();
|
||||
// UNDONE: not implemented here.
|
||||
virtual IVP_DOUBLE get_second_friction_factor()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
virtual IVP_DOUBLE get_adhesion()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
virtual IVP_DOUBLE get_damping()
|
||||
{
|
||||
return data.physics.dampening;
|
||||
}
|
||||
|
||||
// strings
|
||||
CUtlSymbol m_name;
|
||||
unsigned short m_pad;
|
||||
|
||||
// physics properties
|
||||
surfacedata_t data;
|
||||
};
|
||||
|
||||
|
||||
class CPhysicsSurfaceProps;
|
||||
|
||||
class CIVPMaterialManager : public IVP_Material_Manager
|
||||
{
|
||||
typedef IVP_Material_Manager BaseClass;
|
||||
public:
|
||||
CIVPMaterialManager( void );
|
||||
void Init( CPhysicsSurfaceProps *pProps ) { m_props = pProps; }
|
||||
void SetPropMap( int *map, int mapSize );
|
||||
int RemapIVPMaterialIndex( int ivpMaterialIndex ) const;
|
||||
|
||||
// IVP_Material_Manager
|
||||
virtual IVP_Material *get_material_by_index(IVP_Real_Object *pObject, const IVP_U_Point *world_position, int index);
|
||||
|
||||
virtual IVP_DOUBLE get_friction_factor(IVP_Contact_Situation *situation) // returns values >0, value of 1.0f means object stands on a 45 degres hill
|
||||
{
|
||||
// vehicle wheels get no friction with stuff that isn't ground
|
||||
// helps keep control of the car
|
||||
// traction on less than 60 degree slopes.
|
||||
float wheelFriction = 1.0f;
|
||||
if ( ShouldOverrideWheelContactFriction( &wheelFriction, situation->objects[0], situation->objects[1], &situation->surf_normal ) )
|
||||
{
|
||||
return wheelFriction;
|
||||
}
|
||||
|
||||
IVP_DOUBLE factor = BaseClass::get_friction_factor( situation );
|
||||
factor = clamp(factor,0.0,1.0);
|
||||
|
||||
return factor;
|
||||
}
|
||||
|
||||
virtual IVP_DOUBLE get_elasticity(IVP_Contact_Situation *situation) // range [0, 1.0f[, the relative speed after a collision compared to the speed before
|
||||
{
|
||||
IVP_DOUBLE flElasticity = BaseClass::get_elasticity( situation );
|
||||
if ( flElasticity > 1.0f )
|
||||
{
|
||||
flElasticity = 1.0f;
|
||||
}
|
||||
else if ( flElasticity < 0 )
|
||||
{
|
||||
flElasticity = 0;
|
||||
}
|
||||
return flElasticity;
|
||||
}
|
||||
|
||||
private:
|
||||
CPhysicsSurfaceProps *m_props;
|
||||
unsigned short m_propMap[128];
|
||||
};
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Purpose: This is the main database of materials
|
||||
//-----------------------------------------------------------------------------
|
||||
class CPhysicsSurfaceProps : public IPhysicsSurfacePropsInternal
|
||||
{
|
||||
public:
|
||||
CPhysicsSurfaceProps( void );
|
||||
~CPhysicsSurfaceProps( void );
|
||||
|
||||
virtual int ParseSurfaceData( const char *pFilename, const char *pTextfile );
|
||||
virtual int SurfacePropCount( void ) const;
|
||||
virtual int GetSurfaceIndex( const char *pPropertyName ) const;
|
||||
virtual void GetPhysicsProperties( int surfaceDataIndex, float *density, float *thickness, float *friction, float *elasticity ) const;
|
||||
virtual void GetPhysicsParameters( int surfaceDataIndex, surfacephysicsparams_t *pParamsOut ) const;
|
||||
virtual surfacedata_t *GetSurfaceData( int surfaceDataIndex );
|
||||
virtual const char *GetString( unsigned short stringTableIndex ) const;
|
||||
virtual const char *GetPropName( int surfaceDataIndex ) const;
|
||||
virtual void SetWorldMaterialIndexTable( int *pMapArray, int mapSize );
|
||||
virtual int RemapIVPMaterialIndex( int ivpMaterialIndex ) const
|
||||
{
|
||||
return m_ivpManager.RemapIVPMaterialIndex( ivpMaterialIndex );
|
||||
}
|
||||
bool IsReservedMaterialIndex( int materialIndex ) const;
|
||||
virtual const char *GetReservedMaterialName( int materialIndex ) const;
|
||||
int GetReservedFallBack( int materialIndex ) const;
|
||||
|
||||
int GetReservedSurfaceIndex( const char *pPropertyName ) const;
|
||||
|
||||
// The database is derived from the IVP material class
|
||||
const IVP_Material *GetIVPMaterial( int materialIndex ) const;
|
||||
IVP_Material *GetIVPMaterial( int materialIndex );
|
||||
virtual int GetIVPMaterialIndex( const IVP_Material *pIVP ) const;
|
||||
IVP_Material_Manager *GetIVPManager( void ) { return &m_ivpManager; }
|
||||
|
||||
const char *GetNameString( CUtlSymbol name ) const
|
||||
{
|
||||
return m_strings.String(name);
|
||||
}
|
||||
|
||||
private:
|
||||
const CSurface *GetInternalSurface( int materialIndex ) const;
|
||||
CSurface *GetInternalSurface( int materialIndex );
|
||||
|
||||
void CopyPhysicsProperties( CSurface *pOut, int baseIndex );
|
||||
bool AddFileToDatabase( const char *pFilename );
|
||||
|
||||
private:
|
||||
CUtlSymbolTableMT m_strings;
|
||||
CUtlVector<CSurface> m_props;
|
||||
CUtlVector<CUtlSymbol> m_fileList;
|
||||
CIVPMaterialManager m_ivpManager;
|
||||
bool m_init;
|
||||
int m_shadowFallback;
|
||||
};
|
||||
|
||||
|
||||
// Singleton database object
|
||||
CPhysicsSurfaceProps g_SurfaceDatabase;
|
||||
EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CPhysicsSurfaceProps, IPhysicsSurfaceProps, VPHYSICS_SURFACEPROPS_INTERFACE_VERSION, g_SurfaceDatabase);
|
||||
|
||||
|
||||
// Global pointer to singleton for VPHYSICS.DLL internal access
|
||||
IPhysicsSurfacePropsInternal *physprops = &g_SurfaceDatabase;
|
||||
|
||||
|
||||
const char *CSurface::get_name()
|
||||
{
|
||||
return g_SurfaceDatabase.GetNameString( m_name );
|
||||
}
|
||||
|
||||
CPhysicsSurfaceProps::CPhysicsSurfaceProps( void ) : m_fileList(8,8), m_strings( 0, 32, true )
|
||||
{
|
||||
m_ivpManager.Init( this );
|
||||
// Force index 0 to be the empty string. Allows game code to check for zero, but
|
||||
// still resolve to a string
|
||||
m_strings.AddString("");
|
||||
m_init = false;
|
||||
m_shadowFallback = 0;
|
||||
}
|
||||
|
||||
|
||||
CPhysicsSurfaceProps::~CPhysicsSurfaceProps( void )
|
||||
{
|
||||
}
|
||||
|
||||
int CPhysicsSurfaceProps::SurfacePropCount( void ) const
|
||||
{
|
||||
return m_props.Size();
|
||||
}
|
||||
|
||||
// Add the filename to a list to make sure each file is only processed once
|
||||
bool CPhysicsSurfaceProps::AddFileToDatabase( const char *pFilename )
|
||||
{
|
||||
CUtlSymbol id = m_strings.AddString( pFilename );
|
||||
|
||||
for ( int i = 0; i < m_fileList.Size(); i++ )
|
||||
{
|
||||
if ( m_fileList[i] == id )
|
||||
return false;
|
||||
}
|
||||
|
||||
m_fileList.AddToTail( id );
|
||||
return true;
|
||||
}
|
||||
|
||||
int CPhysicsSurfaceProps::GetSurfaceIndex( const char *pPropertyName ) const
|
||||
{
|
||||
if ( pPropertyName[0] == '$' )
|
||||
{
|
||||
int index = GetReservedSurfaceIndex( pPropertyName );
|
||||
if ( index >= 0 )
|
||||
return index;
|
||||
}
|
||||
|
||||
CUtlSymbol id = m_strings.Find( pPropertyName );
|
||||
if ( id.IsValid() )
|
||||
{
|
||||
// BUGBUG: Linear search is slow!!!
|
||||
for ( int i = 0; i < m_props.Size(); i++ )
|
||||
{
|
||||
// NOTE: Just comparing strings by index is pretty fast though
|
||||
if ( m_props[i].m_name == id )
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
const char *CPhysicsSurfaceProps::GetPropName( int surfaceDataIndex ) const
|
||||
{
|
||||
const CSurface *pSurface = GetInternalSurface( surfaceDataIndex );
|
||||
if ( pSurface )
|
||||
{
|
||||
return GetNameString( pSurface->m_name );
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
// UNDONE: move reserved materials into this table, or into a parallel table
|
||||
// that gets hooked out here.
|
||||
CSurface *CPhysicsSurfaceProps::GetInternalSurface( int materialIndex )
|
||||
{
|
||||
if ( IsReservedMaterialIndex( materialIndex ) )
|
||||
{
|
||||
materialIndex = GetReservedFallBack( materialIndex );
|
||||
}
|
||||
if ( materialIndex < 0 || materialIndex > m_props.Size()-1 )
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
return &m_props[materialIndex];
|
||||
}
|
||||
|
||||
// this function is actually const except for the return type, so this is safe
|
||||
const CSurface *CPhysicsSurfaceProps::GetInternalSurface( int materialIndex ) const
|
||||
{
|
||||
return const_cast<CPhysicsSurfaceProps *>(this)->GetInternalSurface(materialIndex);
|
||||
}
|
||||
|
||||
void CPhysicsSurfaceProps::GetPhysicsProperties( int materialIndex, float *density, float *thickness, float *friction, float *elasticity ) const
|
||||
{
|
||||
const CSurface *pSurface = GetInternalSurface( materialIndex );
|
||||
if ( !pSurface )
|
||||
{
|
||||
pSurface = GetInternalSurface( GetSurfaceIndex( "default" ) );
|
||||
Assert ( pSurface );
|
||||
}
|
||||
if ( pSurface )
|
||||
{
|
||||
if ( friction )
|
||||
{
|
||||
*friction = (float)pSurface->data.physics.friction;
|
||||
}
|
||||
if ( elasticity )
|
||||
{
|
||||
*elasticity = (float)pSurface->data.physics.elasticity;
|
||||
}
|
||||
if ( density )
|
||||
{
|
||||
*density = pSurface->data.physics.density;
|
||||
}
|
||||
if ( thickness )
|
||||
{
|
||||
*thickness = pSurface->data.physics.thickness;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CPhysicsSurfaceProps::GetPhysicsParameters( int surfaceDataIndex, surfacephysicsparams_t *pParamsOut ) const
|
||||
{
|
||||
if ( !pParamsOut )
|
||||
return;
|
||||
|
||||
const CSurface *pSurface = GetInternalSurface( surfaceDataIndex );
|
||||
if ( pSurface )
|
||||
{
|
||||
*pParamsOut = pSurface->data.physics;
|
||||
}
|
||||
}
|
||||
|
||||
surfacedata_t *CPhysicsSurfaceProps::GetSurfaceData( int materialIndex )
|
||||
{
|
||||
CSurface *pSurface = GetInternalSurface( materialIndex );
|
||||
if (!pSurface)
|
||||
pSurface = GetInternalSurface( 0 ); // Zero is always the "default" property
|
||||
|
||||
Assert ( pSurface );
|
||||
return &pSurface->data;
|
||||
}
|
||||
|
||||
const char *CPhysicsSurfaceProps::GetString( unsigned short stringTableIndex ) const
|
||||
{
|
||||
return m_strings.String( stringTableIndex );
|
||||
}
|
||||
|
||||
|
||||
bool CPhysicsSurfaceProps::IsReservedMaterialIndex( int materialIndex ) const
|
||||
{
|
||||
return (materialIndex > 127) ? true : false;
|
||||
}
|
||||
|
||||
const char *CPhysicsSurfaceProps::GetReservedMaterialName( int materialIndex ) const
|
||||
{
|
||||
// NOTE: All of these must start with '$'
|
||||
switch( materialIndex )
|
||||
{
|
||||
case MATERIAL_INDEX_SHADOW:
|
||||
return "$MATERIAL_INDEX_SHADOW";
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int CPhysicsSurfaceProps::GetReservedSurfaceIndex( const char *pPropertyName ) const
|
||||
{
|
||||
if ( !Q_stricmp( pPropertyName, "$MATERIAL_INDEX_SHADOW" ) )
|
||||
{
|
||||
return MATERIAL_INDEX_SHADOW;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
const IVP_Material *CPhysicsSurfaceProps::GetIVPMaterial( int materialIndex ) const
|
||||
{
|
||||
return GetInternalSurface(materialIndex);
|
||||
}
|
||||
|
||||
IVP_Material *CPhysicsSurfaceProps::GetIVPMaterial( int materialIndex )
|
||||
{
|
||||
return GetInternalSurface(materialIndex);
|
||||
}
|
||||
|
||||
|
||||
int CPhysicsSurfaceProps::GetReservedFallBack( int materialIndex ) const
|
||||
{
|
||||
switch( materialIndex )
|
||||
{
|
||||
case MATERIAL_INDEX_SHADOW:
|
||||
return m_shadowFallback;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int CPhysicsSurfaceProps::GetIVPMaterialIndex( const IVP_Material *pIVP ) const
|
||||
{
|
||||
int index = (const CSurface *)pIVP - m_props.Base();
|
||||
if ( index >= 0 && index < m_props.Size() )
|
||||
return index;
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
void CPhysicsSurfaceProps::CopyPhysicsProperties( CSurface *pOut, int baseIndex )
|
||||
{
|
||||
const CSurface *pSurface = GetInternalSurface( baseIndex );
|
||||
if ( pSurface )
|
||||
{
|
||||
pOut->data = pSurface->data;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int CPhysicsSurfaceProps::ParseSurfaceData( const char *pFileName, const char *pTextfile )
|
||||
{
|
||||
if ( !AddFileToDatabase( pFileName ) )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
const char *pText = pTextfile;
|
||||
|
||||
do
|
||||
{
|
||||
char key[MAX_KEYVALUE], value[MAX_KEYVALUE];
|
||||
|
||||
pText = ParseKeyvalue( pText, key, value );
|
||||
if ( !strcmp(value, "{") )
|
||||
{
|
||||
CSurface prop;
|
||||
memset( &prop.data, 0, sizeof(prop.data) );
|
||||
prop.m_name = m_strings.AddString( key );
|
||||
int baseMaterial = GetSurfaceIndex( key );
|
||||
if ( baseMaterial < 0 )
|
||||
{
|
||||
baseMaterial = GetSurfaceIndex( "default" );
|
||||
}
|
||||
|
||||
CopyPhysicsProperties( &prop, baseMaterial );
|
||||
|
||||
do
|
||||
{
|
||||
pText = ParseKeyvalue( pText, key, value );
|
||||
if ( !strcmpi( key, "}" ) )
|
||||
{
|
||||
// already in the database, don't add again, override values instead
|
||||
const char *pOverride = m_strings.String(prop.m_name);
|
||||
int propIndex = GetSurfaceIndex( pOverride );
|
||||
if ( propIndex >= 0 )
|
||||
{
|
||||
CSurface *pSurface = GetInternalSurface( propIndex );
|
||||
pSurface->data = prop.data;
|
||||
break;
|
||||
}
|
||||
|
||||
m_props.AddToTail( prop );
|
||||
break;
|
||||
}
|
||||
else if ( !strcmpi( key, "base" ) )
|
||||
{
|
||||
baseMaterial = GetSurfaceIndex( value );
|
||||
CopyPhysicsProperties( &prop, baseMaterial );
|
||||
}
|
||||
else if ( !strcmpi( key, "thickness" ) )
|
||||
{
|
||||
prop.data.physics.thickness = atof(value);
|
||||
}
|
||||
else if ( !strcmpi( key, "density" ) )
|
||||
{
|
||||
prop.data.physics.density = atof(value);
|
||||
}
|
||||
else if ( !strcmpi( key, "elasticity" ) )
|
||||
{
|
||||
prop.data.physics.elasticity = atof(value);
|
||||
}
|
||||
else if ( !strcmpi( key, "friction" ) )
|
||||
{
|
||||
prop.data.physics.friction = atof(value);
|
||||
}
|
||||
else if ( !strcmpi( key, "maxspeedfactor" ) )
|
||||
{
|
||||
prop.data.game.maxSpeedFactor = atof(value);
|
||||
}
|
||||
else if ( !strcmpi( key, "jumpfactor" ) )
|
||||
{
|
||||
prop.data.game.jumpFactor = atof(value);
|
||||
}
|
||||
else if ( !strcmpi( key, "climbable" ) )
|
||||
{
|
||||
prop.data.game.climbable = atoi(value);
|
||||
}
|
||||
// audio parameters
|
||||
else if ( !strcmpi( key, "audioReflectivity" ) )
|
||||
{
|
||||
prop.data.audio.reflectivity = atof(value);
|
||||
}
|
||||
else if ( !strcmpi( key, "audioHardnessFactor" ) )
|
||||
{
|
||||
prop.data.audio.hardnessFactor = atof(value);
|
||||
}
|
||||
else if ( !strcmpi( key, "audioHardMinVelocity" ) )
|
||||
{
|
||||
prop.data.audio.hardVelocityThreshold = atof(value);
|
||||
}
|
||||
else if ( !strcmpi( key, "audioRoughnessFactor" ) )
|
||||
{
|
||||
prop.data.audio.roughnessFactor = atof(value);
|
||||
}
|
||||
else if ( !strcmpi( key, "scrapeRoughThreshold" ) )
|
||||
{
|
||||
prop.data.audio.roughThreshold = atof(value);
|
||||
}
|
||||
else if ( !strcmpi( key, "impactHardThreshold" ) )
|
||||
{
|
||||
prop.data.audio.hardThreshold = atof(value);
|
||||
}
|
||||
// sound names
|
||||
else if ( !strcmpi( key, "stepleft" ) )
|
||||
{
|
||||
prop.data.sounds.stepleft = m_strings.AddString( value );
|
||||
}
|
||||
else if ( !strcmpi( key, "stepright" ) )
|
||||
{
|
||||
prop.data.sounds.stepright = m_strings.AddString( value );
|
||||
}
|
||||
else if ( !strcmpi( key, "impactsoft" ) )
|
||||
{
|
||||
prop.data.sounds.impactSoft = m_strings.AddString( value );
|
||||
}
|
||||
else if ( !strcmpi( key, "impacthard" ) )
|
||||
{
|
||||
prop.data.sounds.impactHard = m_strings.AddString( value );
|
||||
}
|
||||
else if ( !strcmpi( key, "scrapesmooth" ) )
|
||||
{
|
||||
prop.data.sounds.scrapeSmooth = m_strings.AddString( value );
|
||||
}
|
||||
else if ( !strcmpi( key, "scraperough" ) )
|
||||
{
|
||||
prop.data.sounds.scrapeRough = m_strings.AddString( value );
|
||||
}
|
||||
else if ( !strcmpi( key, "bulletimpact" ) )
|
||||
{
|
||||
prop.data.sounds.bulletImpact = m_strings.AddString( value );
|
||||
}
|
||||
else if ( !strcmpi( key, "break" ) )
|
||||
{
|
||||
prop.data.sounds.breakSound = m_strings.AddString( value );
|
||||
}
|
||||
else if ( !strcmpi( key, "strain" ) )
|
||||
{
|
||||
prop.data.sounds.strainSound = m_strings.AddString( value );
|
||||
}
|
||||
else if ( !strcmpi( key, "rolling" ) )
|
||||
{
|
||||
prop.data.sounds.rolling = m_strings.AddString( value );
|
||||
}
|
||||
else if ( !strcmpi( key, "gamematerial" ) )
|
||||
{
|
||||
if ( strlen(value) == 1 && !V_isdigit( value[0]) )
|
||||
{
|
||||
prop.data.game.material = toupper(value[0]);
|
||||
}
|
||||
else
|
||||
{
|
||||
prop.data.game.material = atoi(value);
|
||||
}
|
||||
}
|
||||
else if ( !strcmpi( key, "dampening" ) )
|
||||
{
|
||||
prop.data.physics.dampening = atof(value);
|
||||
}
|
||||
else
|
||||
{
|
||||
// force a breakpoint
|
||||
AssertMsg2( 0, "Bad surfaceprop key %s (%s)\n", key, value );
|
||||
}
|
||||
} while (pText);
|
||||
}
|
||||
} while (pText);
|
||||
|
||||
if ( !m_init )
|
||||
{
|
||||
m_init = true;
|
||||
//AddReservedMaterials
|
||||
CSurface prop;
|
||||
|
||||
int baseMaterial = GetSurfaceIndex( "default" );
|
||||
memset( &prop.data, 0, sizeof(prop.data) );
|
||||
prop.m_name = m_strings.AddString( GetReservedMaterialName(MATERIAL_INDEX_SHADOW) );
|
||||
CopyPhysicsProperties( &prop, baseMaterial );
|
||||
prop.data.physics.elasticity = 1e-3f;
|
||||
prop.data.physics.friction = 0.8f;
|
||||
m_shadowFallback = m_props.AddToTail( prop );
|
||||
}
|
||||
return m_props.Size();
|
||||
}
|
||||
|
||||
|
||||
void CPhysicsSurfaceProps::SetWorldMaterialIndexTable( int *pMapArray, int mapSize )
|
||||
{
|
||||
m_ivpManager.SetPropMap( pMapArray, mapSize );
|
||||
}
|
||||
|
||||
CIVPMaterialManager::CIVPMaterialManager( void ) : IVP_Material_Manager( IVP_FALSE )
|
||||
{
|
||||
// by default every index maps to itself (NULL translation)
|
||||
for ( int i = 0; i < ARRAYSIZE(m_propMap); i++ )
|
||||
{
|
||||
m_propMap[i] = i;
|
||||
}
|
||||
}
|
||||
|
||||
int CIVPMaterialManager::RemapIVPMaterialIndex( int ivpMaterialIndex ) const
|
||||
{
|
||||
if ( ivpMaterialIndex > 127 )
|
||||
return ivpMaterialIndex;
|
||||
|
||||
return m_propMap[ivpMaterialIndex];
|
||||
}
|
||||
|
||||
// remap the incoming (from IVP) index and get the appropriate material
|
||||
// note that ivp will only supply indices between 1 and 127
|
||||
IVP_Material *CIVPMaterialManager::get_material_by_index(IVP_Real_Object *pObject, const IVP_U_Point *world_position, int index)
|
||||
{
|
||||
IVP_Material *tmp = m_props->GetIVPMaterial( RemapIVPMaterialIndex(index) );
|
||||
Assert(tmp);
|
||||
if ( tmp )
|
||||
{
|
||||
return tmp;
|
||||
}
|
||||
else
|
||||
{
|
||||
return m_props->GetIVPMaterial( m_props->GetSurfaceIndex( "default" ) );
|
||||
}
|
||||
}
|
||||
|
||||
// Installs a LUT for remapping IVP material indices to physprop indices
|
||||
// A table of the names of the materials in index order is stored with the
|
||||
// compiled bsp file. This is then remapped dynamically without touching the
|
||||
// per-triangle indices on load. If we wanted to support multiple LUTs, it would
|
||||
// be better to preprocess/remap the triangles in the collision models at load time
|
||||
void CIVPMaterialManager::SetPropMap( int *map, int mapSize )
|
||||
{
|
||||
// ??? just ignore any extra bits
|
||||
if ( mapSize > 128 )
|
||||
{
|
||||
mapSize = 128;
|
||||
}
|
||||
|
||||
for ( int i = 0; i < mapSize; i++ )
|
||||
{
|
||||
m_propMap[i] = (unsigned short)map[i];
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user