644 lines
17 KiB
C++
644 lines
17 KiB
C++
//========= 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];
|
|
}
|
|
}
|