/*
===========================================================================
Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Doom 3 BFG Edition Source Code. If not, see .
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
===========================================================================
*/
#include "../idlib/precompiled.h"
#pragma hdrstop
#include "Game_local.h"
/*
===============================================================================
idEntity
===============================================================================
*/
idCVar net_errorSmoothingMaxDecay( "net_errorSmoothingMaxDecay", "25.0", CVAR_FLOAT, "Max rate at which origin error smoothing decays (in units per game frame)" );
idCVar net_errorSmoothingDecay( "net_errorSmoothingDecay", "0.06", CVAR_FLOAT, "Rate at which error smoothing decays (in percent per game frame)" );
// overridable events
const idEventDef EV_PostSpawn( "", NULL );
const idEventDef EV_FindTargets( "", NULL );
const idEventDef EV_Touch( "", "et" );
const idEventDef EV_GetName( "getName", NULL, 's' );
const idEventDef EV_SetName( "setName", "s" );
const idEventDef EV_Activate( "activate", "e" );
const idEventDef EV_ActivateTargets( "activateTargets", "e" );
const idEventDef EV_NumTargets( "numTargets", NULL, 'f' );
const idEventDef EV_GetTarget( "getTarget", "f", 'e' );
const idEventDef EV_RandomTarget( "randomTarget", "s", 'e' );
const idEventDef EV_Bind( "bind", "e" );
const idEventDef EV_BindPosition( "bindPosition", "e" );
const idEventDef EV_BindToJoint( "bindToJoint", "esf" );
const idEventDef EV_Unbind( "unbind", NULL );
const idEventDef EV_RemoveBinds( "removeBinds" );
const idEventDef EV_SpawnBind( "", NULL );
const idEventDef EV_SetOwner( "setOwner", "e" );
const idEventDef EV_SetModel( "setModel", "s" );
const idEventDef EV_SetSkin( "setSkin", "s" );
const idEventDef EV_GetWorldOrigin( "getWorldOrigin", NULL, 'v' );
const idEventDef EV_SetWorldOrigin( "setWorldOrigin", "v" );
const idEventDef EV_GetOrigin( "getOrigin", NULL, 'v' );
const idEventDef EV_SetOrigin( "setOrigin", "v" );
const idEventDef EV_GetAngles( "getAngles", NULL, 'v' );
const idEventDef EV_SetAngles( "setAngles", "v" );
const idEventDef EV_GetLinearVelocity( "getLinearVelocity", NULL, 'v' );
const idEventDef EV_SetLinearVelocity( "setLinearVelocity", "v" );
const idEventDef EV_GetAngularVelocity( "getAngularVelocity", NULL, 'v' );
const idEventDef EV_SetAngularVelocity( "setAngularVelocity", "v" );
const idEventDef EV_GetSize( "getSize", NULL, 'v' );
const idEventDef EV_SetSize( "setSize", "vv" );
const idEventDef EV_GetMins( "getMins", NULL, 'v' );
const idEventDef EV_GetMaxs( "getMaxs", NULL, 'v' );
const idEventDef EV_IsHidden( "isHidden", NULL, 'd' );
const idEventDef EV_Hide( "hide", NULL );
const idEventDef EV_Show( "show", NULL );
const idEventDef EV_Touches( "touches", "E", 'd' );
const idEventDef EV_ClearSignal( "clearSignal", "d" );
const idEventDef EV_GetShaderParm( "getShaderParm", "d", 'f' );
const idEventDef EV_SetShaderParm( "setShaderParm", "df" );
const idEventDef EV_SetShaderParms( "setShaderParms", "ffff" );
const idEventDef EV_SetColor( "setColor", "fff" );
const idEventDef EV_GetColor( "getColor", NULL, 'v' );
const idEventDef EV_CacheSoundShader( "cacheSoundShader", "s" );
const idEventDef EV_StartSoundShader( "startSoundShader", "sd", 'f' );
const idEventDef EV_StartSound( "startSound", "sdd", 'f' );
const idEventDef EV_StopSound( "stopSound", "dd" );
const idEventDef EV_FadeSound( "fadeSound", "dff" );
const idEventDef EV_SetGuiParm( "setGuiParm", "ss" );
const idEventDef EV_SetGuiFloat( "setGuiFloat", "sf" );
const idEventDef EV_GetNextKey( "getNextKey", "ss", 's' );
const idEventDef EV_SetKey( "setKey", "ss" );
const idEventDef EV_GetKey( "getKey", "s", 's' );
const idEventDef EV_GetIntKey( "getIntKey", "s", 'f' );
const idEventDef EV_GetFloatKey( "getFloatKey", "s", 'f' );
const idEventDef EV_GetVectorKey( "getVectorKey", "s", 'v' );
const idEventDef EV_GetEntityKey( "getEntityKey", "s", 'e' );
const idEventDef EV_RestorePosition( "restorePosition" );
const idEventDef EV_UpdateCameraTarget( "", NULL );
const idEventDef EV_DistanceTo( "distanceTo", "E", 'f' );
const idEventDef EV_DistanceToPoint( "distanceToPoint", "v", 'f' );
const idEventDef EV_StartFx( "startFx", "s" );
const idEventDef EV_HasFunction( "hasFunction", "s", 'd' );
const idEventDef EV_CallFunction( "callFunction", "s" );
const idEventDef EV_SetNeverDormant( "setNeverDormant", "d" );
const idEventDef EV_SetGui( "setGui", "ds" );
const idEventDef EV_PrecacheGui( "precacheGui", "s" );
const idEventDef EV_GetGuiParm( "getGuiParm", "ds", 's' );
const idEventDef EV_GetGuiParmFloat( "getGuiParmFloat", "ds", 'f' );
const idEventDef EV_MotionBlurOn( "motionBlurOn" );
const idEventDef EV_MotionBlurOff( "motionBlurOff" );
const idEventDef EV_GuiNamedEvent( "guiNamedEvent", "ds" );
ABSTRACT_DECLARATION( idClass, idEntity )
EVENT( EV_GetName, idEntity::Event_GetName )
EVENT( EV_SetName, idEntity::Event_SetName )
EVENT( EV_FindTargets, idEntity::Event_FindTargets )
EVENT( EV_ActivateTargets, idEntity::Event_ActivateTargets )
EVENT( EV_NumTargets, idEntity::Event_NumTargets )
EVENT( EV_GetTarget, idEntity::Event_GetTarget )
EVENT( EV_RandomTarget, idEntity::Event_RandomTarget )
EVENT( EV_BindToJoint, idEntity::Event_BindToJoint )
EVENT( EV_RemoveBinds, idEntity::Event_RemoveBinds )
EVENT( EV_Bind, idEntity::Event_Bind )
EVENT( EV_BindPosition, idEntity::Event_BindPosition )
EVENT( EV_Unbind, idEntity::Event_Unbind )
EVENT( EV_SpawnBind, idEntity::Event_SpawnBind )
EVENT( EV_SetOwner, idEntity::Event_SetOwner )
EVENT( EV_SetModel, idEntity::Event_SetModel )
EVENT( EV_SetSkin, idEntity::Event_SetSkin )
EVENT( EV_GetShaderParm, idEntity::Event_GetShaderParm )
EVENT( EV_SetShaderParm, idEntity::Event_SetShaderParm )
EVENT( EV_SetShaderParms, idEntity::Event_SetShaderParms )
EVENT( EV_SetColor, idEntity::Event_SetColor )
EVENT( EV_GetColor, idEntity::Event_GetColor )
EVENT( EV_IsHidden, idEntity::Event_IsHidden )
EVENT( EV_Hide, idEntity::Event_Hide )
EVENT( EV_Show, idEntity::Event_Show )
EVENT( EV_CacheSoundShader, idEntity::Event_CacheSoundShader )
EVENT( EV_StartSoundShader, idEntity::Event_StartSoundShader )
EVENT( EV_StartSound, idEntity::Event_StartSound )
EVENT( EV_StopSound, idEntity::Event_StopSound )
EVENT( EV_FadeSound, idEntity::Event_FadeSound )
EVENT( EV_GetWorldOrigin, idEntity::Event_GetWorldOrigin )
EVENT( EV_SetWorldOrigin, idEntity::Event_SetWorldOrigin )
EVENT( EV_GetOrigin, idEntity::Event_GetOrigin )
EVENT( EV_SetOrigin, idEntity::Event_SetOrigin )
EVENT( EV_GetAngles, idEntity::Event_GetAngles )
EVENT( EV_SetAngles, idEntity::Event_SetAngles )
EVENT( EV_GetLinearVelocity, idEntity::Event_GetLinearVelocity )
EVENT( EV_SetLinearVelocity, idEntity::Event_SetLinearVelocity )
EVENT( EV_GetAngularVelocity, idEntity::Event_GetAngularVelocity )
EVENT( EV_SetAngularVelocity, idEntity::Event_SetAngularVelocity )
EVENT( EV_GetSize, idEntity::Event_GetSize )
EVENT( EV_SetSize, idEntity::Event_SetSize )
EVENT( EV_GetMins, idEntity::Event_GetMins )
EVENT( EV_GetMaxs, idEntity::Event_GetMaxs )
EVENT( EV_Touches, idEntity::Event_Touches )
EVENT( EV_SetGuiParm, idEntity::Event_SetGuiParm )
EVENT( EV_SetGuiFloat, idEntity::Event_SetGuiFloat )
EVENT( EV_GetNextKey, idEntity::Event_GetNextKey )
EVENT( EV_SetKey, idEntity::Event_SetKey )
EVENT( EV_GetKey, idEntity::Event_GetKey )
EVENT( EV_GetIntKey, idEntity::Event_GetIntKey )
EVENT( EV_GetFloatKey, idEntity::Event_GetFloatKey )
EVENT( EV_GetVectorKey, idEntity::Event_GetVectorKey )
EVENT( EV_GetEntityKey, idEntity::Event_GetEntityKey )
EVENT( EV_RestorePosition, idEntity::Event_RestorePosition )
EVENT( EV_UpdateCameraTarget, idEntity::Event_UpdateCameraTarget )
EVENT( EV_DistanceTo, idEntity::Event_DistanceTo )
EVENT( EV_DistanceToPoint, idEntity::Event_DistanceToPoint )
EVENT( EV_StartFx, idEntity::Event_StartFx )
EVENT( EV_Thread_WaitFrame, idEntity::Event_WaitFrame )
EVENT( EV_Thread_Wait, idEntity::Event_Wait )
EVENT( EV_HasFunction, idEntity::Event_HasFunction )
EVENT( EV_CallFunction, idEntity::Event_CallFunction )
EVENT( EV_SetNeverDormant, idEntity::Event_SetNeverDormant )
EVENT( EV_SetGui, idEntity::Event_SetGui )
EVENT( EV_PrecacheGui, idEntity::Event_PrecacheGui )
EVENT( EV_GetGuiParm, idEntity::Event_GetGuiParm )
EVENT( EV_GetGuiParmFloat, idEntity::Event_GetGuiParmFloat )
EVENT( EV_GuiNamedEvent, idEntity::Event_GuiNamedEvent )
END_CLASS
/*
================
UpdateGuiParms
================
*/
void UpdateGuiParms( idUserInterface* gui, const idDict* args )
{
if( gui == NULL || args == NULL )
{
return;
}
const idKeyValue* kv = args->MatchPrefix( "gui_parm", NULL );
while( kv )
{
gui->SetStateString( kv->GetKey(), kv->GetValue() );
kv = args->MatchPrefix( "gui_parm", kv );
}
gui->SetStateBool( "noninteractive", args->GetBool( "gui_noninteractive" ) ) ;
gui->StateChanged( gameLocal.time );
}
/*
================
AddRenderGui
================
*/
void AddRenderGui( const char* name, idUserInterface** gui, const idDict* args )
{
const idKeyValue* kv = args->MatchPrefix( "gui_parm", NULL );
*gui = uiManager->FindGui( name, true, ( kv != NULL ) );
UpdateGuiParms( *gui, args );
}
/*
================
idGameEdit::ParseSpawnArgsToRenderEntity
parse the static model parameters
this is the canonical renderEntity parm parsing,
which should be used by dmap and the editor
================
*/
void idGameEdit::ParseSpawnArgsToRenderEntity( const idDict* args, renderEntity_t* renderEntity )
{
int i;
const char* temp;
idVec3 color;
float angle;
const idDeclModelDef* modelDef;
memset( renderEntity, 0, sizeof( *renderEntity ) );
temp = args->GetString( "model" );
modelDef = NULL;
if( temp[0] != '\0' )
{
modelDef = static_cast( declManager->FindType( DECL_MODELDEF, temp, false ) );
if( modelDef )
{
renderEntity->hModel = modelDef->ModelHandle();
}
if( !renderEntity->hModel )
{
renderEntity->hModel = renderModelManager->FindModel( temp );
}
}
if( renderEntity->hModel )
{
renderEntity->bounds = renderEntity->hModel->Bounds( renderEntity );
}
else
{
renderEntity->bounds.Zero();
}
temp = args->GetString( "skin" );
if( temp[0] != '\0' )
{
renderEntity->customSkin = declManager->FindSkin( temp );
}
else if( modelDef )
{
renderEntity->customSkin = modelDef->GetDefaultSkin();
}
temp = args->GetString( "shader" );
if( temp[0] != '\0' )
{
renderEntity->customShader = declManager->FindMaterial( temp );
}
args->GetVector( "origin", "0 0 0", renderEntity->origin );
// get the rotation matrix in either full form, or single angle form
if( !args->GetMatrix( "rotation", "1 0 0 0 1 0 0 0 1", renderEntity->axis ) )
{
angle = args->GetFloat( "angle" );
if( angle != 0.0f )
{
renderEntity->axis = idAngles( 0.0f, angle, 0.0f ).ToMat3();
}
else
{
renderEntity->axis.Identity();
}
}
renderEntity->referenceSound = NULL;
// get shader parms
args->GetVector( "_color", "1 1 1", color );
renderEntity->shaderParms[ SHADERPARM_RED ] = color[0];
renderEntity->shaderParms[ SHADERPARM_GREEN ] = color[1];
renderEntity->shaderParms[ SHADERPARM_BLUE ] = color[2];
renderEntity->shaderParms[ 3 ] = args->GetFloat( "shaderParm3", "1" );
renderEntity->shaderParms[ 4 ] = args->GetFloat( "shaderParm4", "0" );
renderEntity->shaderParms[ 5 ] = args->GetFloat( "shaderParm5", "0" );
renderEntity->shaderParms[ 6 ] = args->GetFloat( "shaderParm6", "0" );
renderEntity->shaderParms[ 7 ] = args->GetFloat( "shaderParm7", "0" );
renderEntity->shaderParms[ 8 ] = args->GetFloat( "shaderParm8", "0" );
renderEntity->shaderParms[ 9 ] = args->GetFloat( "shaderParm9", "0" );
renderEntity->shaderParms[ 10 ] = args->GetFloat( "shaderParm10", "0" );
renderEntity->shaderParms[ 11 ] = args->GetFloat( "shaderParm11", "0" );
// check noDynamicInteractions flag
renderEntity->noDynamicInteractions = args->GetBool( "noDynamicInteractions" );
// check noshadows flag
renderEntity->noShadow = args->GetBool( "noshadows" );
// check noselfshadows flag
renderEntity->noSelfShadow = args->GetBool( "noselfshadows" );
// init any guis, including entity-specific states
for( i = 0; i < MAX_RENDERENTITY_GUI; i++ )
{
temp = args->GetString( i == 0 ? "gui" : va( "gui%d", i + 1 ) );
if( temp[ 0 ] != '\0' )
{
AddRenderGui( temp, &renderEntity->gui[ i ], args );
}
}
}
/*
================
idGameEdit::ParseSpawnArgsToRefSound
parse the sound parameters
this is the canonical refSound parm parsing,
which should be used by dmap and the editor
================
*/
void idGameEdit::ParseSpawnArgsToRefSound( const idDict* args, refSound_t* refSound )
{
const char* temp;
memset( refSound, 0, sizeof( *refSound ) );
refSound->parms.minDistance = args->GetFloat( "s_mindistance" );
refSound->parms.maxDistance = args->GetFloat( "s_maxdistance" );
refSound->parms.volume = args->GetFloat( "s_volume" );
refSound->parms.shakes = args->GetFloat( "s_shakes" );
args->GetVector( "origin", "0 0 0", refSound->origin );
refSound->referenceSound = NULL;
// if a diversity is not specified, every sound start will make
// a random one. Specifying diversity is usefull to make multiple
// lights all share the same buzz sound offset, for instance.
refSound->diversity = args->GetFloat( "s_diversity", "-1" );
refSound->waitfortrigger = args->GetBool( "s_waitfortrigger" );
if( args->GetBool( "s_omni" ) )
{
refSound->parms.soundShaderFlags |= SSF_OMNIDIRECTIONAL;
}
if( args->GetBool( "s_looping" ) )
{
refSound->parms.soundShaderFlags |= SSF_LOOPING;
}
if( args->GetBool( "s_occlusion" ) )
{
refSound->parms.soundShaderFlags |= SSF_NO_OCCLUSION;
}
if( args->GetBool( "s_global" ) )
{
refSound->parms.soundShaderFlags |= SSF_GLOBAL;
}
if( args->GetBool( "s_unclamped" ) )
{
refSound->parms.soundShaderFlags |= SSF_UNCLAMPED;
}
refSound->parms.soundClass = args->GetInt( "s_soundClass" );
temp = args->GetString( "s_shader" );
if( temp[0] != '\0' )
{
refSound->shader = declManager->FindSound( temp );
}
}
/*
===============
idEntity::UpdateChangeableSpawnArgs
Any key val pair that might change during the course of the game ( via a gui or whatever )
should be initialize here so a gui or other trigger can change something and have it updated
properly. An optional source may be provided if the values reside in an outside dictionary and
first need copied over to spawnArgs
===============
*/
void idEntity::UpdateChangeableSpawnArgs( const idDict* source )
{
int i;
const char* target;
if( !source )
{
source = &spawnArgs;
}
cameraTarget = NULL;
target = source->GetString( "cameraTarget" );
if( target != NULL && target[0] != '\0' )
{
// update the camera taget
PostEventMS( &EV_UpdateCameraTarget, 0 );
}
for( i = 0; i < MAX_RENDERENTITY_GUI; i++ )
{
UpdateGuiParms( renderEntity.gui[ i ], source );
}
}
/*
================
idEntity::idEntity
================
*/
idEntity::idEntity():
useClientInterpolation( true ),
predictionKey( INVALID_PREDICTION_KEY ),
originDelta( vec3_zero ),
axisDelta( mat3_identity ),
interpolationBehavior( USE_NO_INTERPOLATION )
{
entityNumber = ENTITYNUM_NONE;
entityDefNumber = -1;
spawnNode.SetOwner( this );
activeNode.SetOwner( this );
snapshotNode.SetOwner( this );
snapshotChanged = -1;
snapshotStale = false;
snapshotBits = 0;
thinkFlags = 0;
dormantStart = 0;
cinematic = false;
renderView = NULL;
cameraTarget = NULL;
health = 0;
physics = NULL;
bindMaster = NULL;
bindJoint = INVALID_JOINT;
bindBody = -1;
teamMaster = NULL;
teamChain = NULL;
signals = NULL;
snapshotsReceived = 0;
memset( PVSAreas, 0, sizeof( PVSAreas ) );
numPVSAreas = -1;
memset( &fl, 0, sizeof( fl ) );
fl.neverDormant = true; // most entities never go dormant
memset( &renderEntity, 0, sizeof( renderEntity ) );
modelDefHandle = -1;
memset( &refSound, 0, sizeof( refSound ) );
mpGUIState = -1;
memset( &xrayEntity, 0, sizeof( xrayEntity ) );
timeGroup = TIME_GROUP1;
xrayEntityHandle = -1;
xraySkin = NULL;
noGrab = false;
}
/*
================
idEntity::FixupLocalizedStrings
================
*/
void idEntity::FixupLocalizedStrings()
{
for( int i = 0; i < spawnArgs.GetNumKeyVals(); i++ )
{
const idKeyValue* kv = spawnArgs.GetKeyVal( i );
if( idStr::Cmpn( kv->GetValue(), STRTABLE_ID, STRTABLE_ID_LENGTH ) == 0 )
{
spawnArgs.Set( kv->GetKey(), idLocalization::GetString( kv->GetValue() ) );
}
}
}
/*
================
idEntity::Spawn
================
*/
void idEntity::Spawn()
{
int i;
const char* temp;
idVec3 origin;
idMat3 axis;
const idKeyValue* networkSync;
const char* classname;
const char* scriptObjectName;
gameLocal.RegisterEntity( this, -1, gameLocal.GetSpawnArgs() );
spawnArgs.GetString( "classname", NULL, &classname );
const idDeclEntityDef* def = gameLocal.FindEntityDef( classname, false );
if( def )
{
entityDefNumber = def->Index();
}
FixupLocalizedStrings();
// parse static models the same way the editor display does
gameEdit->ParseSpawnArgsToRenderEntity( &spawnArgs, &renderEntity );
renderEntity.entityNum = entityNumber;
noGrab = spawnArgs.GetBool( "noGrab", "0" );
xraySkin = NULL;
renderEntity.xrayIndex = 1;
idStr str;
if( spawnArgs.GetString( "skin_xray", "", str ) )
{
xraySkin = declManager->FindSkin( str.c_str() );
}
// go dormant within 100ms so that when the map starts most monsters are dormant
dormantStart = gameLocal.time - DELAY_DORMANT_TIME + 100;
origin = renderEntity.origin;
axis = renderEntity.axis;
// do the audio parsing the same way dmap and the editor do
gameEdit->ParseSpawnArgsToRefSound( &spawnArgs, &refSound );
// only play SCHANNEL_PRIVATE when sndworld->PlaceListener() is called with this listenerId
// don't spatialize sounds from the same entity
refSound.listenerId = entityNumber + 1;
cameraTarget = NULL;
temp = spawnArgs.GetString( "cameraTarget" );
if( temp != NULL && temp[0] != '\0' )
{
// update the camera taget
PostEventMS( &EV_UpdateCameraTarget, 0 );
}
for( i = 0; i < MAX_RENDERENTITY_GUI; i++ )
{
UpdateGuiParms( renderEntity.gui[ i ], &spawnArgs );
}
fl.solidForTeam = spawnArgs.GetBool( "solidForTeam", "0" );
fl.neverDormant = spawnArgs.GetBool( "neverDormant", "0" );
fl.hidden = spawnArgs.GetBool( "hide", "0" );
if( fl.hidden )
{
// make sure we're hidden, since a spawn function might not set it up right
PostEventMS( &EV_Hide, 0 );
}
cinematic = spawnArgs.GetBool( "cinematic", "0" );
networkSync = spawnArgs.FindKey( "networkSync" );
if( networkSync )
{
fl.networkSync = ( atoi( networkSync->GetValue() ) != 0 );
}
#if 0
if( !common->IsClient() )
{
// common->DPrintf( "NET: DBG %s - %s is synced: %s\n", spawnArgs.GetString( "classname", "" ), GetType()->classname, fl.networkSync ? "true" : "false" );
if( spawnArgs.GetString( "classname", "" )[ 0 ] == '\0' && !fl.networkSync )
{
common->DPrintf( "NET: WRN %s entity, no classname, and no networkSync?\n", GetType()->classname );
}
}
#endif
// every object will have a unique name
temp = spawnArgs.GetString( "name", va( "%s_%s_%d", GetClassname(), spawnArgs.GetString( "classname" ), entityNumber ) );
SetName( temp );
// if we have targets, wait until all entities are spawned to get them
if( spawnArgs.MatchPrefix( "target" ) || spawnArgs.MatchPrefix( "guiTarget" ) )
{
if( gameLocal.GameState() == GAMESTATE_STARTUP )
{
PostEventMS( &EV_FindTargets, 0 );
}
else
{
// not during spawn, so it's ok to get the targets
FindTargets();
}
}
health = spawnArgs.GetInt( "health" );
InitDefaultPhysics( origin, axis );
SetOrigin( origin );
SetAxis( axis );
temp = spawnArgs.GetString( "model" );
if( temp != NULL && *temp != '\0' )
{
SetModel( temp );
}
if( spawnArgs.GetString( "bind", "", &temp ) )
{
PostEventMS( &EV_SpawnBind, 0 );
}
// auto-start a sound on the entity
if( refSound.shader && !refSound.waitfortrigger )
{
StartSoundShader( refSound.shader, SND_CHANNEL_ANY, 0, false, NULL );
}
// setup script object
if( ShouldConstructScriptObjectAtSpawn() && spawnArgs.GetString( "scriptobject", NULL, &scriptObjectName ) )
{
if( !scriptObject.SetType( scriptObjectName ) )
{
gameLocal.Error( "Script object '%s' not found on entity '%s'.", scriptObjectName, name.c_str() );
}
ConstructScriptObject();
}
// determine time group
DetermineTimeGroup( spawnArgs.GetBool( "slowmo", "1" ) );
}
/*
================
idEntity::~idEntity
================
*/
idEntity::~idEntity()
{
DeconstructScriptObject();
scriptObject.Free();
if( thinkFlags )
{
BecomeInactive( thinkFlags );
}
activeNode.Remove();
Signal( SIG_REMOVED );
// we have to set back the default physics object before unbinding because the entity
// specific physics object might be an entity variable and as such could already be destroyed.
SetPhysics( NULL );
// remove any entities that are bound to me
RemoveBinds();
// unbind from master
Unbind();
QuitTeam();
gameLocal.RemoveEntityFromHash( name.c_str(), this );
delete renderView;
renderView = NULL;
delete signals;
signals = NULL;
FreeModelDef();
FreeSoundEmitter( false );
if( xrayEntityHandle != -1 )
{
gameRenderWorld->FreeEntityDef( xrayEntityHandle );
xrayEntityHandle = -1;
}
gameLocal.UnregisterEntity( this );
}
/*
================
idEntity::Save
================
*/
void idEntity::Save( idSaveGame* savefile ) const
{
int i, j;
savefile->WriteInt( entityNumber );
savefile->WriteInt( entityDefNumber );
// spawnNode and activeNode are restored by gameLocal
savefile->WriteDict( &spawnArgs );
savefile->WriteString( name );
scriptObject.Save( savefile );
savefile->WriteInt( thinkFlags );
savefile->WriteInt( dormantStart );
savefile->WriteBool( cinematic );
savefile->WriteObject( cameraTarget );
savefile->WriteInt( health );
savefile->WriteInt( targets.Num() );
for( i = 0; i < targets.Num(); i++ )
{
targets[ i ].Save( savefile );
}
entityFlags_s flags = fl;
LittleBitField( &flags, sizeof( flags ) );
savefile->Write( &flags, sizeof( flags ) );
savefile->WriteInt( timeGroup );
savefile->WriteBool( noGrab );
savefile->WriteRenderEntity( xrayEntity );
savefile->WriteInt( xrayEntityHandle );
savefile->WriteSkin( xraySkin );
savefile->WriteRenderEntity( renderEntity );
savefile->WriteInt( modelDefHandle );
savefile->WriteRefSound( refSound );
savefile->WriteObject( bindMaster );
savefile->WriteJoint( bindJoint );
savefile->WriteInt( bindBody );
savefile->WriteObject( teamMaster );
savefile->WriteObject( teamChain );
savefile->WriteStaticObject( defaultPhysicsObj );
savefile->WriteInt( numPVSAreas );
for( i = 0; i < MAX_PVS_AREAS; i++ )
{
savefile->WriteInt( PVSAreas[ i ] );
}
if( !signals )
{
savefile->WriteBool( false );
}
else
{
savefile->WriteBool( true );
for( i = 0; i < NUM_SIGNALS; i++ )
{
savefile->WriteInt( signals->signal[ i ].Num() );
for( j = 0; j < signals->signal[ i ].Num(); j++ )
{
savefile->WriteInt( signals->signal[ i ][ j ].threadnum );
savefile->WriteString( signals->signal[ i ][ j ].function->Name() );
}
}
}
savefile->WriteInt( mpGUIState );
}
/*
================
idEntity::Restore
================
*/
void idEntity::Restore( idRestoreGame* savefile )
{
int i, j;
int num;
idStr funcname;
savefile->ReadInt( entityNumber );
savefile->ReadInt( entityDefNumber );
// spawnNode and activeNode are restored by gameLocal
savefile->ReadDict( &spawnArgs );
savefile->ReadString( name );
SetName( name );
scriptObject.Restore( savefile );
savefile->ReadInt( thinkFlags );
savefile->ReadInt( dormantStart );
savefile->ReadBool( cinematic );
savefile->ReadObject( reinterpret_cast( cameraTarget ) );
savefile->ReadInt( health );
targets.Clear();
savefile->ReadInt( num );
targets.SetNum( num );
for( i = 0; i < num; i++ )
{
targets[ i ].Restore( savefile );
}
savefile->Read( &fl, sizeof( fl ) );
LittleBitField( &fl, sizeof( fl ) );
savefile->ReadInt( timeGroup );
savefile->ReadBool( noGrab );
savefile->ReadRenderEntity( xrayEntity );
savefile->ReadInt( xrayEntityHandle );
if( xrayEntityHandle != -1 )
{
xrayEntityHandle = gameRenderWorld->AddEntityDef( &xrayEntity );
}
savefile->ReadSkin( xraySkin );
savefile->ReadRenderEntity( renderEntity );
savefile->ReadInt( modelDefHandle );
savefile->ReadRefSound( refSound );
savefile->ReadObject( reinterpret_cast( bindMaster ) );
savefile->ReadJoint( bindJoint );
savefile->ReadInt( bindBody );
savefile->ReadObject( reinterpret_cast( teamMaster ) );
savefile->ReadObject( reinterpret_cast( teamChain ) );
savefile->ReadStaticObject( defaultPhysicsObj );
RestorePhysics( &defaultPhysicsObj );
savefile->ReadInt( numPVSAreas );
for( i = 0; i < MAX_PVS_AREAS; i++ )
{
savefile->ReadInt( PVSAreas[ i ] );
}
bool readsignals;
savefile->ReadBool( readsignals );
if( readsignals )
{
signals = new( TAG_ENTITY ) signalList_t;
for( i = 0; i < NUM_SIGNALS; i++ )
{
savefile->ReadInt( num );
signals->signal[ i ].SetNum( num );
for( j = 0; j < num; j++ )
{
savefile->ReadInt( signals->signal[ i ][ j ].threadnum );
savefile->ReadString( funcname );
signals->signal[ i ][ j ].function = gameLocal.program.FindFunction( funcname );
if( !signals->signal[ i ][ j ].function )
{
savefile->Error( "Function '%s' not found", funcname.c_str() );
}
}
}
}
savefile->ReadInt( mpGUIState );
// restore must retrieve modelDefHandle from the renderer
if( modelDefHandle != -1 )
{
modelDefHandle = gameRenderWorld->AddEntityDef( &renderEntity );
}
}
/*
================
idEntity::GetEntityDefName
================
*/
const char* idEntity::GetEntityDefName() const
{
if( entityDefNumber < 0 )
{
return "*unknown*";
}
return declManager->DeclByIndex( DECL_ENTITYDEF, entityDefNumber, false )->GetName();
}
/*
================
idEntity::SetName
================
*/
void idEntity::SetName( const char* newname )
{
if( name.Length() )
{
gameLocal.RemoveEntityFromHash( name.c_str(), this );
gameLocal.program.SetEntity( name, NULL );
}
name = newname;
if( name.Length() )
{
if( ( name == "NULL" ) || ( name == "null_entity" ) )
{
gameLocal.Error( "Cannot name entity '%s'. '%s' is reserved for script.", name.c_str(), name.c_str() );
}
gameLocal.AddEntityToHash( name.c_str(), this );
gameLocal.program.SetEntity( name, this );
}
}
/*
================
idEntity::GetName
================
*/
const char* idEntity::GetName() const
{
return name.c_str();
}
/***********************************************************************
Thinking
***********************************************************************/
/*
================
idEntity::Think
================
*/
void idEntity::Think()
{
RunPhysics();
Present();
}
/*
================
idEntity::DoDormantTests
Monsters and other expensive entities that are completely closed
off from the player can skip all of their work
================
*/
bool idEntity::DoDormantTests()
{
if( fl.neverDormant )
{
return false;
}
// if the monster area is not topologically connected to a player
if( !gameLocal.InPlayerConnectedArea( this ) )
{
if( dormantStart == 0 )
{
dormantStart = gameLocal.time;
}
if( gameLocal.time - dormantStart < DELAY_DORMANT_TIME )
{
// just got closed off, don't go dormant yet
return false;
}
return true;
}
else
{
// the monster area is topologically connected to a player, but if
// the monster hasn't been woken up before, do the more precise PVS check
if( !fl.hasAwakened )
{
if( !gameLocal.InPlayerPVS( this ) )
{
return true; // stay dormant
}
}
// wake up
dormantStart = 0;
fl.hasAwakened = true; // only go dormant when area closed off now, not just out of PVS
return false;
}
}
/*
================
idEntity::CheckDormant
Monsters and other expensive entities that are completely closed
off from the player can skip all of their work
================
*/
bool idEntity::CheckDormant()
{
bool dormant;
dormant = DoDormantTests();
if( dormant && !fl.isDormant )
{
fl.isDormant = true;
DormantBegin();
}
else if( !dormant && fl.isDormant )
{
fl.isDormant = false;
DormantEnd();
}
return dormant;
}
/*
================
idEntity::DormantBegin
called when entity becomes dormant
================
*/
void idEntity::DormantBegin()
{
}
/*
================
idEntity::DormantEnd
called when entity wakes from being dormant
================
*/
void idEntity::DormantEnd()
{
}
/*
================
idEntity::IsActive
================
*/
bool idEntity::IsActive() const
{
return activeNode.InList();
}
/*
================
idEntity::BecomeActive
================
*/
void idEntity::BecomeActive( int flags )
{
if( ( flags & TH_PHYSICS ) )
{
// enable the team master if this entity is part of a physics team
if( teamMaster && teamMaster != this )
{
teamMaster->BecomeActive( TH_PHYSICS );
}
else if( !( thinkFlags & TH_PHYSICS ) )
{
// if this is a pusher
if( physics->IsType( idPhysics_Parametric::Type ) || physics->IsType( idPhysics_Actor::Type ) )
{
gameLocal.sortPushers = true;
}
}
}
int oldFlags = thinkFlags;
thinkFlags |= flags;
if( thinkFlags )
{
if( !IsActive() )
{
activeNode.AddToEnd( gameLocal.activeEntities );
}
else if( !oldFlags )
{
// we became inactive this frame, so we have to decrease the count of entities to deactivate
gameLocal.numEntitiesToDeactivate--;
}
}
}
/*
================
idEntity::BecomeInactive
================
*/
void idEntity::BecomeInactive( int flags )
{
if( ( flags & TH_PHYSICS ) )
{
// may only disable physics on a team master if no team members are running physics or bound to a joints
if( teamMaster == this )
{
for( idEntity* ent = teamMaster->teamChain; ent; ent = ent->teamChain )
{
if( ( ent->thinkFlags & TH_PHYSICS ) || ( ( ent->bindMaster == this ) && ( ent->bindJoint != INVALID_JOINT ) ) )
{
flags &= ~TH_PHYSICS;
break;
}
}
}
}
if( thinkFlags )
{
thinkFlags &= ~flags;
if( !thinkFlags && IsActive() )
{
gameLocal.numEntitiesToDeactivate++;
}
}
if( ( flags & TH_PHYSICS ) )
{
// if this entity has a team master
if( teamMaster && teamMaster != this )
{
// if the team master is at rest
if( teamMaster->IsAtRest() )
{
teamMaster->BecomeInactive( TH_PHYSICS );
}
}
// Becoming inactive automagically turns on motion blur again
renderEntity.skipMotionBlur = false;
BecomeActive( TH_UPDATEVISUALS );
}
}
/***********************************************************************
Visuals
***********************************************************************/
/*
================
idEntity::SetShaderParm
================
*/
void idEntity::SetShaderParm( int parmnum, float value )
{
if( ( parmnum < 0 ) || ( parmnum >= MAX_ENTITY_SHADER_PARMS ) )
{
gameLocal.Warning( "shader parm index (%d) out of range", parmnum );
return;
}
renderEntity.shaderParms[ parmnum ] = value;
UpdateVisuals();
}
/*
================
idEntity::SetColor
================
*/
void idEntity::SetColor( float red, float green, float blue )
{
renderEntity.shaderParms[ SHADERPARM_RED ] = red;
renderEntity.shaderParms[ SHADERPARM_GREEN ] = green;
renderEntity.shaderParms[ SHADERPARM_BLUE ] = blue;
UpdateVisuals();
}
/*
================
idEntity::SetColor
================
*/
void idEntity::SetColor( const idVec3& color )
{
SetColor( color[ 0 ], color[ 1 ], color[ 2 ] );
UpdateVisuals();
}
/*
================
idEntity::GetColor
================
*/
void idEntity::GetColor( idVec3& out ) const
{
out[ 0 ] = renderEntity.shaderParms[ SHADERPARM_RED ];
out[ 1 ] = renderEntity.shaderParms[ SHADERPARM_GREEN ];
out[ 2 ] = renderEntity.shaderParms[ SHADERPARM_BLUE ];
}
/*
================
idEntity::SetColor
================
*/
void idEntity::SetColor( const idVec4& color )
{
renderEntity.shaderParms[ SHADERPARM_RED ] = color[ 0 ];
renderEntity.shaderParms[ SHADERPARM_GREEN ] = color[ 1 ];
renderEntity.shaderParms[ SHADERPARM_BLUE ] = color[ 2 ];
renderEntity.shaderParms[ SHADERPARM_ALPHA ] = color[ 3 ];
UpdateVisuals();
}
/*
================
idEntity::GetColor
================
*/
void idEntity::GetColor( idVec4& out ) const
{
out[ 0 ] = renderEntity.shaderParms[ SHADERPARM_RED ];
out[ 1 ] = renderEntity.shaderParms[ SHADERPARM_GREEN ];
out[ 2 ] = renderEntity.shaderParms[ SHADERPARM_BLUE ];
out[ 3 ] = renderEntity.shaderParms[ SHADERPARM_ALPHA ];
}
/*
================
idEntity::UpdateAnimationControllers
================
*/
bool idEntity::UpdateAnimationControllers()
{
// any ragdoll and IK animation controllers should be updated here
return false;
}
/*
================
idEntity::SetModel
================
*/
void idEntity::SetModel( const char* modelname )
{
assert( modelname );
FreeModelDef();
renderEntity.hModel = renderModelManager->FindModel( modelname );
if( renderEntity.hModel )
{
renderEntity.hModel->Reset();
}
renderEntity.callback = NULL;
renderEntity.numJoints = 0;
renderEntity.joints = NULL;
if( renderEntity.hModel )
{
renderEntity.bounds = renderEntity.hModel->Bounds( &renderEntity );
}
else
{
renderEntity.bounds.Zero();
}
UpdateVisuals();
}
/*
================
idEntity::SetSkin
================
*/
void idEntity::SetSkin( const idDeclSkin* skin )
{
renderEntity.customSkin = skin;
UpdateVisuals();
}
/*
================
idEntity::GetSkin
================
*/
const idDeclSkin* idEntity::GetSkin() const
{
return renderEntity.customSkin;
}
/*
================
idEntity::FreeModelDef
================
*/
void idEntity::FreeModelDef()
{
if( modelDefHandle != -1 )
{
gameRenderWorld->FreeEntityDef( modelDefHandle );
modelDefHandle = -1;
}
}
/*
================
idEntity::FreeLightDef
================
*/
void idEntity::FreeLightDef()
{
}
/*
================
idEntity::IsHidden
================
*/
bool idEntity::IsHidden() const
{
return fl.hidden;
}
/*
================
idEntity::Hide
================
*/
void idEntity::Hide()
{
if( !IsHidden() )
{
fl.hidden = true;
FreeModelDef();
UpdateVisuals();
}
}
/*
================
idEntity::Show
================
*/
void idEntity::Show()
{
if( IsHidden() )
{
fl.hidden = false;
UpdateVisuals();
}
}
/*
================
idEntity::UpdateModelTransform
================
*/
void idEntity::UpdateModelTransform()
{
idVec3 origin;
idMat3 axis;
if( GetPhysicsToVisualTransform( origin, axis ) )
{
renderEntity.axis = axis * GetPhysics()->GetAxis();
renderEntity.origin = GetPhysics()->GetOrigin() + origin * renderEntity.axis;
}
else
{
// Add the deltas here, used for projectiles in MP. These deltas should only affect the visuals.
renderEntity.axis = GetPhysics()->GetAxis() * axisDelta;
renderEntity.origin = GetPhysics()->GetOrigin() + originDelta;
}
}
/*
================
idEntity::UpdateModel
================
*/
void idEntity::UpdateModel()
{
renderEntity.timeGroup = timeGroup;
UpdateModelTransform();
// check if the entity has an MD5 model
idAnimator* animator = GetAnimator();
if( animator != NULL && animator->ModelHandle() != NULL )
{
// set the callback to update the joints
renderEntity.callback = idEntity::ModelCallback;
}
// set to invalid number to force an update the next time the PVS areas are retrieved
ClearPVSAreas();
// ensure that we call Present this frame
BecomeActive( TH_UPDATEVISUALS );
// If the entity has an xray skin, go ahead and add it
if( xraySkin != NULL )
{
xrayEntity = renderEntity;
xrayEntity.xrayIndex = 2;
xrayEntity.customSkin = xraySkin;
if( xrayEntityHandle == -1 )
{
xrayEntityHandle = gameRenderWorld->AddEntityDef( &xrayEntity );
}
else
{
gameRenderWorld->UpdateEntityDef( xrayEntityHandle, &xrayEntity );
}
}
}
/*
================
idEntity::UpdateVisuals
================
*/
void idEntity::UpdateVisuals()
{
UpdateModel();
UpdateSound();
}
/*
================
idEntity::UpdatePVSAreas
================
*/
void idEntity::UpdatePVSAreas()
{
int localNumPVSAreas, localPVSAreas[32];
idBounds modelAbsBounds;
int i;
modelAbsBounds.FromTransformedBounds( renderEntity.bounds, renderEntity.origin, renderEntity.axis );
localNumPVSAreas = gameLocal.pvs.GetPVSAreas( modelAbsBounds, localPVSAreas, sizeof( localPVSAreas ) / sizeof( localPVSAreas[0] ) );
// FIXME: some particle systems may have huge bounds and end up in many PVS areas
// the first MAX_PVS_AREAS may not be visible to a network client and as a result the particle system may not show up when it should
if( localNumPVSAreas > MAX_PVS_AREAS )
{
localNumPVSAreas = gameLocal.pvs.GetPVSAreas( idBounds( renderEntity.origin ).Expand( 64.0f ), localPVSAreas, sizeof( localPVSAreas ) / sizeof( localPVSAreas[0] ) );
}
for( numPVSAreas = 0; numPVSAreas < MAX_PVS_AREAS && numPVSAreas < localNumPVSAreas; numPVSAreas++ )
{
PVSAreas[numPVSAreas] = localPVSAreas[numPVSAreas];
}
for( i = numPVSAreas; i < MAX_PVS_AREAS; i++ )
{
PVSAreas[ i ] = 0;
}
}
/*
================
idEntity::UpdatePVSAreas
================
*/
void idEntity::UpdatePVSAreas( const idVec3& pos )
{
int i;
numPVSAreas = gameLocal.pvs.GetPVSAreas( idBounds( pos ), PVSAreas, MAX_PVS_AREAS );
i = numPVSAreas;
while( i < MAX_PVS_AREAS )
{
PVSAreas[ i++ ] = 0;
}
}
/*
================
idEntity::GetNumPVSAreas
================
*/
int idEntity::GetNumPVSAreas()
{
if( numPVSAreas < 0 )
{
UpdatePVSAreas();
}
return numPVSAreas;
}
/*
================
idEntity::GetPVSAreas
================
*/
const int* idEntity::GetPVSAreas()
{
if( numPVSAreas < 0 )
{
UpdatePVSAreas();
}
return PVSAreas;
}
/*
================
idEntity::ClearPVSAreas
================
*/
void idEntity::ClearPVSAreas()
{
numPVSAreas = -1;
}
/*
================
idEntity::PhysicsTeamInPVS
FIXME: for networking also return true if any of the entity shadows is in the PVS
================
*/
bool idEntity::PhysicsTeamInPVS( pvsHandle_t pvsHandle )
{
idEntity* part;
if( teamMaster )
{
for( part = teamMaster; part; part = part->teamChain )
{
if( gameLocal.pvs.InCurrentPVS( pvsHandle, part->GetPVSAreas(), part->GetNumPVSAreas() ) )
{
return true;
}
}
}
else
{
return gameLocal.pvs.InCurrentPVS( pvsHandle, GetPVSAreas(), GetNumPVSAreas() );
}
return false;
}
/*
==============
idEntity::BecomeReplicated
==============
*/
void idEntity::BecomeReplicated()
{
fl.skipReplication = false;
if( GetPhysics() )
{
GetPhysics()->ResetInterpolationState( GetPhysics()->GetOrigin(), GetPhysics()->GetAxis() );
}
}
/*
==============
idEntity::ProjectOverlay
==============
*/
void idEntity::ProjectOverlay( const idVec3& origin, const idVec3& dir, float size, const char* material )
{
float s, c;
idMat3 axis, axistemp;
idVec3 localOrigin, localAxis[2];
idPlane localPlane[2];
// make sure the entity has a valid model handle
if( modelDefHandle < 0 )
{
return;
}
// only do this on dynamic md5 models
if( renderEntity.hModel->IsDynamicModel() != DM_CACHED )
{
return;
}
idMath::SinCos16( gameLocal.random.RandomFloat() * idMath::TWO_PI, s, c );
axis[2] = -dir;
axis[2].NormalVectors( axistemp[0], axistemp[1] );
axis[0] = axistemp[ 0 ] * c + axistemp[ 1 ] * -s;
axis[1] = axistemp[ 0 ] * -s + axistemp[ 1 ] * -c;
renderEntity.axis.ProjectVector( origin - renderEntity.origin, localOrigin );
renderEntity.axis.ProjectVector( axis[0], localAxis[0] );
renderEntity.axis.ProjectVector( axis[1], localAxis[1] );
size = 1.0f / size;
localAxis[0] *= size;
localAxis[1] *= size;
localPlane[0] = localAxis[0];
localPlane[0][3] = -( localOrigin * localAxis[0] ) + 0.5f;
localPlane[1] = localAxis[1];
localPlane[1][3] = -( localOrigin * localAxis[1] ) + 0.5f;
const idMaterial* mtr = declManager->FindMaterial( material );
// project an overlay onto the model
gameRenderWorld->ProjectOverlay( modelDefHandle, localPlane, mtr, gameLocal.slow.time );
// make sure non-animating models update their overlay
UpdateVisuals();
}
/*
================
idEntity::Present
Present is called to allow entities to generate refEntities, lights, etc for the renderer.
================
*/
void idEntity::Present()
{
if( !gameLocal.isNewFrame )
{
return;
}
// don't present to the renderer if the entity hasn't changed
if( !( thinkFlags & TH_UPDATEVISUALS ) )
{
return;
}
BecomeInactive( TH_UPDATEVISUALS );
// camera target for remote render views
if( cameraTarget && gameLocal.InPlayerPVS( this ) )
{
renderEntity.remoteRenderView = cameraTarget->GetRenderView();
}
// if set to invisible, skip
if( !renderEntity.hModel || IsHidden() )
{
return;
}
// add to refresh list
if( modelDefHandle == -1 )
{
modelDefHandle = gameRenderWorld->AddEntityDef( &renderEntity );
}
else
{
gameRenderWorld->UpdateEntityDef( modelDefHandle, &renderEntity );
}
}
/*
================
idEntity::GetRenderEntity
================
*/
renderEntity_t* idEntity::GetRenderEntity()
{
return &renderEntity;
}
/*
================
idEntity::GetModelDefHandle
================
*/
int idEntity::GetModelDefHandle()
{
return modelDefHandle;
}
/*
================
idEntity::UpdateRenderEntity
================
*/
bool idEntity::UpdateRenderEntity( renderEntity_s* renderEntity, const renderView_t* renderView )
{
idAnimator* animator = GetAnimator();
if( animator != NULL )
{
SetTimeState ts( timeGroup );
int currentTime = gameLocal.time;
if( renderEntity != NULL )
{
currentTime = gameLocal.GetTimeGroupTime( renderEntity->timeGroup );
}
return animator->CreateFrame( currentTime, false );
}
return false;
}
/*
================
idEntity::ModelCallback
NOTE: may not change the game state whatsoever!
================
*/
bool idEntity::ModelCallback( renderEntity_s* renderEntity, const renderView_t* renderView )
{
idEntity* ent;
ent = gameLocal.entities[ renderEntity->entityNum ];
if( ent == NULL )
{
gameLocal.Error( "idEntity::ModelCallback: callback with NULL game entity" );
return false;
}
return ent->UpdateRenderEntity( renderEntity, renderView );
}
/*
================
idEntity::GetAnimator
Subclasses will be responsible for allocating animator.
================
*/
idAnimator* idEntity::GetAnimator()
{
return NULL;
}
/*
=============
idEntity::GetRenderView
This is used by remote camera views to look from an entity
=============
*/
renderView_t* idEntity::GetRenderView()
{
if( !renderView )
{
renderView = new( TAG_ENTITY ) renderView_t;
}
memset( renderView, 0, sizeof( *renderView ) );
renderView->vieworg = GetPhysics()->GetOrigin();
renderView->fov_x = 120;
renderView->fov_y = 120;
renderView->viewaxis = GetPhysics()->GetAxis();
// copy global shader parms
for( int i = 0; i < MAX_GLOBAL_SHADER_PARMS; i++ )
{
renderView->shaderParms[ i ] = gameLocal.globalShaderParms[ i ];
}
renderView->globalMaterial = gameLocal.GetGlobalMaterial();
renderView->time[0] = gameLocal.slow.time;
renderView->time[1] = gameLocal.fast.time;
return renderView;
}
/***********************************************************************
Sound
***********************************************************************/
/*
================
idEntity::CanPlayChatterSounds
Used for playing chatter sounds on monsters.
================
*/
bool idEntity::CanPlayChatterSounds() const
{
return true;
}
/*
================
idEntity::StartSound
================
*/
bool idEntity::StartSound( const char* soundName, const s_channelType channel, int soundShaderFlags, bool broadcast, int* length )
{
const idSoundShader* shader;
const char* sound;
if( length )
{
*length = 0;
}
// we should ALWAYS be playing sounds from the def.
// hardcoded sounds MUST be avoided at all times because they won't get precached.
assert( idStr::Icmpn( soundName, "snd_", 4 ) == 0 );
if( !spawnArgs.GetString( soundName, "", &sound ) )
{
return false;
}
if( sound[0] == '\0' )
{
return false;
}
if( !gameLocal.isNewFrame )
{
// don't play the sound, but don't report an error
return true;
}
shader = declManager->FindSound( sound );
return StartSoundShader( shader, channel, soundShaderFlags, broadcast, length );
}
/*
================
idEntity::StartSoundShader
================
*/
bool idEntity::StartSoundShader( const idSoundShader* shader, const s_channelType channel, int soundShaderFlags, bool broadcast, int* length )
{
float diversity;
int len;
if( length )
{
*length = 0;
}
if( !shader )
{
return false;
}
if( !gameLocal.isNewFrame )
{
return true;
}
if( common->IsServer() && broadcast )
{
idBitMsg msg;
byte msgBuf[MAX_EVENT_PARAM_SIZE];
msg.InitWrite( msgBuf, sizeof( msgBuf ) );
msg.BeginWriting();
msg.WriteLong( gameLocal.ServerRemapDecl( -1, DECL_SOUND, shader->Index() ) );
msg.WriteByte( channel );
ServerSendEvent( EVENT_STARTSOUNDSHADER, &msg, false );
}
// set a random value for diversity unless one was parsed from the entity
if( refSound.diversity < 0.0f )
{
diversity = gameLocal.random.RandomFloat();
}
else
{
diversity = refSound.diversity;
}
// if we don't have a soundEmitter allocated yet, get one now
if( !refSound.referenceSound )
{
refSound.referenceSound = gameSoundWorld->AllocSoundEmitter();
}
UpdateSound();
len = refSound.referenceSound->StartSound( shader, channel, diversity, soundShaderFlags, !timeGroup /*_D3XP*/ );
if( length )
{
*length = len;
}
// set reference to the sound for shader synced effects
renderEntity.referenceSound = refSound.referenceSound;
return true;
}
/*
================
idEntity::StopSound
================
*/
void idEntity::StopSound( const s_channelType channel, bool broadcast )
{
if( !gameLocal.isNewFrame )
{
return;
}
if( common->IsServer() && broadcast )
{
idBitMsg msg;
byte msgBuf[MAX_EVENT_PARAM_SIZE];
msg.InitWrite( msgBuf, sizeof( msgBuf ) );
msg.BeginWriting();
msg.WriteByte( channel );
ServerSendEvent( EVENT_STOPSOUNDSHADER, &msg, false );
}
if( refSound.referenceSound )
{
refSound.referenceSound->StopSound( channel );
}
}
/*
================
idEntity::SetSoundVolume
Must be called before starting a new sound.
================
*/
void idEntity::SetSoundVolume( float volume )
{
refSound.parms.volume = volume;
}
/*
================
idEntity::UpdateSound
================
*/
void idEntity::UpdateSound()
{
if( refSound.referenceSound )
{
idVec3 origin;
idMat3 axis;
if( GetPhysicsToSoundTransform( origin, axis ) )
{
refSound.origin = GetPhysics()->GetOrigin() + origin * axis;
}
else
{
refSound.origin = GetPhysics()->GetOrigin();
}
refSound.referenceSound->UpdateEmitter( refSound.origin, refSound.listenerId, &refSound.parms );
}
}
/*
================
idEntity::GetListenerId
================
*/
int idEntity::GetListenerId() const
{
return refSound.listenerId;
}
/*
================
idEntity::GetSoundEmitter
================
*/
idSoundEmitter* idEntity::GetSoundEmitter() const
{
return refSound.referenceSound;
}
/*
================
idEntity::FreeSoundEmitter
================
*/
void idEntity::FreeSoundEmitter( bool immediate )
{
if( refSound.referenceSound )
{
refSound.referenceSound->Free( immediate );
refSound.referenceSound = NULL;
}
}
/***********************************************************************
entity binding
***********************************************************************/
/*
================
idEntity::PreBind
================
*/
void idEntity::PreBind()
{
}
/*
================
idEntity::PostBind
================
*/
void idEntity::PostBind()
{
}
/*
================
idEntity::PreUnbind
================
*/
void idEntity::PreUnbind()
{
}
/*
================
idEntity::PostUnbind
================
*/
void idEntity::PostUnbind()
{
}
/*
================
idEntity::InitBind
================
*/
bool idEntity::InitBind( idEntity* master )
{
if( master == this )
{
gameLocal.Error( "Tried to bind an object to itself." );
return false;
}
if( this == gameLocal.world )
{
gameLocal.Error( "Tried to bind world to another entity" );
return false;
}
// unbind myself from my master
Unbind();
// add any bind constraints to an articulated figure
if( master && IsType( idAFEntity_Base::Type ) )
{
static_cast( this )->AddBindConstraints();
}
if( !master || master == gameLocal.world )
{
// this can happen in scripts, so safely exit out.
return false;
}
return true;
}
/*
================
idEntity::FinishBind
================
*/
void idEntity::FinishBind()
{
// set the master on the physics object
physics->SetMaster( bindMaster, fl.bindOrientated );
// We are now separated from our previous team and are either
// an individual, or have a team of our own. Now we can join
// the new bindMaster's team. Bindmaster must be set before
// joining the team, or we will be placed in the wrong position
// on the team.
JoinTeam( bindMaster );
// if our bindMaster is enabled during a cinematic, we must be, too
cinematic = bindMaster->cinematic;
// make sure the team master is active so that physics get run
teamMaster->BecomeActive( TH_PHYSICS );
}
/*
================
idEntity::Bind
bind relative to the visual position of the master
================
*/
void idEntity::Bind( idEntity* master, bool orientated )
{
if( !InitBind( master ) )
{
return;
}
PreBind();
bindJoint = INVALID_JOINT;
bindBody = -1;
bindMaster = master;
fl.bindOrientated = orientated;
FinishBind();
PostBind( );
}
/*
================
idEntity::BindToJoint
bind relative to a joint of the md5 model used by the master
================
*/
void idEntity::BindToJoint( idEntity* master, const char* jointname, bool orientated )
{
jointHandle_t jointnum;
idAnimator* masterAnimator;
if( !InitBind( master ) )
{
return;
}
masterAnimator = master->GetAnimator();
if( !masterAnimator )
{
gameLocal.Warning( "idEntity::BindToJoint: entity '%s' cannot support skeletal models.", master->GetName() );
return;
}
jointnum = masterAnimator->GetJointHandle( jointname );
if( jointnum == INVALID_JOINT )
{
gameLocal.Warning( "idEntity::BindToJoint: joint '%s' not found on entity '%s'.", jointname, master->GetName() );
}
PreBind();
bindJoint = jointnum;
bindBody = -1;
bindMaster = master;
fl.bindOrientated = orientated;
FinishBind();
PostBind();
}
/*
================
idEntity::BindToJoint
bind relative to a joint of the md5 model used by the master
================
*/
void idEntity::BindToJoint( idEntity* master, jointHandle_t jointnum, bool orientated )
{
if( !InitBind( master ) )
{
return;
}
PreBind();
bindJoint = jointnum;
bindBody = -1;
bindMaster = master;
fl.bindOrientated = orientated;
FinishBind();
PostBind();
}
/*
================
idEntity::BindToBody
bind relative to a collision model used by the physics of the master
================
*/
void idEntity::BindToBody( idEntity* master, int bodyId, bool orientated )
{
if( !InitBind( master ) )
{
return;
}
if( bodyId < 0 )
{
gameLocal.Warning( "idEntity::BindToBody: body '%d' not found.", bodyId );
}
PreBind();
bindJoint = INVALID_JOINT;
bindBody = bodyId;
bindMaster = master;
fl.bindOrientated = orientated;
FinishBind();
PostBind();
}
/*
================
idEntity::Unbind
================
*/
void idEntity::Unbind()
{
idEntity* prev;
idEntity* next;
idEntity* last;
idEntity* ent;
// remove any bind constraints from an articulated figure
if( IsType( idAFEntity_Base::Type ) )
{
static_cast( this )->RemoveBindConstraints();
}
if( !bindMaster )
{
return;
}
if( !teamMaster )
{
// Teammaster already has been freed
bindMaster = NULL;
return;
}
PreUnbind();
if( physics )
{
physics->SetMaster( NULL, fl.bindOrientated );
}
// We're still part of a team, so that means I have to extricate myself
// and any entities that are bound to me from the old team.
// Find the node previous to me in the team
prev = teamMaster;
for( ent = teamMaster->teamChain; ent && ( ent != this ); ent = ent->teamChain )
{
prev = ent;
}
assert( ent == this ); // If ent is not pointing to this, then something is very wrong.
// Find the last node in my team that is bound to me.
// Also find the first node not bound to me, if one exists.
last = this;
for( next = teamChain; next != NULL; next = next->teamChain )
{
if( !next->IsBoundTo( this ) )
{
break;
}
// Tell them I'm now the teamMaster
next->teamMaster = this;
last = next;
}
// disconnect the last member of our team from the old team
last->teamChain = NULL;
// connect up the previous member of the old team to the node that
// follow the last node bound to me (if one exists).
if( teamMaster != this )
{
prev->teamChain = next;
if( !next && ( teamMaster == prev ) )
{
prev->teamMaster = NULL;
}
}
else if( next )
{
// If we were the teamMaster, then the nodes that were not bound to me are now
// a disconnected chain. Make them into their own team.
for( ent = next; ent->teamChain != NULL; ent = ent->teamChain )
{
ent->teamMaster = next;
}
next->teamMaster = next;
}
// If we don't have anyone on our team, then clear the team variables.
if( teamChain )
{
// make myself my own team
teamMaster = this;
}
else
{
// no longer a team
teamMaster = NULL;
}
bindJoint = INVALID_JOINT;
bindBody = -1;
bindMaster = NULL;
PostUnbind();
}
/*
================
idEntity::RemoveBinds
================
*/
void idEntity::RemoveBinds()
{
idEntity* ent;
idEntity* next;
for( ent = teamChain; ent != NULL; ent = next )
{
next = ent->teamChain;
if( ent->bindMaster == this )
{
ent->Unbind();
ent->PostEventMS( &EV_Remove, 0 );
next = teamChain;
}
}
}
/*
================
idEntity::IsBound
================
*/
bool idEntity::IsBound() const
{
if( bindMaster )
{
return true;
}
return false;
}
/*
================
idEntity::IsBoundTo
================
*/
bool idEntity::IsBoundTo( idEntity* master ) const
{
idEntity* ent;
if( !bindMaster )
{
return false;
}
for( ent = bindMaster; ent != NULL; ent = ent->bindMaster )
{
if( ent == master )
{
return true;
}
}
return false;
}
/*
================
idEntity::GetBindMaster
================
*/
idEntity* idEntity::GetBindMaster() const
{
return bindMaster;
}
/*
================
idEntity::GetBindJoint
================
*/
jointHandle_t idEntity::GetBindJoint() const
{
return bindJoint;
}
/*
================
idEntity::GetBindBody
================
*/
int idEntity::GetBindBody() const
{
return bindBody;
}
/*
================
idEntity::GetTeamMaster
================
*/
idEntity* idEntity::GetTeamMaster() const
{
return teamMaster;
}
/*
================
idEntity::GetNextTeamEntity
================
*/
idEntity* idEntity::GetNextTeamEntity() const
{
return teamChain;
}
/*
=====================
idEntity::ConvertLocalToWorldTransform
=====================
*/
void idEntity::ConvertLocalToWorldTransform( idVec3& offset, idMat3& axis )
{
UpdateModelTransform();
offset = renderEntity.origin + offset * renderEntity.axis;
axis *= renderEntity.axis;
}
/*
================
idEntity::GetLocalVector
Takes a vector in worldspace and transforms it into the parent
object's localspace.
Note: Does not take origin into acount. Use getLocalCoordinate to
convert coordinates.
================
*/
idVec3 idEntity::GetLocalVector( const idVec3& vec ) const
{
idVec3 pos;
if( !bindMaster )
{
return vec;
}
idVec3 masterOrigin;
idMat3 masterAxis;
GetMasterPosition( masterOrigin, masterAxis );
masterAxis.ProjectVector( vec, pos );
return pos;
}
/*
================
idEntity::GetLocalCoordinates
Takes a vector in world coordinates and transforms it into the parent
object's local coordinates.
================
*/
idVec3 idEntity::GetLocalCoordinates( const idVec3& vec ) const
{
idVec3 pos;
if( !bindMaster )
{
return vec;
}
idVec3 masterOrigin;
idMat3 masterAxis;
GetMasterPosition( masterOrigin, masterAxis );
masterAxis.ProjectVector( vec - masterOrigin, pos );
return pos;
}
/*
================
idEntity::GetWorldVector
Takes a vector in the parent object's local coordinates and transforms
it into world coordinates.
Note: Does not take origin into acount. Use getWorldCoordinate to
convert coordinates.
================
*/
idVec3 idEntity::GetWorldVector( const idVec3& vec ) const
{
idVec3 pos;
if( !bindMaster )
{
return vec;
}
idVec3 masterOrigin;
idMat3 masterAxis;
GetMasterPosition( masterOrigin, masterAxis );
masterAxis.UnprojectVector( vec, pos );
return pos;
}
/*
================
idEntity::GetWorldCoordinates
Takes a vector in the parent object's local coordinates and transforms
it into world coordinates.
================
*/
idVec3 idEntity::GetWorldCoordinates( const idVec3& vec ) const
{
idVec3 pos;
if( !bindMaster )
{
return vec;
}
idVec3 masterOrigin;
idMat3 masterAxis;
GetMasterPosition( masterOrigin, masterAxis );
masterAxis.UnprojectVector( vec, pos );
pos += masterOrigin;
return pos;
}
/*
================
idEntity::GetMasterPosition
================
*/
bool idEntity::GetMasterPosition( idVec3& masterOrigin, idMat3& masterAxis ) const
{
idVec3 localOrigin;
idMat3 localAxis;
idAnimator* masterAnimator;
if( bindMaster )
{
// if bound to a joint of an animated model
if( bindJoint != INVALID_JOINT )
{
masterAnimator = bindMaster->GetAnimator();
if( !masterAnimator )
{
masterOrigin = vec3_origin;
masterAxis = mat3_identity;
return false;
}
else
{
masterAnimator->GetJointTransform( bindJoint, gameLocal.time, masterOrigin, masterAxis );
masterAxis *= bindMaster->renderEntity.axis;
masterOrigin = bindMaster->renderEntity.origin + masterOrigin * bindMaster->renderEntity.axis;
}
}
else if( bindBody >= 0 && bindMaster->GetPhysics() )
{
masterOrigin = bindMaster->GetPhysics()->GetOrigin( bindBody );
masterAxis = bindMaster->GetPhysics()->GetAxis( bindBody );
}
else
{
masterOrigin = bindMaster->renderEntity.origin;
masterAxis = bindMaster->renderEntity.axis;
}
return true;
}
else
{
masterOrigin = vec3_origin;
masterAxis = mat3_identity;
return false;
}
}
/*
================
idEntity::GetWorldVelocities
================
*/
void idEntity::GetWorldVelocities( idVec3& linearVelocity, idVec3& angularVelocity ) const
{
linearVelocity = physics->GetLinearVelocity();
angularVelocity = physics->GetAngularVelocity();
if( bindMaster )
{
idVec3 masterOrigin, masterLinearVelocity, masterAngularVelocity;
idMat3 masterAxis;
// get position of master
GetMasterPosition( masterOrigin, masterAxis );
// get master velocities
bindMaster->GetWorldVelocities( masterLinearVelocity, masterAngularVelocity );
// linear velocity relative to master plus master linear and angular velocity
linearVelocity = linearVelocity * masterAxis + masterLinearVelocity +
masterAngularVelocity.Cross( GetPhysics()->GetOrigin() - masterOrigin );
}
}
/*
================
idEntity::JoinTeam
================
*/
void idEntity::JoinTeam( idEntity* teammember )
{
idEntity* ent;
idEntity* master;
idEntity* prev;
idEntity* next;
// if we're already on a team, quit it so we can join this one
if( teamMaster && ( teamMaster != this ) )
{
QuitTeam();
}
assert( teammember );
if( teammember == this )
{
teamMaster = this;
return;
}
// check if our new team mate is already on a team
master = teammember->teamMaster;
if( !master )
{
// he's not on a team, so he's the new teamMaster
master = teammember;
teammember->teamMaster = teammember;
teammember->teamChain = this;
// make anyone who's bound to me part of the new team
for( ent = teamChain; ent != NULL; ent = ent->teamChain )
{
ent->teamMaster = master;
}
}
else
{
// skip past the chain members bound to the entity we're teaming up with
prev = teammember;
next = teammember->teamChain;
if( bindMaster )
{
// if we have a bindMaster, join after any entities bound to the entity
// we're joining
while( next && next->IsBoundTo( teammember ) )
{
prev = next;
next = next->teamChain;
}
}
else
{
// if we're not bound to someone, then put us at the end of the team
while( next )
{
prev = next;
next = next->teamChain;
}
}
// make anyone who's bound to me part of the new team and
// also find the last member of my team
for( ent = this; ent->teamChain != NULL; ent = ent->teamChain )
{
ent->teamChain->teamMaster = master;
}
prev->teamChain = this;
ent->teamChain = next;
}
teamMaster = master;
// reorder the active entity list
gameLocal.sortTeamMasters = true;
}
/*
================
idEntity::QuitTeam
================
*/
void idEntity::QuitTeam()
{
idEntity* ent;
if( !teamMaster )
{
return;
}
// check if I'm the teamMaster
if( teamMaster == this )
{
// do we have more than one teammate?
if( !teamChain->teamChain )
{
// no, break up the team
teamChain->teamMaster = NULL;
}
else
{
// yes, so make the first teammate the teamMaster
for( ent = teamChain; ent; ent = ent->teamChain )
{
ent->teamMaster = teamChain;
}
}
}
else
{
assert( teamMaster );
assert( teamMaster->teamChain );
// find the previous member of the teamChain
ent = teamMaster;
while( ent->teamChain != this )
{
assert( ent->teamChain ); // this should never happen
ent = ent->teamChain;
}
// remove this from the teamChain
ent->teamChain = teamChain;
// if no one is left on the team, break it up
if( !teamMaster->teamChain )
{
teamMaster->teamMaster = NULL;
}
}
teamMaster = NULL;
teamChain = NULL;
}
/***********************************************************************
Physics.
***********************************************************************/
/*
================
idEntity::InitDefaultPhysics
================
*/
void idEntity::InitDefaultPhysics( const idVec3& origin, const idMat3& axis )
{
const char* temp;
idClipModel* clipModel = NULL;
// check if a clipmodel key/value pair is set
if( spawnArgs.GetString( "clipmodel", "", &temp ) )
{
if( idClipModel::CheckModel( temp ) )
{
clipModel = new( TAG_PHYSICS_CLIP_ENTITY ) idClipModel( temp );
}
}
if( !spawnArgs.GetBool( "noclipmodel", "0" ) )
{
// check if mins/maxs or size key/value pairs are set
if( !clipModel )
{
idVec3 size;
idBounds bounds;
bool setClipModel = false;
if( spawnArgs.GetVector( "mins", NULL, bounds[0] ) &&
spawnArgs.GetVector( "maxs", NULL, bounds[1] ) )
{
setClipModel = true;
if( bounds[0][0] > bounds[1][0] || bounds[0][1] > bounds[1][1] || bounds[0][2] > bounds[1][2] )
{
gameLocal.Error( "Invalid bounds '%s'-'%s' on entity '%s'", bounds[0].ToString(), bounds[1].ToString(), name.c_str() );
}
}
else if( spawnArgs.GetVector( "size", NULL, size ) )
{
if( ( size.x < 0.0f ) || ( size.y < 0.0f ) || ( size.z < 0.0f ) )
{
gameLocal.Error( "Invalid size '%s' on entity '%s'", size.ToString(), name.c_str() );
}
bounds[0].Set( size.x * -0.5f, size.y * -0.5f, 0.0f );
bounds[1].Set( size.x * 0.5f, size.y * 0.5f, size.z );
setClipModel = true;
}
if( setClipModel )
{
int numSides;
idTraceModel trm;
if( spawnArgs.GetInt( "cylinder", "0", numSides ) && numSides > 0 )
{
trm.SetupCylinder( bounds, numSides < 3 ? 3 : numSides );
}
else if( spawnArgs.GetInt( "cone", "0", numSides ) && numSides > 0 )
{
trm.SetupCone( bounds, numSides < 3 ? 3 : numSides );
}
else
{
trm.SetupBox( bounds );
}
clipModel = new( TAG_PHYSICS_CLIP_ENTITY ) idClipModel( trm );
}
}
// check if the visual model can be used as collision model
if( !clipModel )
{
temp = spawnArgs.GetString( "model" );
if( ( temp != NULL ) && ( *temp != 0 ) )
{
if( idClipModel::CheckModel( temp ) )
{
clipModel = new( TAG_PHYSICS_CLIP_ENTITY ) idClipModel( temp );
}
}
}
}
defaultPhysicsObj.SetSelf( this );
defaultPhysicsObj.SetClipModel( clipModel, 1.0f );
defaultPhysicsObj.SetOrigin( origin );
defaultPhysicsObj.SetAxis( axis );
physics = &defaultPhysicsObj;
}
/*
================
idEntity::SetPhysics
================
*/
void idEntity::SetPhysics( idPhysics* phys )
{
// clear any contacts the current physics object has
if( physics )
{
physics->ClearContacts();
}
// set new physics object or set the default physics if NULL
if( phys != NULL )
{
defaultPhysicsObj.SetClipModel( NULL, 1.0f );
physics = phys;
physics->Activate();
}
else
{
physics = &defaultPhysicsObj;
}
physics->UpdateTime( gameLocal.time );
physics->SetMaster( bindMaster, fl.bindOrientated );
}
/*
================
idEntity::RestorePhysics
================
*/
void idEntity::RestorePhysics( idPhysics* phys )
{
assert( phys != NULL );
// restore physics pointer
physics = phys;
}
/*
================
idEntity::GetPhysics
================
*/
idPhysics* idEntity::GetPhysics() const
{
return physics;
}
/*
================
idEntity::RunPhysics
================
*/
bool idEntity::RunPhysics()
{
int i, reachedTime;
idEntity* part = NULL, *blockedPart = NULL, *blockingEntity = NULL;
trace_t results;
bool moved;
// don't run physics if not enabled
if( !( thinkFlags & TH_PHYSICS ) )
{
// however do update any animation controllers
if( UpdateAnimationControllers() )
{
BecomeActive( TH_ANIMATE );
}
return false;
}
// if this entity is a team slave don't do anything because the team master will handle everything
if( teamMaster && teamMaster != this )
{
return false;
}
const int startTime = gameLocal.previousTime;
const int endTime = gameLocal.time;
gameLocal.push.InitSavingPushedEntityPositions();
blockedPart = NULL;
// save the physics state of the whole team and disable the team for collision detection
for( part = this; part != NULL; part = part->teamChain )
{
if( part->physics )
{
if( !part->fl.solidForTeam )
{
part->physics->DisableClip();
}
part->physics->SaveState();
}
}
// move the whole team
for( part = this; part != NULL; part = part->teamChain )
{
if( part->physics )
{
// run physics
moved = part->physics->Evaluate( GetPhysicsTimeStep(), endTime );
// check if the object is blocked
blockingEntity = part->physics->GetBlockingEntity();
if( blockingEntity )
{
blockedPart = part;
break;
}
// if moved or forced to update the visual position and orientation from the physics
if( moved || part->fl.forcePhysicsUpdate )
{
part->UpdateFromPhysics( false );
}
// update any animation controllers here so an entity bound
// to a joint of this entity gets the correct position
if( part->UpdateAnimationControllers() )
{
part->BecomeActive( TH_ANIMATE );
}
}
}
// enable the whole team for collision detection
for( part = this; part != NULL; part = part->teamChain )
{
if( part->physics )
{
if( !part->fl.solidForTeam )
{
part->physics->EnableClip();
}
}
}
// if one of the team entities is a pusher and blocked
if( blockedPart )
{
// move the parts back to the previous position
for( part = this; part != blockedPart; part = part->teamChain )
{
if( part->physics )
{
// restore the physics state
part->physics->RestoreState();
// move back the visual position and orientation
part->UpdateFromPhysics( true );
}
}
for( part = this; part != NULL; part = part->teamChain )
{
if( part->physics )
{
// update the physics time without moving
part->physics->UpdateTime( endTime );
}
}
// restore the positions of any pushed entities
gameLocal.push.RestorePushedEntityPositions();
if( common->IsClient() )
{
return false;
}
// if the master pusher has a "blocked" function, call it
Signal( SIG_BLOCKED );
ProcessEvent( &EV_TeamBlocked, blockedPart, blockingEntity );
// call the blocked function on the blocked part
blockedPart->ProcessEvent( &EV_PartBlocked, blockingEntity );
return false;
}
// This is to hack around an issue when reloading a game saved on certain movers would
// eject the player randomly through the world due to the first couple of frames imparting
// large pushVelocities.
const bool useAbnormalVelocityHack = ( idStr::Cmp( name, "houndola" ) == 0 );
// Disable motion blur if this object pushes the local player
renderEntity.skipMotionBlur = false;
// set pushed
for( i = 0; i < gameLocal.push.GetNumPushedEntities(); i++ )
{
idEntity* ent = gameLocal.push.GetPushedEntity( i );
if( ent->physics->IsType( idPhysics_Player::Type ) )
{
if( gameLocal.GetLocalClientNum() == ent->entityNumber )
{
renderEntity.skipMotionBlur = true;
}
if( useAbnormalVelocityHack )
{
idPhysics_Player* physics = static_cast< idPhysics_Player* >( ent->physics );
physics->SetPushedWithAbnormalVelocityHack( GetPhysicsTimeStep() );
}
else
{
ent->physics->SetPushed( endTime - startTime );
}
}
else
{
ent->physics->SetPushed( endTime - startTime );
}
}
// Propogate skipMotionBlur to all team members
for( part = this; part != NULL; part = part->teamChain )
{
part->renderEntity.skipMotionBlur = renderEntity.skipMotionBlur;
}
if( common->IsClient() )
{
return true;
}
// post reached event if the current time is at or past the end point of the motion
for( part = this; part != NULL; part = part->teamChain )
{
if( part->physics )
{
reachedTime = part->physics->GetLinearEndTime();
if( startTime < reachedTime && endTime >= reachedTime )
{
part->ProcessEvent( &EV_ReachedPos );
}
reachedTime = part->physics->GetAngularEndTime();
if( startTime < reachedTime && endTime >= reachedTime )
{
part->ProcessEvent( &EV_ReachedAng );
}
}
}
return true;
}
/*
================
idEntity::InterpolatePhysics
================
*/
void idEntity::InterpolatePhysics( const float fraction )
{
int i, startTime, endTime;
idEntity* part = NULL, *blockedPart = NULL, *blockingEntity = NULL;
trace_t results;
bool moved;
// don't run physics if not enabled
if( !( thinkFlags & TH_PHYSICS ) )
{
// however do update any animation controllers
if( UpdateAnimationControllers() )
{
BecomeActive( TH_ANIMATE );
}
return;
}
// if this entity is a team slave, we still need to interpolate it's current position from the snapshot.
// The team master probably depends on the current physics state, and may be unaware of prev/next or interpolation.
if( teamMaster && teamMaster != this )
{
if( physics != NULL && useClientInterpolation )
{
if( physics->Interpolate( fraction ) )
{
UpdateFromPhysics( false );
}
}
return;
}
startTime = gameLocal.previousTime;
endTime = gameLocal.time;
gameLocal.push.InitSavingPushedEntityPositions();
blockedPart = NULL;
// save the physics state of the whole team and disable the team for collision detection
for( part = this; part != NULL; part = part->teamChain )
{
if( part->physics )
{
if( !part->fl.solidForTeam )
{
part->physics->DisableClip();
}
part->physics->SaveState();
}
}
// move the whole team
for( part = this; part != NULL; part = part->teamChain )
{
if( part->physics )
{
// run physics
moved = part->physics->Evaluate( GetPhysicsTimeStep(), endTime );
// check if the object is blocked
blockingEntity = part->physics->GetBlockingEntity();
if( blockingEntity )
{
blockedPart = part;
break;
}
// if moved or forced to update the visual position and orientation from the physics
if( moved || part->fl.forcePhysicsUpdate )
{
part->UpdateFromPhysics( false );
}
// update any animation controllers here so an entity bound
// to a joint of this entity gets the correct position
if( part->UpdateAnimationControllers() )
{
part->BecomeActive( TH_ANIMATE );
}
}
}
// enable the whole team for collision detection
for( part = this; part != NULL; part = part->teamChain )
{
if( part->physics )
{
if( !part->fl.solidForTeam )
{
part->physics->EnableClip();
}
}
}
// if one of the team entities is a pusher and blocked
if( blockedPart )
{
// move the parts back to the previous position
for( part = this; part != blockedPart; part = part->teamChain )
{
if( part->physics )
{
// restore the physics state
part->physics->RestoreState();
// move back the visual position and orientation
part->UpdateFromPhysics( true );
}
}
for( part = this; part != NULL; part = part->teamChain )
{
if( part->physics )
{
// update the physics time without moving
part->physics->UpdateTime( endTime );
}
}
// restore the positions of any pushed entities
gameLocal.push.RestorePushedEntityPositions();
}
// set pushed
for( i = 0; i < gameLocal.push.GetNumPushedEntities(); i++ )
{
idEntity* ent = gameLocal.push.GetPushedEntity( i );
ent->physics->SetPushed( GetPhysicsTimeStep() );
}
if( physics && useClientInterpolation )
{
if( physics->Interpolate( fraction ) )
{
UpdateFromPhysics( false );
}
}
}
/*
================
idEntity::InterpolatePhysicsOnly
================
*/
void idEntity::InterpolatePhysicsOnly( const float fraction, bool updateTeam )
{
if( physics && useClientInterpolation )
{
if( physics->Interpolate( fraction ) )
{
UpdateFromPhysics( false );
}
}
if( updateTeam )
{
int endTime = gameLocal.time;
// move the whole team
for( idEntity* part = this; part != NULL; part = part->teamChain )
{
if( part->physics && part != this )
{
// run physics
bool moved = part->physics->Evaluate( GetPhysicsTimeStep(), endTime );
// if moved or forced to update the visual position and orientation from the physics
if( moved || part->fl.forcePhysicsUpdate )
{
part->UpdateFromPhysics( false );
}
// update any animation controllers here so an entity bound
// to a joint of this entity gets the correct position
if( part->UpdateAnimationControllers() )
{
part->BecomeActive( TH_ANIMATE );
}
}
}
}
}
/*
================
idEntity::UpdateFromPhysics
================
*/
void idEntity::UpdateFromPhysics( bool moveBack )
{
if( IsType( idActor::Type ) )
{
idActor* actor = static_cast( this );
// set master delta angles for actors
if( GetBindMaster() )
{
idAngles delta = actor->GetDeltaViewAngles();
if( moveBack )
{
delta.yaw -= static_cast( physics )->GetMasterDeltaYaw();
}
else
{
delta.yaw += static_cast( physics )->GetMasterDeltaYaw();
}
actor->SetDeltaViewAngles( delta );
}
}
UpdateVisuals();
}
/*
================
idEntity::GetPhysicsTimeStep
================
*/
int idEntity::GetPhysicsTimeStep() const
{
return gameLocal.time - gameLocal.previousTime;
}
/*
================
idEntity::SetOrigin
================
*/
void idEntity::SetOrigin( const idVec3& org )
{
GetPhysics()->SetOrigin( org );
UpdateVisuals();
}
/*
================
idEntity::SetAxis
================
*/
void idEntity::SetAxis( const idMat3& axis )
{
if( GetPhysics()->IsType( idPhysics_Actor::Type ) )
{
static_cast( this )->viewAxis = axis;
}
else
{
GetPhysics()->SetAxis( axis );
}
UpdateVisuals();
}
/*
================
idEntity::SetAngles
================
*/
void idEntity::SetAngles( const idAngles& ang )
{
SetAxis( ang.ToMat3() );
}
/*
================
idEntity::GetFloorPos
================
*/
bool idEntity::GetFloorPos( float max_dist, idVec3& floorpos ) const
{
trace_t result;
if( !GetPhysics()->HasGroundContacts() )
{
GetPhysics()->ClipTranslation( result, GetPhysics()->GetGravityNormal() * max_dist, NULL );
if( result.fraction < 1.0f )
{
floorpos = result.endpos;
return true;
}
else
{
floorpos = GetPhysics()->GetOrigin();
return false;
}
}
else
{
floorpos = GetPhysics()->GetOrigin();
return true;
}
}
/*
================
idEntity::GetPhysicsToVisualTransform
================
*/
bool idEntity::GetPhysicsToVisualTransform( idVec3& origin, idMat3& axis )
{
return false;
}
/*
================
idEntity::GetPhysicsToSoundTransform
================
*/
bool idEntity::GetPhysicsToSoundTransform( idVec3& origin, idMat3& axis )
{
// by default play the sound at the center of the bounding box of the first clip model
if( GetPhysics()->GetNumClipModels() > 0 )
{
origin = GetPhysics()->GetBounds().GetCenter();
axis.Identity();
return true;
}
return false;
}
/*
================
idEntity::Collide
================
*/
bool idEntity::Collide( const trace_t& collision, const idVec3& velocity )
{
// this entity collides with collision.c.entityNum
return false;
}
/*
================
idEntity::GetImpactInfo
================
*/
void idEntity::GetImpactInfo( idEntity* ent, int id, const idVec3& point, impactInfo_t* info )
{
GetPhysics()->GetImpactInfo( id, point, info );
}
/*
================
idEntity::ApplyImpulse
================
*/
void idEntity::ApplyImpulse( idEntity* ent, int id, const idVec3& point, const idVec3& impulse )
{
GetPhysics()->ApplyImpulse( id, point, impulse );
}
/*
================
idEntity::AddForce
================
*/
void idEntity::AddForce( idEntity* ent, int id, const idVec3& point, const idVec3& force )
{
GetPhysics()->AddForce( id, point, force );
}
/*
================
idEntity::ActivatePhysics
================
*/
void idEntity::ActivatePhysics( idEntity* ent )
{
GetPhysics()->Activate();
}
/*
================
idEntity::IsAtRest
================
*/
bool idEntity::IsAtRest() const
{
return GetPhysics()->IsAtRest();
}
/*
================
idEntity::GetRestStartTime
================
*/
int idEntity::GetRestStartTime() const
{
return GetPhysics()->GetRestStartTime();
}
/*
================
idEntity::AddContactEntity
================
*/
void idEntity::AddContactEntity( idEntity* ent )
{
GetPhysics()->AddContactEntity( ent );
}
/*
================
idEntity::RemoveContactEntity
================
*/
void idEntity::RemoveContactEntity( idEntity* ent )
{
GetPhysics()->RemoveContactEntity( ent );
}
/***********************************************************************
Damage
***********************************************************************/
/*
============
idEntity::CanDamage
Returns true if the inflictor can directly damage the target. Used for
explosions and melee attacks.
============
*/
bool idEntity::CanDamage( const idVec3& origin, idVec3& damagePoint ) const
{
idVec3 dest;
trace_t tr;
idVec3 midpoint;
// use the midpoint of the bounds instead of the origin, because
// bmodels may have their origin at 0,0,0
midpoint = ( GetPhysics()->GetAbsBounds()[0] + GetPhysics()->GetAbsBounds()[1] ) * 0.5;
dest = midpoint;
gameLocal.clip.TracePoint( tr, origin, dest, MASK_SOLID, NULL );
if( tr.fraction == 1.0 || ( gameLocal.GetTraceEntity( tr ) == this ) )
{
damagePoint = tr.endpos;
return true;
}
// this should probably check in the plane of projection, rather than in world coordinate
dest = midpoint;
dest[0] += 15.0;
dest[1] += 15.0;
gameLocal.clip.TracePoint( tr, origin, dest, MASK_SOLID, NULL );
if( tr.fraction == 1.0 || ( gameLocal.GetTraceEntity( tr ) == this ) )
{
damagePoint = tr.endpos;
return true;
}
dest = midpoint;
dest[0] += 15.0;
dest[1] -= 15.0;
gameLocal.clip.TracePoint( tr, origin, dest, MASK_SOLID, NULL );
if( tr.fraction == 1.0 || ( gameLocal.GetTraceEntity( tr ) == this ) )
{
damagePoint = tr.endpos;
return true;
}
dest = midpoint;
dest[0] -= 15.0;
dest[1] += 15.0;
gameLocal.clip.TracePoint( tr, origin, dest, MASK_SOLID, NULL );
if( tr.fraction == 1.0 || ( gameLocal.GetTraceEntity( tr ) == this ) )
{
damagePoint = tr.endpos;
return true;
}
dest = midpoint;
dest[0] -= 15.0;
dest[1] -= 15.0;
gameLocal.clip.TracePoint( tr, origin, dest, MASK_SOLID, NULL );
if( tr.fraction == 1.0 || ( gameLocal.GetTraceEntity( tr ) == this ) )
{
damagePoint = tr.endpos;
return true;
}
dest = midpoint;
dest[2] += 15.0;
gameLocal.clip.TracePoint( tr, origin, dest, MASK_SOLID, NULL );
if( tr.fraction == 1.0 || ( gameLocal.GetTraceEntity( tr ) == this ) )
{
damagePoint = tr.endpos;
return true;
}
dest = midpoint;
dest[2] -= 15.0;
gameLocal.clip.TracePoint( tr, origin, dest, MASK_SOLID, NULL );
if( tr.fraction == 1.0 || ( gameLocal.GetTraceEntity( tr ) == this ) )
{
damagePoint = tr.endpos;
return true;
}
return false;
}
/*
================
idEntity::DamageFeedback
callback function for when another entity received damage from this entity. damage can be adjusted and returned to the caller.
================
*/
void idEntity::DamageFeedback( idEntity* victim, idEntity* inflictor, int& damage )
{
// implemented in subclasses
}
/*
============
Damage
this entity that is being damaged
inflictor entity that is causing the damage
attacker entity that caused the inflictor to damage targ
example: this=monster, inflictor=rocket, attacker=player
dir direction of the attack for knockback in global space
point point at which the damage is being inflicted, used for headshots
damage amount of damage being inflicted
inflictor, attacker, dir, and point can be NULL for environmental effects
============
*/
void idEntity::Damage( idEntity* inflictor, idEntity* attacker, const idVec3& dir,
const char* damageDefName, const float damageScale, const int location )
{
if( !fl.takedamage )
{
return;
}
SetTimeState ts( timeGroup );
if( !inflictor )
{
inflictor = gameLocal.world;
}
if( !attacker )
{
attacker = gameLocal.world;
}
const idDict* damageDef = gameLocal.FindEntityDefDict( damageDefName );
if( damageDef == NULL )
{
gameLocal.Error( "Unknown damageDef '%s'\n", damageDefName );
return;
}
int damage = damageDef->GetInt( "damage" );
// inform the attacker that they hit someone
attacker->DamageFeedback( this, inflictor, damage );
if( damage )
{
// do the damage
health -= damage;
if( health <= 0 )
{
if( health < -999 )
{
health = -999;
}
Killed( inflictor, attacker, damage, dir, location );
}
else
{
Pain( inflictor, attacker, damage, dir, location );
}
}
}
/*
================
idEntity::AddDamageEffect
================
*/
void idEntity::AddDamageEffect( const trace_t& collision, const idVec3& velocity, const char* damageDefName )
{
const char* sound, *decal, *key;
const idDeclEntityDef* def = gameLocal.FindEntityDef( damageDefName, false );
if( def == NULL )
{
return;
}
const char* materialType = gameLocal.sufaceTypeNames[ collision.c.material->GetSurfaceType() ];
// start impact sound based on material type
key = va( "snd_%s", materialType );
sound = spawnArgs.GetString( key );
if( *sound == '\0' )
{
sound = def->dict.GetString( key );
}
if( *sound != '\0' )
{
StartSoundShader( declManager->FindSound( sound ), SND_CHANNEL_BODY, 0, false, NULL );
}
if( g_decals.GetBool() )
{
// place a wound overlay on the model
key = va( "mtr_wound_%s", materialType );
decal = spawnArgs.RandomPrefix( key, gameLocal.random );
if( *decal == '\0' )
{
decal = def->dict.RandomPrefix( key, gameLocal.random );
}
if( *decal != '\0' )
{
idVec3 dir = velocity;
dir.Normalize();
ProjectOverlay( collision.c.point, dir, 20.0f, decal );
}
}
}
/*
============
idEntity::Pain
Called whenever an entity recieves damage. Returns whether the entity responds to the pain.
This is a virtual function that subclasses are expected to implement.
============
*/
bool idEntity::Pain( idEntity* inflictor, idEntity* attacker, int damage, const idVec3& dir, int location )
{
return false;
}
/*
============
idEntity::Killed
Called whenever an entity's health is reduced to 0 or less.
This is a virtual function that subclasses are expected to implement.
============
*/
void idEntity::Killed( idEntity* inflictor, idEntity* attacker, int damage, const idVec3& dir, int location )
{
}
/***********************************************************************
Script functions
***********************************************************************/
/*
================
idEntity::ShouldConstructScriptObjectAtSpawn
Called during idEntity::Spawn to see if it should construct the script object or not.
Overridden by subclasses that need to spawn the script object themselves.
================
*/
bool idEntity::ShouldConstructScriptObjectAtSpawn() const
{
return true;
}
/*
================
idEntity::ConstructScriptObject
Called during idEntity::Spawn. Calls the constructor on the script object.
Can be overridden by subclasses when a thread doesn't need to be allocated.
================
*/
idThread* idEntity::ConstructScriptObject()
{
idThread* thread;
const function_t* constructor;
// init the script object's data
scriptObject.ClearObject();
// call script object's constructor
constructor = scriptObject.GetConstructor();
if( constructor )
{
// start a thread that will initialize after Spawn is done being called
thread = new idThread();
thread->SetThreadName( name.c_str() );
thread->CallFunction( this, constructor, true );
thread->DelayedStart( 0 );
}
else
{
thread = NULL;
}
// clear out the object's memory
scriptObject.ClearObject();
return thread;
}
/*
================
idEntity::DeconstructScriptObject
Called during idEntity::~idEntity. Calls the destructor on the script object.
Can be overridden by subclasses when a thread doesn't need to be allocated.
Not called during idGameLocal::MapShutdown.
================
*/
void idEntity::DeconstructScriptObject()
{
idThread* thread;
const function_t* destructor;
// don't bother calling the script object's destructor on map shutdown
if( gameLocal.GameState() == GAMESTATE_SHUTDOWN )
{
return;
}
// call script object's destructor
destructor = scriptObject.GetDestructor();
if( destructor )
{
// start a thread that will run immediately and be destroyed
thread = new idThread();
thread->SetThreadName( name.c_str() );
thread->CallFunction( this, destructor, true );
thread->Execute();
delete thread;
}
}
/*
================
idEntity::HasSignal
================
*/
bool idEntity::HasSignal( signalNum_t signalnum ) const
{
if( !signals )
{
return false;
}
assert( ( signalnum >= 0 ) && ( signalnum < NUM_SIGNALS ) );
return ( signals->signal[ signalnum ].Num() > 0 );
}
/*
================
idEntity::SetSignal
================
*/
void idEntity::SetSignal( signalNum_t signalnum, idThread* thread, const function_t* function )
{
int i;
int num;
signal_t sig;
int threadnum;
assert( ( signalnum >= 0 ) && ( signalnum < NUM_SIGNALS ) );
if( !signals )
{
signals = new( TAG_ENTITY ) signalList_t;
}
assert( thread );
threadnum = thread->GetThreadNum();
num = signals->signal[ signalnum ].Num();
for( i = 0; i < num; i++ )
{
if( signals->signal[ signalnum ][ i ].threadnum == threadnum )
{
signals->signal[ signalnum ][ i ].function = function;
return;
}
}
if( num >= MAX_SIGNAL_THREADS )
{
thread->Error( "Exceeded maximum number of signals per object" );
}
sig.threadnum = threadnum;
sig.function = function;
signals->signal[ signalnum ].Append( sig );
}
/*
================
idEntity::ClearSignal
================
*/
void idEntity::ClearSignal( idThread* thread, signalNum_t signalnum )
{
assert( thread );
if( ( signalnum < 0 ) || ( signalnum >= NUM_SIGNALS ) )
{
gameLocal.Error( "Signal out of range" );
return;
}
if( signals == NULL )
{
return;
}
signals->signal[ signalnum ].Clear();
}
/*
================
idEntity::ClearSignalThread
================
*/
void idEntity::ClearSignalThread( signalNum_t signalnum, idThread* thread )
{
int i;
int num;
int threadnum;
assert( thread );
if( ( signalnum < 0 ) || ( signalnum >= NUM_SIGNALS ) )
{
gameLocal.Error( "Signal out of range" );
return;
}
if( signals == NULL )
{
return;
}
threadnum = thread->GetThreadNum();
num = signals->signal[ signalnum ].Num();
for( i = 0; i < num; i++ )
{
if( signals->signal[ signalnum ][ i ].threadnum == threadnum )
{
signals->signal[ signalnum ].RemoveIndex( i );
return;
}
}
}
/*
================
idEntity::Signal
================
*/
void idEntity::Signal( signalNum_t signalnum )
{
int i;
int num;
signal_t sigs[ MAX_SIGNAL_THREADS ];
idThread* thread;
assert( ( signalnum >= 0 ) && ( signalnum < NUM_SIGNALS ) );
if( !signals )
{
return;
}
// we copy the signal list since each thread has the potential
// to end any of the threads in the list. By copying the list
// we don't have to worry about the list changing as we're
// processing it.
num = signals->signal[ signalnum ].Num();
for( i = 0; i < num; i++ )
{
sigs[ i ] = signals->signal[ signalnum ][ i ];
}
// clear out the signal list so that we don't get into an infinite loop
signals->signal[ signalnum ].Clear();
for( i = 0; i < num; i++ )
{
thread = idThread::GetThread( sigs[ i ].threadnum );
if( thread )
{
thread->CallFunction( this, sigs[ i ].function, true );
thread->Execute();
}
}
}
/*
================
idEntity::SignalEvent
================
*/
void idEntity::SignalEvent( idThread* thread, signalNum_t signalnum )
{
if( ( signalnum < 0 ) || ( signalnum >= NUM_SIGNALS ) )
{
gameLocal.Error( "Signal out of range" );
}
if( !signals )
{
return;
}
Signal( signalnum );
}
/***********************************************************************
Guis.
***********************************************************************/
/*
================
idEntity::TriggerGuis
================
*/
void idEntity::TriggerGuis()
{
int i;
for( i = 0; i < MAX_RENDERENTITY_GUI; i++ )
{
if( renderEntity.gui[ i ] )
{
renderEntity.gui[ i ]->Trigger( gameLocal.time );
}
}
}
/*
================
idEntity::HandleGuiCommands
================
*/
bool idEntity::HandleGuiCommands( idEntity* entityGui, const char* cmds )
{
idEntity* targetEnt;
bool ret = false;
if( entityGui && cmds && *cmds )
{
idLexer src;
idToken token, token2, token3, token4;
src.LoadMemory( cmds, strlen( cmds ), "guiCommands" );
while( 1 )
{
if( !src.ReadToken( &token ) )
{
return ret;
}
if( token == ";" )
{
continue;
}
if( token.Icmp( "activate" ) == 0 )
{
bool targets = true;
if( src.ReadToken( &token2 ) )
{
if( token2 == ";" )
{
src.UnreadToken( &token2 );
}
else
{
targets = false;
}
}
if( targets )
{
entityGui->ActivateTargets( this );
}
else
{
idEntity* ent = gameLocal.FindEntity( token2 );
if( ent )
{
ent->Signal( SIG_TRIGGER );
ent->PostEventMS( &EV_Activate, 0, this );
}
}
entityGui->renderEntity.shaderParms[ SHADERPARM_MODE ] = 1.0f;
continue;
}
if( token.Icmp( "runScript" ) == 0 )
{
if( src.ReadToken( &token2 ) )
{
while( src.CheckTokenString( "::" ) )
{
idToken token3;
if( !src.ReadToken( &token3 ) )
{
gameLocal.Error( "Expecting function name following '::' in gui for entity '%s'", entityGui->name.c_str() );
}
token2 += "::" + token3;
}
const function_t* func = gameLocal.program.FindFunction( token2 );
if( !func )
{
gameLocal.Error( "Can't find function '%s' for gui in entity '%s'", token2.c_str(), entityGui->name.c_str() );
}
else
{
idThread* thread = new idThread( func );
thread->DelayedStart( 0 );
}
}
continue;
}
if( token.Icmp( "play" ) == 0 )
{
if( src.ReadToken( &token2 ) )
{
const idSoundShader* shader = declManager->FindSound( token2 );
entityGui->StartSoundShader( shader, SND_CHANNEL_ANY, 0, false, NULL );
}
continue;
}
if( token.Icmp( "setkeyval" ) == 0 )
{
if( src.ReadToken( &token2 ) && src.ReadToken( &token3 ) && src.ReadToken( &token4 ) )
{
idEntity* ent = gameLocal.FindEntity( token2 );
if( ent )
{
ent->spawnArgs.Set( token3, token4 );
ent->UpdateChangeableSpawnArgs( NULL );
ent->UpdateVisuals();
}
}
continue;
}
if( token.Icmp( "setshaderparm" ) == 0 )
{
if( src.ReadToken( &token2 ) && src.ReadToken( &token3 ) )
{
entityGui->SetShaderParm( atoi( token2 ), atof( token3 ) );
entityGui->UpdateVisuals();
}
continue;
}
if( token.Icmp( "close" ) == 0 )
{
ret = true;
continue;
}
if( !token.Icmp( "turkeyscore" ) )
{
if( src.ReadToken( &token2 ) && entityGui->renderEntity.gui[0] )
{
int score = entityGui->renderEntity.gui[0]->State().GetInt( "score" );
score += atoi( token2 );
entityGui->renderEntity.gui[0]->SetStateInt( "score", score );
if( gameLocal.GetLocalPlayer() && score >= 25000 )
{
gameLocal.GetLocalPlayer()->GetAchievementManager().EventCompletesAchievement( ACHIEVEMENT_SCORE_25000_TURKEY_PUNCHER );
gameLocal.GetLocalPlayer()->GiveEmail( static_cast( declManager->FindType( DECL_EMAIL, "highScore", false ) ) );
}
}
continue;
}
if( !token.Icmp( "martianbuddycomplete" ) )
{
gameLocal.GetLocalPlayer()->GiveEmail( static_cast( declManager->FindType( DECL_EMAIL, "MartianBuddyGameComplete", false ) ) );
continue;
}
// handy for debugging GUI stuff
if( !token.Icmp( "print" ) )
{
idStr msg;
while( src.ReadToken( &token2 ) )
{
if( token2 == ";" )
{
src.UnreadToken( &token2 );
break;
}
msg += token2.c_str();
}
common->Printf( "ent gui 0x%x '%s': %s\n", entityNumber, name.c_str(), msg.c_str() );
continue;
}
// if we get to this point we don't know how to handle it
src.UnreadToken( &token );
if( !HandleSingleGuiCommand( entityGui, &src ) )
{
// not handled there see if entity or any of its targets can handle it
// this will only work for one target atm
if( entityGui->HandleSingleGuiCommand( entityGui, &src ) )
{
continue;
}
int c = entityGui->targets.Num();
int i;
for( i = 0; i < c; i++ )
{
targetEnt = entityGui->targets[ i ].GetEntity();
if( targetEnt && targetEnt->HandleSingleGuiCommand( entityGui, &src ) )
{
break;
}
}
if( i == c )
{
// not handled
common->DPrintf( "idEntity::HandleGuiCommands: '%s' not handled\n", token.c_str() );
src.ReadToken( &token );
}
}
}
}
return ret;
}
/*
================
idEntity::HandleSingleGuiCommand
================
*/
bool idEntity::HandleSingleGuiCommand( idEntity* entityGui, idLexer* src )
{
return false;
}
/***********************************************************************
Targets
***********************************************************************/
/*
===============
idEntity::FindTargets
We have to wait until all entities are spawned
Used to build lists of targets after the entity is spawned. Since not all entities
have been spawned when the entity is created at map load time, we have to wait
===============
*/
void idEntity::FindTargets()
{
int i;
// targets can be a list of multiple names
gameLocal.GetTargets( spawnArgs, targets, "target" );
// ensure that we don't target ourselves since that could cause an infinite loop when activating entities
for( i = 0; i < targets.Num(); i++ )
{
if( targets[ i ].GetEntity() == this )
{
gameLocal.Error( "Entity '%s' is targeting itself", name.c_str() );
}
}
}
/*
================
idEntity::RemoveNullTargets
================
*/
void idEntity::RemoveNullTargets()
{
int i;
for( i = targets.Num() - 1; i >= 0; i-- )
{
if( !targets[ i ].GetEntity() )
{
targets.RemoveIndex( i );
}
}
}
/*
==============================
idEntity::ActivateTargets
"activator" should be set to the entity that initiated the firing.
==============================
*/
void idEntity::ActivateTargets( idEntity* activator ) const
{
idEntity* ent;
int i, j;
for( i = 0; i < targets.Num(); i++ )
{
ent = targets[ i ].GetEntity();
if( !ent )
{
continue;
}
if( ent->RespondsTo( EV_Activate ) || ent->HasSignal( SIG_TRIGGER ) )
{
ent->Signal( SIG_TRIGGER );
ent->ProcessEvent( &EV_Activate, activator );
}
for( j = 0; j < MAX_RENDERENTITY_GUI; j++ )
{
if( ent->renderEntity.gui[ j ] )
{
ent->renderEntity.gui[ j ]->Trigger( gameLocal.time );
}
}
}
}
/***********************************************************************
Misc.
***********************************************************************/
/*
================
idEntity::Teleport
================
*/
void idEntity::Teleport( const idVec3& origin, const idAngles& angles, idEntity* destination )
{
GetPhysics()->SetOrigin( origin );
GetPhysics()->SetAxis( angles.ToMat3() );
UpdateVisuals();
}
/*
============
idEntity::TouchTriggers
Activate all trigger entities touched at the current position.
============
*/
bool idEntity::TouchTriggers() const
{
int i, numClipModels, numEntities;
idClipModel* cm;
idClipModel* clipModels[ MAX_GENTITIES ];
idEntity* ent;
trace_t trace;
memset( &trace, 0, sizeof( trace ) );
trace.endpos = GetPhysics()->GetOrigin();
trace.endAxis = GetPhysics()->GetAxis();
numClipModels = gameLocal.clip.ClipModelsTouchingBounds( GetPhysics()->GetAbsBounds(), CONTENTS_TRIGGER, clipModels, MAX_GENTITIES );
numEntities = 0;
for( i = 0; i < numClipModels; i++ )
{
cm = clipModels[ i ];
// don't touch it if we're the owner
if( cm->GetOwner() == this )
{
continue;
}
ent = cm->GetEntity();
if( !ent->RespondsTo( EV_Touch ) && !ent->HasSignal( SIG_TOUCH ) )
{
continue;
}
if( !GetPhysics()->ClipContents( cm ) )
{
continue;
}
SetTimeState ts( ent->timeGroup );
numEntities++;
trace.c.contents = cm->GetContents();
trace.c.entityNum = cm->GetEntity()->entityNumber;
trace.c.id = cm->GetId();
ent->Signal( SIG_TOUCH );
ent->ProcessEvent( &EV_Touch, this, &trace );
if( !gameLocal.entities[ entityNumber ] )
{
gameLocal.Printf( "entity was removed while touching triggers\n" );
return true;
}
}
return ( numEntities != 0 );
}
/*
================
idEntity::GetSpline
================
*/
idCurve_Spline* idEntity::GetSpline() const
{
int i, numPoints, t;
const idKeyValue* kv;
idLexer lex;
idVec3 v;
idCurve_Spline* spline;
const char* curveTag = "curve_";
kv = spawnArgs.MatchPrefix( curveTag );
if( !kv )
{
return NULL;
}
idStr str = kv->GetKey().Right( kv->GetKey().Length() - strlen( curveTag ) );
if( str.Icmp( "CatmullRomSpline" ) == 0 )
{
spline = new( TAG_ENTITY ) idCurve_CatmullRomSpline();
}
else if( str.Icmp( "nubs" ) == 0 )
{
spline = new( TAG_ENTITY ) idCurve_NonUniformBSpline();
}
else if( str.Icmp( "nurbs" ) == 0 )
{
spline = new( TAG_ENTITY ) idCurve_NURBS();
}
else
{
spline = new( TAG_ENTITY ) idCurve_BSpline();
}
spline->SetBoundaryType( idCurve_Spline::BT_CLAMPED );
lex.LoadMemory( kv->GetValue(), kv->GetValue().Length(), curveTag );
numPoints = lex.ParseInt();
lex.ExpectTokenString( "(" );
for( t = i = 0; i < numPoints; i++, t += 100 )
{
v.x = lex.ParseFloat();
v.y = lex.ParseFloat();
v.z = lex.ParseFloat();
spline->AddValue( t, v );
}
lex.ExpectTokenString( ")" );
return spline;
}
/*
===============
idEntity::ShowEditingDialog
===============
*/
void idEntity::ShowEditingDialog()
{
}
/***********************************************************************
Events
***********************************************************************/
/*
================
idEntity::Event_GetName
================
*/
void idEntity::Event_GetName()
{
idThread::ReturnString( name.c_str() );
}
/*
================
idEntity::Event_SetName
================
*/
void idEntity::Event_SetName( const char* newname )
{
SetName( newname );
}
/*
===============
idEntity::Event_FindTargets
===============
*/
void idEntity::Event_FindTargets()
{
FindTargets();
}
/*
============
idEntity::Event_ActivateTargets
Activates any entities targeted by this entity. Mainly used as an
event to delay activating targets.
============
*/
void idEntity::Event_ActivateTargets( idEntity* activator )
{
ActivateTargets( activator );
}
/*
================
idEntity::Event_NumTargets
================
*/
void idEntity::Event_NumTargets()
{
idThread::ReturnFloat( targets.Num() );
}
/*
================
idEntity::Event_GetTarget
================
*/
void idEntity::Event_GetTarget( float index )
{
int i;
i = ( int )index;
if( ( i < 0 ) || i >= targets.Num() )
{
idThread::ReturnEntity( NULL );
}
else
{
idThread::ReturnEntity( targets[ i ].GetEntity() );
}
}
/*
================
idEntity::Event_RandomTarget
================
*/
void idEntity::Event_RandomTarget( const char* ignore )
{
int num;
idEntity* ent;
int i;
int ignoreNum;
RemoveNullTargets();
if( !targets.Num() )
{
idThread::ReturnEntity( NULL );
return;
}
ignoreNum = -1;
if( ignore && ( ignore[ 0 ] != 0 ) && ( targets.Num() > 1 ) )
{
for( i = 0; i < targets.Num(); i++ )
{
ent = targets[ i ].GetEntity();
if( ent && ( ent->name == ignore ) )
{
ignoreNum = i;
break;
}
}
}
if( ignoreNum >= 0 )
{
num = gameLocal.random.RandomInt( targets.Num() - 1 );
if( num >= ignoreNum )
{
num++;
}
}
else
{
num = gameLocal.random.RandomInt( targets.Num() );
}
ent = targets[ num ].GetEntity();
idThread::ReturnEntity( ent );
}
/*
================
idEntity::Event_BindToJoint
================
*/
void idEntity::Event_BindToJoint( idEntity* master, const char* jointname, float orientated )
{
BindToJoint( master, jointname, ( orientated != 0.0f ) );
}
/*
================
idEntity::Event_RemoveBinds
================
*/
void idEntity::Event_RemoveBinds()
{
RemoveBinds();
}
/*
================
idEntity::Event_Bind
================
*/
void idEntity::Event_Bind( idEntity* master )
{
Bind( master, true );
}
/*
================
idEntity::Event_BindPosition
================
*/
void idEntity::Event_BindPosition( idEntity* master )
{
Bind( master, false );
}
/*
================
idEntity::Event_Unbind
================
*/
void idEntity::Event_Unbind()
{
Unbind();
}
/*
================
idEntity::Event_SpawnBind
================
*/
void idEntity::Event_SpawnBind()
{
idEntity* parent;
const char* bind, *joint, *bindanim;
jointHandle_t bindJoint;
bool bindOrientated;
int id;
const idAnim* anim;
int animNum;
idAnimator* parentAnimator;
if( spawnArgs.GetString( "bind", "", &bind ) )
{
if( idStr::Icmp( bind, "worldspawn" ) == 0 )
{
//FIXME: Completely unneccessary since the worldspawn is called "world"
parent = gameLocal.world;
}
else
{
parent = gameLocal.FindEntity( bind );
}
bindOrientated = spawnArgs.GetBool( "bindOrientated", "1" );
if( parent )
{
// bind to a joint of the skeletal model of the parent
if( spawnArgs.GetString( "bindToJoint", "", &joint ) && *joint )
{
parentAnimator = parent->GetAnimator();
if( parentAnimator == NULL )
{
gameLocal.Error( "Cannot bind to joint '%s' on '%s'. Entity does not support skeletal models.", joint, name.c_str() );
return;
}
bindJoint = parentAnimator->GetJointHandle( joint );
if( bindJoint == INVALID_JOINT )
{
gameLocal.Error( "Joint '%s' not found for bind on '%s'", joint, name.c_str() );
}
// bind it relative to a specific anim
if( ( parent->spawnArgs.GetString( "bindanim", "", &bindanim ) || parent->spawnArgs.GetString( "anim", "", &bindanim ) ) && *bindanim )
{
animNum = parentAnimator->GetAnim( bindanim );
if( !animNum )
{
gameLocal.Error( "Anim '%s' not found for bind on '%s'", bindanim, name.c_str() );
}
anim = parentAnimator->GetAnim( animNum );
if( !anim )
{
gameLocal.Error( "Anim '%s' not found for bind on '%s'", bindanim, name.c_str() );
}
// make sure parent's render origin has been set
parent->UpdateModelTransform();
//FIXME: need a BindToJoint that accepts a joint position
parentAnimator->CreateFrame( gameLocal.time, true );
idJointMat* frame = parent->renderEntity.joints;
gameEdit->ANIM_CreateAnimFrame( parentAnimator->ModelHandle(), anim->MD5Anim( 0 ), parent->renderEntity.numJoints, frame, 0, parentAnimator->ModelDef()->GetVisualOffset(), parentAnimator->RemoveOrigin() );
BindToJoint( parent, joint, bindOrientated );
parentAnimator->ForceUpdate();
}
else
{
BindToJoint( parent, joint, bindOrientated );
}
}
// bind to a body of the physics object of the parent
else if( spawnArgs.GetInt( "bindToBody", "0", id ) )
{
BindToBody( parent, id, bindOrientated );
}
// bind to the parent
else
{
Bind( parent, bindOrientated );
}
}
}
}
/*
================
idEntity::Event_SetOwner
================
*/
void idEntity::Event_SetOwner( idEntity* owner )
{
int i;
for( i = 0; i < GetPhysics()->GetNumClipModels(); i++ )
{
GetPhysics()->GetClipModel( i )->SetOwner( owner );
}
}
/*
================
idEntity::Event_SetModel
================
*/
void idEntity::Event_SetModel( const char* modelname )
{
SetModel( modelname );
}
/*
================
idEntity::Event_SetSkin
================
*/
void idEntity::Event_SetSkin( const char* skinname )
{
renderEntity.customSkin = declManager->FindSkin( skinname );
UpdateVisuals();
}
/*
================
idEntity::Event_GetShaderParm
================
*/
void idEntity::Event_GetShaderParm( int parmnum )
{
if( ( parmnum < 0 ) || ( parmnum >= MAX_ENTITY_SHADER_PARMS ) )
{
gameLocal.Error( "shader parm index (%d) out of range", parmnum );
return;
}
idThread::ReturnFloat( renderEntity.shaderParms[ parmnum ] );
}
/*
================
idEntity::Event_SetShaderParm
================
*/
void idEntity::Event_SetShaderParm( int parmnum, float value )
{
SetShaderParm( parmnum, value );
}
/*
================
idEntity::Event_SetShaderParms
================
*/
void idEntity::Event_SetShaderParms( float parm0, float parm1, float parm2, float parm3 )
{
renderEntity.shaderParms[ SHADERPARM_RED ] = parm0;
renderEntity.shaderParms[ SHADERPARM_GREEN ] = parm1;
renderEntity.shaderParms[ SHADERPARM_BLUE ] = parm2;
renderEntity.shaderParms[ SHADERPARM_ALPHA ] = parm3;
UpdateVisuals();
}
/*
================
idEntity::Event_SetColor
================
*/
void idEntity::Event_SetColor( float red, float green, float blue )
{
SetColor( red, green, blue );
}
/*
================
idEntity::Event_GetColor
================
*/
void idEntity::Event_GetColor()
{
idVec3 out;
GetColor( out );
idThread::ReturnVector( out );
}
/*
================
idEntity::Event_IsHidden
================
*/
void idEntity::Event_IsHidden()
{
idThread::ReturnInt( fl.hidden );
}
/*
================
idEntity::Event_Hide
================
*/
void idEntity::Event_Hide()
{
Hide();
}
/*
================
idEntity::Event_Show
================
*/
void idEntity::Event_Show()
{
Show();
}
/*
================
idEntity::Event_CacheSoundShader
================
*/
void idEntity::Event_CacheSoundShader( const char* soundName )
{
declManager->FindSound( soundName );
}
/*
================
idEntity::Event_StartSoundShader
================
*/
void idEntity::Event_StartSoundShader( const char* soundName, int channel )
{
int length = 0;
if( soundName == NULL || soundName[0] == 0 )
{
StopSound( channel, false );
}
else
{
StartSoundShader( declManager->FindSound( soundName ), ( s_channelType )channel, 0, false, &length );
}
idThread::ReturnFloat( MS2SEC( length ) );
}
/*
================
idEntity::Event_StopSound
================
*/
void idEntity::Event_StopSound( int channel, int netSync )
{
StopSound( channel, ( netSync != 0 ) );
}
/*
================
idEntity::Event_StartSound
================
*/
void idEntity::Event_StartSound( const char* soundName, int channel, int netSync )
{
int time;
StartSound( soundName, ( s_channelType )channel, 0, ( netSync != 0 ), &time );
idThread::ReturnFloat( MS2SEC( time ) );
}
/*
================
idEntity::Event_FadeSound
================
*/
void idEntity::Event_FadeSound( int channel, float to, float over )
{
if( refSound.referenceSound )
{
refSound.referenceSound->FadeSound( channel, to, over );
}
}
/*
================
idEntity::Event_GetWorldOrigin
================
*/
void idEntity::Event_GetWorldOrigin()
{
idThread::ReturnVector( GetPhysics()->GetOrigin() );
}
/*
================
idEntity::Event_SetWorldOrigin
================
*/
void idEntity::Event_SetWorldOrigin( idVec3 const& org )
{
idVec3 neworg = GetLocalCoordinates( org );
SetOrigin( neworg );
}
/*
================
idEntity::Event_SetOrigin
================
*/
void idEntity::Event_SetOrigin( idVec3 const& org )
{
SetOrigin( org );
}
/*
================
idEntity::Event_GetOrigin
================
*/
void idEntity::Event_GetOrigin()
{
idThread::ReturnVector( GetLocalCoordinates( GetPhysics()->GetOrigin() ) );
}
/*
================
idEntity::Event_SetAngles
================
*/
void idEntity::Event_SetAngles( idAngles const& ang )
{
SetAngles( ang );
}
/*
================
idEntity::Event_GetAngles
================
*/
void idEntity::Event_GetAngles()
{
idAngles ang = GetPhysics()->GetAxis().ToAngles();
idThread::ReturnVector( idVec3( ang[0], ang[1], ang[2] ) );
}
/*
================
idEntity::Event_SetLinearVelocity
================
*/
void idEntity::Event_SetLinearVelocity( const idVec3& velocity )
{
GetPhysics()->SetLinearVelocity( velocity );
}
/*
================
idEntity::Event_GetLinearVelocity
================
*/
void idEntity::Event_GetLinearVelocity()
{
idThread::ReturnVector( GetPhysics()->GetLinearVelocity() );
}
/*
================
idEntity::Event_SetAngularVelocity
================
*/
void idEntity::Event_SetAngularVelocity( const idVec3& velocity )
{
GetPhysics()->SetAngularVelocity( velocity );
}
/*
================
idEntity::Event_GetAngularVelocity
================
*/
void idEntity::Event_GetAngularVelocity()
{
idThread::ReturnVector( GetPhysics()->GetAngularVelocity() );
}
/*
================
idEntity::Event_SetSize
================
*/
void idEntity::Event_SetSize( idVec3 const& mins, idVec3 const& maxs )
{
GetPhysics()->SetClipBox( idBounds( mins, maxs ), 1.0f );
}
/*
================
idEntity::Event_GetSize
================
*/
void idEntity::Event_GetSize()
{
idBounds bounds;
bounds = GetPhysics()->GetBounds();
idThread::ReturnVector( bounds[1] - bounds[0] );
}
/*
================
idEntity::Event_GetMins
================
*/
void idEntity::Event_GetMins()
{
idThread::ReturnVector( GetPhysics()->GetBounds()[0] );
}
/*
================
idEntity::Event_GetMaxs
================
*/
void idEntity::Event_GetMaxs()
{
idThread::ReturnVector( GetPhysics()->GetBounds()[1] );
}
/*
================
idEntity::Event_Touches
================
*/
void idEntity::Event_Touches( idEntity* ent )
{
if( !ent )
{
idThread::ReturnInt( false );
return;
}
const idBounds& myBounds = GetPhysics()->GetAbsBounds();
const idBounds& entBounds = ent->GetPhysics()->GetAbsBounds();
idThread::ReturnInt( myBounds.IntersectsBounds( entBounds ) );
}
/*
================
idEntity::Event_SetGuiParm
================
*/
void idEntity::Event_SetGuiParm( const char* key, const char* val )
{
for( int i = 0; i < MAX_RENDERENTITY_GUI; i++ )
{
if( renderEntity.gui[ i ] )
{
if( idStr::Icmpn( key, "gui_", 4 ) == 0 )
{
spawnArgs.Set( key, val );
}
renderEntity.gui[ i ]->SetStateString( key, val );
renderEntity.gui[ i ]->StateChanged( gameLocal.time );
}
}
}
/*
================
idEntity::Event_SetGuiParm
================
*/
void idEntity::Event_SetGuiFloat( const char* key, float f )
{
for( int i = 0; i < MAX_RENDERENTITY_GUI; i++ )
{
if( renderEntity.gui[ i ] )
{
renderEntity.gui[ i ]->SetStateString( key, va( "%f", f ) );
renderEntity.gui[ i ]->StateChanged( gameLocal.time );
}
}
}
/*
================
idEntity::Event_GetNextKey
================
*/
void idEntity::Event_GetNextKey( const char* prefix, const char* lastMatch )
{
const idKeyValue* kv;
const idKeyValue* previous;
if( *lastMatch )
{
previous = spawnArgs.FindKey( lastMatch );
}
else
{
previous = NULL;
}
kv = spawnArgs.MatchPrefix( prefix, previous );
if( !kv )
{
idThread::ReturnString( "" );
}
else
{
idThread::ReturnString( kv->GetKey() );
}
}
/*
================
idEntity::Event_SetKey
================
*/
void idEntity::Event_SetKey( const char* key, const char* value )
{
spawnArgs.Set( key, value );
UpdateChangeableSpawnArgs( NULL );
}
/*
================
idEntity::Event_GetKey
================
*/
void idEntity::Event_GetKey( const char* key )
{
const char* value;
spawnArgs.GetString( key, "", &value );
idThread::ReturnString( value );
}
/*
================
idEntity::Event_GetIntKey
================
*/
void idEntity::Event_GetIntKey( const char* key )
{
int value;
spawnArgs.GetInt( key, "0", value );
// scripts only support floats
idThread::ReturnFloat( value );
}
/*
================
idEntity::Event_GetFloatKey
================
*/
void idEntity::Event_GetFloatKey( const char* key )
{
float value;
spawnArgs.GetFloat( key, "0", value );
idThread::ReturnFloat( value );
}
/*
================
idEntity::Event_GetVectorKey
================
*/
void idEntity::Event_GetVectorKey( const char* key )
{
idVec3 value;
spawnArgs.GetVector( key, "0 0 0", value );
idThread::ReturnVector( value );
}
/*
================
idEntity::Event_GetEntityKey
================
*/
void idEntity::Event_GetEntityKey( const char* key )
{
idEntity* ent;
const char* entname;
if( !spawnArgs.GetString( key, NULL, &entname ) )
{
idThread::ReturnEntity( NULL );
return;
}
ent = gameLocal.FindEntity( entname );
if( !ent )
{
gameLocal.Warning( "Couldn't find entity '%s' specified in '%s' key in entity '%s'", entname, key, name.c_str() );
}
idThread::ReturnEntity( ent );
}
/*
================
idEntity::Event_RestorePosition
================
*/
void idEntity::Event_RestorePosition()
{
idVec3 org;
idAngles angles;
idMat3 axis;
idEntity* part;
spawnArgs.GetVector( "origin", "0 0 0", org );
// get the rotation matrix in either full form, or single angle form
if( spawnArgs.GetMatrix( "rotation", "1 0 0 0 1 0 0 0 1", axis ) )
{
angles = axis.ToAngles();
}
else
{
angles[ 0 ] = 0;
angles[ 1 ] = spawnArgs.GetFloat( "angle" );
angles[ 2 ] = 0;
}
Teleport( org, angles, NULL );
for( part = teamChain; part != NULL; part = part->teamChain )
{
if( part->bindMaster != this )
{
continue;
}
if( part->GetPhysics()->IsType( idPhysics_Parametric::Type ) )
{
if( static_cast( part->GetPhysics() )->IsPusher() )
{
gameLocal.Warning( "teleported '%s' which has the pushing mover '%s' bound to it\n", GetName(), part->GetName() );
}
}
else if( part->GetPhysics()->IsType( idPhysics_AF::Type ) )
{
gameLocal.Warning( "teleported '%s' which has the articulated figure '%s' bound to it\n", GetName(), part->GetName() );
}
}
}
/*
================
idEntity::Event_UpdateCameraTarget
================
*/
void idEntity::Event_UpdateCameraTarget()
{
const char* target;
const idKeyValue* kv;
idVec3 dir;
target = spawnArgs.GetString( "cameraTarget" );
cameraTarget = gameLocal.FindEntity( target );
if( cameraTarget != NULL )
{
kv = cameraTarget->spawnArgs.MatchPrefix( "target", NULL );
while( kv )
{
idEntity* ent = gameLocal.FindEntity( kv->GetValue() );
if( ent != NULL && idStr::Icmp( ent->GetEntityDefName(), "target_null" ) == 0 )
{
dir = ent->GetPhysics()->GetOrigin() - cameraTarget->GetPhysics()->GetOrigin();
dir.Normalize();
cameraTarget->SetAxis( dir.ToMat3() );
SetAxis( dir.ToMat3() );
break;
}
kv = cameraTarget->spawnArgs.MatchPrefix( "target", kv );
}
}
UpdateVisuals();
}
/*
================
idEntity::Event_DistanceTo
================
*/
void idEntity::Event_DistanceTo( idEntity* ent )
{
if( !ent )
{
// just say it's really far away
idThread::ReturnFloat( MAX_WORLD_SIZE );
}
else
{
float dist = ( GetPhysics()->GetOrigin() - ent->GetPhysics()->GetOrigin() ).LengthFast();
idThread::ReturnFloat( dist );
}
}
/*
================
idEntity::Event_DistanceToPoint
================
*/
void idEntity::Event_DistanceToPoint( const idVec3& point )
{
float dist = ( GetPhysics()->GetOrigin() - point ).LengthFast();
idThread::ReturnFloat( dist );
}
/*
================
idEntity::Event_StartFx
================
*/
void idEntity::Event_StartFx( const char* fx )
{
idEntityFx::StartFx( fx, NULL, NULL, this, true );
}
/*
================
idEntity::Event_WaitFrame
================
*/
void idEntity::Event_WaitFrame()
{
idThread* thread;
thread = idThread::CurrentThread();
if( thread )
{
thread->WaitFrame();
}
}
/*
=====================
idEntity::Event_Wait
=====================
*/
void idEntity::Event_Wait( float time )
{
idThread* thread = idThread::CurrentThread();
if( thread == NULL )
{
gameLocal.Error( "Event 'wait' called from outside thread" );
return;
}
thread->WaitSec( time );
}
/*
=====================
idEntity::Event_HasFunction
=====================
*/
void idEntity::Event_HasFunction( const char* name )
{
const function_t* func;
func = scriptObject.GetFunction( name );
if( func )
{
idThread::ReturnInt( true );
}
else
{
idThread::ReturnInt( false );
}
}
/*
=====================
idEntity::Event_CallFunction
=====================
*/
void idEntity::Event_CallFunction( const char* funcname )
{
const function_t* func;
idThread* thread;
thread = idThread::CurrentThread();
if( thread == NULL )
{
gameLocal.Error( "Event 'callFunction' called from outside thread" );
return;
}
func = scriptObject.GetFunction( funcname );
if( func == NULL )
{
gameLocal.Error( "Unknown function '%s' in '%s'", funcname, scriptObject.GetTypeName() );
return;
}
if( func->type->NumParameters() != 1 )
{
gameLocal.Error( "Function '%s' has the wrong number of parameters for 'callFunction'", funcname );
return;
}
if( !scriptObject.GetTypeDef()->Inherits( func->type->GetParmType( 0 ) ) )
{
gameLocal.Error( "Function '%s' is the wrong type for 'callFunction'", funcname );
return;
}
// function args will be invalid after this call
thread->CallFunction( this, func, false );
}
/*
================
idEntity::Event_SetNeverDormant
================
*/
void idEntity::Event_SetNeverDormant( int enable )
{
fl.neverDormant = ( enable != 0 );
dormantStart = 0;
}
/*
================
idEntity::Event_SetGui
================
* BSM Nerve: Allows guis to be changed at runtime. Guis that are
* loaded after the level loads should be precahced using PrecacheGui.
*/
void idEntity::Event_SetGui( int guiNum, const char* guiName )
{
idUserInterface** gui = NULL;
if( guiNum >= 1 && guiNum <= MAX_RENDERENTITY_GUI )
{
gui = &renderEntity.gui[ guiNum - 1 ];
}
if( gui )
{
*gui = uiManager->FindGui( guiName, true, false );
UpdateGuiParms( *gui, &spawnArgs );
UpdateChangeableSpawnArgs( NULL );
gameRenderWorld->UpdateEntityDef( modelDefHandle, &renderEntity );
}
else
{
gameLocal.Error( "Entity '%s' doesn't have a GUI %d", name.c_str(), guiNum );
}
}
/*
================
idEntity::Event_PrecacheGui
================
* BSM Nerve: Forces the engine to initialize a gui even if it is not specified as used in a level.
* This is useful for preventing load hitches when switching guis during the game using "setGui"
*/
void idEntity::Event_PrecacheGui( const char* guiName )
{
uiManager->FindGui( guiName, true, true );
}
void idEntity::Event_GetGuiParm( int guiNum, const char* key )
{
if( renderEntity.gui[guiNum - 1] )
{
idThread::ReturnString( renderEntity.gui[guiNum - 1]->GetStateString( key ) );
return;
}
idThread::ReturnString( "" );
}
void idEntity::Event_GetGuiParmFloat( int guiNum, const char* key )
{
if( renderEntity.gui[guiNum - 1] )
{
idThread::ReturnFloat( renderEntity.gui[guiNum - 1]->GetStateFloat( key ) );
return;
}
idThread::ReturnFloat( 0.0f );
}
void idEntity::Event_GuiNamedEvent( int guiNum, const char* event )
{
if( renderEntity.gui[guiNum - 1] )
{
renderEntity.gui[guiNum - 1]->HandleNamedEvent( event );
}
}
/***********************************************************************
Network
***********************************************************************/
/*
================
idEntity::ClientThink
================
*/
void idEntity::ClientThink( const int curTime, const float fraction, const bool predict )
{
InterpolatePhysics( fraction );
Present();
}
/*
================
idEntity::ClientPredictionThink
================
*/
void idEntity::ClientPredictionThink()
{
RunPhysics();
Present();
}
/*
================
idEntity::WriteBindToSnapshot
================
*/
void idEntity::WriteBindToSnapshot( idBitMsg& msg ) const
{
int bindInfo;
if( bindMaster )
{
bindInfo = bindMaster->entityNumber;
bindInfo |= ( fl.bindOrientated & 1 ) << GENTITYNUM_BITS;
if( bindJoint != INVALID_JOINT )
{
bindInfo |= 1 << ( GENTITYNUM_BITS + 1 );
bindInfo |= bindJoint << ( 3 + GENTITYNUM_BITS );
}
else if( bindBody != -1 )
{
bindInfo |= 2 << ( GENTITYNUM_BITS + 1 );
bindInfo |= bindBody << ( 3 + GENTITYNUM_BITS );
}
}
else
{
bindInfo = ENTITYNUM_NONE;
}
msg.WriteBits( bindInfo, GENTITYNUM_BITS + 3 + 9 );
}
/*
================
idEntity::ReadBindFromSnapshot
================
*/
void idEntity::ReadBindFromSnapshot( const idBitMsg& msg )
{
int bindInfo, bindEntityNum, bindPos;
bool bindOrientated;
idEntity* master;
bindInfo = msg.ReadBits( GENTITYNUM_BITS + 3 + 9 );
bindEntityNum = bindInfo & ( ( 1 << GENTITYNUM_BITS ) - 1 );
if( ( bindEntityNum != ENTITYNUM_NONE ) && ( bindEntityNum < MAX_GENTITIES ) )
{
master = gameLocal.entities[ bindEntityNum ];
bindOrientated = ( bindInfo >> GENTITYNUM_BITS ) & 1;
bindPos = ( bindInfo >> ( GENTITYNUM_BITS + 3 ) );
switch( ( bindInfo >> ( GENTITYNUM_BITS + 1 ) ) & 3 )
{
case 1:
{
BindToJoint( master, ( jointHandle_t ) bindPos, bindOrientated );
break;
}
case 2:
{
BindToBody( master, bindPos, bindOrientated );
break;
}
default:
{
Bind( master, bindOrientated );
break;
}
}
}
else if( bindMaster )
{
Unbind();
}
}
/*
================
idEntity::WriteColorToSnapshot
================
*/
void idEntity::WriteColorToSnapshot( idBitMsg& msg ) const
{
idVec4 color;
color[0] = renderEntity.shaderParms[ SHADERPARM_RED ];
color[1] = renderEntity.shaderParms[ SHADERPARM_GREEN ];
color[2] = renderEntity.shaderParms[ SHADERPARM_BLUE ];
color[3] = renderEntity.shaderParms[ SHADERPARM_ALPHA ];
msg.WriteLong( PackColor( color ) );
}
/*
================
idEntity::ReadColorFromSnapshot
================
*/
void idEntity::ReadColorFromSnapshot( const idBitMsg& msg )
{
idVec4 color;
UnpackColor( msg.ReadLong(), color );
renderEntity.shaderParms[ SHADERPARM_RED ] = color[0];
renderEntity.shaderParms[ SHADERPARM_GREEN ] = color[1];
renderEntity.shaderParms[ SHADERPARM_BLUE ] = color[2];
renderEntity.shaderParms[ SHADERPARM_ALPHA ] = color[3];
}
/*
================
idEntity::WriteGUIToSnapshot
================
*/
void idEntity::WriteGUIToSnapshot( idBitMsg& msg ) const
{
// no need to loop over MAX_RENDERENTITY_GUI at this time
if( renderEntity.gui[ 0 ] )
{
msg.WriteByte( renderEntity.gui[ 0 ]->State().GetInt( "networkState" ) );
}
else
{
msg.WriteByte( 0 );
}
}
/*
================
idEntity::ReadGUIFromSnapshot
================
*/
void idEntity::ReadGUIFromSnapshot( const idBitMsg& msg )
{
int state;
idUserInterface* gui;
state = msg.ReadByte( );
gui = renderEntity.gui[ 0 ];
if( gui && state != mpGUIState )
{
mpGUIState = state;
gui->SetStateInt( "networkState", state );
gui->HandleNamedEvent( "networkState" );
}
}
/*
================
idEntity::WriteToSnapshot
================
*/
void idEntity::WriteToSnapshot( idBitMsg& msg ) const
{
}
/*
================
idEntity::ReadFromSnapshot
================
*/
void idEntity::ReadFromSnapshot( const idBitMsg& msg )
{
}
/*
================
idEntity::ReadFromSnapshot_Ex
Increments the snapshot counter for the entity.
================
*/
void idEntity::ReadFromSnapshot_Ex( const idBitMsg& msg )
{
snapshotsReceived += 1;
ReadFromSnapshot( msg );
}
/*
================
idEntity::FlagNewSnapshot
Updates the interpolationBehavior so that subclasses will know if it's safe to interpolate.
Only call this when a new snapshot has been received for this entity!
================
*/
void idEntity::FlagNewSnapshot()
{
switch( interpolationBehavior )
{
case USE_NO_INTERPOLATION:
{
interpolationBehavior = USE_LATEST_SNAP_ONLY;
break;
}
case USE_LATEST_SNAP_ONLY:
{
interpolationBehavior = USE_INTERPOLATION;
break;
}
default:
{
break;
}
}
}
/*
================
idEntity::ServerSendEvent
Saved events are also sent to any client that connects late so all clients
always receive the events nomatter what time they join the game.
================
*/
void idEntity::ServerSendEvent( int eventId, const idBitMsg* msg, bool saveEvent, lobbyUserID_t excluding ) const
{
idBitMsg outMsg;
byte msgBuf[MAX_GAME_MESSAGE_SIZE];
if( !common->IsServer() )
{
return;
}
// prevent dupe events caused by frame re-runs
if( !gameLocal.isNewFrame )
{
return;
}
outMsg.InitWrite( msgBuf, sizeof( msgBuf ) );
outMsg.BeginWriting();
outMsg.WriteBits( gameLocal.GetSpawnId( this ), 32 );
outMsg.WriteByte( eventId );
outMsg.WriteLong( gameLocal.time );
if( msg )
{
outMsg.WriteBits( msg->GetSize(), idMath::BitsForInteger( MAX_EVENT_PARAM_SIZE ) );
outMsg.WriteData( msg->GetReadData(), msg->GetSize() );
}
else
{
outMsg.WriteBits( 0, idMath::BitsForInteger( MAX_EVENT_PARAM_SIZE ) );
}
idLobbyBase& lobby = session->GetActingGameStateLobbyBase();
peerMask_t peerMask = MAX_UNSIGNED_TYPE( peerMask_t );
if( excluding.IsValid() )
{
peerMask = ~( peerMask_t )lobby.PeerIndexFromLobbyUser( excluding );
}
lobby.SendReliable( GAME_RELIABLE_MESSAGE_EVENT, outMsg, false, peerMask );
if( saveEvent )
{
gameLocal.SaveEntityNetworkEvent( this, eventId, msg );
}
}
/*
================
idEntity::ClientSendEvent
================
*/
void idEntity::ClientSendEvent( int eventId, const idBitMsg* msg ) const
{
idBitMsg outMsg;
byte msgBuf[MAX_GAME_MESSAGE_SIZE];
if( !common->IsClient() )
{
return;
}
// prevent dupe events caused by frame re-runs
if( !gameLocal.isNewFrame )
{
return;
}
outMsg.InitWrite( msgBuf, sizeof( msgBuf ) );
outMsg.BeginWriting();
outMsg.WriteBits( gameLocal.GetSpawnId( this ), 32 );
outMsg.WriteByte( eventId );
outMsg.WriteLong( gameLocal.serverTime );
if( msg )
{
outMsg.WriteBits( msg->GetSize(), idMath::BitsForInteger( MAX_EVENT_PARAM_SIZE ) );
outMsg.WriteData( msg->GetReadData(), msg->GetSize() );
}
else
{
outMsg.WriteBits( 0, idMath::BitsForInteger( MAX_EVENT_PARAM_SIZE ) );
}
session->GetActingGameStateLobbyBase().SendReliableToHost( GAME_RELIABLE_MESSAGE_EVENT, outMsg );
}
/*
================
idEntity::ServerReceiveEvent
================
*/
bool idEntity::ServerReceiveEvent( int event, int time, const idBitMsg& msg )
{
switch( event )
{
case 0:
{
}
default:
{
return false;
}
}
}
/*
================
idEntity::ClientReceiveEvent
================
*/
bool idEntity::ClientReceiveEvent( int event, int time, const idBitMsg& msg )
{
int index;
const idSoundShader* shader;
s_channelType channel;
switch( event )
{
case EVENT_STARTSOUNDSHADER:
{
// the sound stuff would early out
assert( gameLocal.isNewFrame );
if( time < gameLocal.realClientTime - 1000 )
{
// too old, skip it ( reliable messages don't need to be parsed in full )
common->DPrintf( "ent 0x%x: start sound shader too old (%d ms)\n", entityNumber, gameLocal.realClientTime - time );
return true;
}
index = gameLocal.ClientRemapDecl( DECL_SOUND, msg.ReadLong() );
if( index >= 0 && index < declManager->GetNumDecls( DECL_SOUND ) )
{
shader = declManager->SoundByIndex( index, false );
channel = ( s_channelType )msg.ReadByte();
StartSoundShader( shader, channel, 0, false, NULL );
}
return true;
}
case EVENT_STOPSOUNDSHADER:
{
// the sound stuff would early out
assert( gameLocal.isNewFrame );
channel = ( s_channelType )msg.ReadByte();
StopSound( channel, false );
return true;
}
default:
{
return false;
}
}
}
/*
================
idEntity::DetermineTimeGroup
================
*/
void idEntity::DetermineTimeGroup( bool slowmo )
{
if( slowmo || common->IsMultiplayer() )
{
timeGroup = TIME_GROUP1;
}
else
{
timeGroup = TIME_GROUP2;
}
}
/*
================
idEntity::SetGrabbedState
================
*/
void idEntity::SetGrabbedState( bool grabbed )
{
fl.grabbed = grabbed;
}
/*
================
idEntity::IsGrabbed
================
*/
bool idEntity::IsGrabbed()
{
return fl.grabbed;
}
/*
========================
idEntity::DecayOriginAndAxisDelta
========================
*/
void idEntity::DecayOriginAndAxisDelta()
{
idVec3 delta = vec3_zero - originDelta;
float length = delta.Length();
if( length > 0.01f )
{
length *= net_errorSmoothingDecay.GetFloat();
if( length > net_errorSmoothingMaxDecay.GetFloat() )
{
length = net_errorSmoothingMaxDecay.GetFloat();
}
delta.Normalize();
delta *= length;
originDelta += delta;
}
else
{
originDelta = vec3_zero;
}
idQuat q;
q.Slerp( axisDelta.ToQuat(), mat3_identity.ToQuat(), net_errorSmoothingDecay.GetFloat() );
axisDelta = q.ToMat3();
}
/*
========================
idEntity::CreateDeltasFromOldOriginAndAxis
========================
*/
void idEntity::CreateDeltasFromOldOriginAndAxis( const idVec3& oldOrigin, const idMat3& oldAxis )
{
// Set smooth values so we transition from the old position/axis to what we are now (visual only)
if( GetPhysics() )
{
originDelta = oldOrigin - GetPhysics()->GetOrigin();
axisDelta = oldAxis.Inverse() * GetPhysics()->GetAxis();
}
}
/*
===============================================================================
idAnimatedEntity
===============================================================================
*/
const idEventDef EV_GetJointHandle( "getJointHandle", "s", 'd' );
const idEventDef EV_ClearAllJoints( "clearAllJoints" );
const idEventDef EV_ClearJoint( "clearJoint", "d" );
const idEventDef EV_SetJointPos( "setJointPos", "ddv" );
const idEventDef EV_SetJointAngle( "setJointAngle", "ddv" );
const idEventDef EV_GetJointPos( "getJointPos", "d", 'v' );
const idEventDef EV_GetJointAngle( "getJointAngle", "d", 'v' );
CLASS_DECLARATION( idEntity, idAnimatedEntity )
EVENT( EV_GetJointHandle, idAnimatedEntity::Event_GetJointHandle )
EVENT( EV_ClearAllJoints, idAnimatedEntity::Event_ClearAllJoints )
EVENT( EV_ClearJoint, idAnimatedEntity::Event_ClearJoint )
EVENT( EV_SetJointPos, idAnimatedEntity::Event_SetJointPos )
EVENT( EV_SetJointAngle, idAnimatedEntity::Event_SetJointAngle )
EVENT( EV_GetJointPos, idAnimatedEntity::Event_GetJointPos )
EVENT( EV_GetJointAngle, idAnimatedEntity::Event_GetJointAngle )
END_CLASS
/*
================
idAnimatedEntity::idAnimatedEntity
================
*/
idAnimatedEntity::idAnimatedEntity()
{
animator.SetEntity( this );
damageEffects = NULL;
}
/*
================
idAnimatedEntity::~idAnimatedEntity
================
*/
idAnimatedEntity::~idAnimatedEntity()
{
damageEffect_t* de;
for( de = damageEffects; de; de = damageEffects )
{
damageEffects = de->next;
delete de;
}
}
/*
================
idAnimatedEntity::Save
archives object for save game file
================
*/
void idAnimatedEntity::Save( idSaveGame* savefile ) const
{
animator.Save( savefile );
// Wounds are very temporary, ignored at this time
//damageEffect_t *damageEffects;
}
/*
================
idAnimatedEntity::Restore
unarchives object from save game file
================
*/
void idAnimatedEntity::Restore( idRestoreGame* savefile )
{
animator.Restore( savefile );
// check if the entity has an MD5 model
if( animator.ModelHandle() )
{
// set the callback to update the joints
renderEntity.callback = idEntity::ModelCallback;
animator.GetJoints( &renderEntity.numJoints, &renderEntity.joints );
animator.GetBounds( gameLocal.time, renderEntity.bounds );
if( modelDefHandle != -1 )
{
gameRenderWorld->UpdateEntityDef( modelDefHandle, &renderEntity );
}
}
}
/*
================
idAnimatedEntity::ClientPredictionThink
================
*/
void idAnimatedEntity::ClientPredictionThink()
{
RunPhysics();
UpdateAnimation();
Present();
}
/*
================
idAnimatedEntity::ClientThink
================
*/
void idAnimatedEntity::ClientThink( const int curTime, const float fraction, const bool predict )
{
InterpolatePhysics( fraction );
UpdateAnimation();
Present();
}
/*
================
idAnimatedEntity::Think
================
*/
void idAnimatedEntity::Think()
{
RunPhysics();
UpdateAnimation();
Present();
UpdateDamageEffects();
}
/*
================
idAnimatedEntity::UpdateAnimation
================
*/
void idAnimatedEntity::UpdateAnimation()
{
// don't do animations if they're not enabled
if( !( thinkFlags & TH_ANIMATE ) )
{
return;
}
// is the model an MD5?
if( !animator.ModelHandle() )
{
// no, so nothing to do
return;
}
// call any frame commands that have happened in the past frame
if( !fl.hidden )
{
animator.ServiceAnims( gameLocal.previousTime, gameLocal.time );
}
// if the model is animating then we have to update it
if( !animator.FrameHasChanged( gameLocal.time ) )
{
// still fine the way it was
return;
}
// get the latest frame bounds
animator.GetBounds( gameLocal.time, renderEntity.bounds );
if( renderEntity.bounds.IsCleared() && !fl.hidden )
{
gameLocal.DPrintf( "%d: inside out bounds\n", gameLocal.time );
}
// update the renderEntity
UpdateVisuals();
// the animation is updated
animator.ClearForceUpdate();
}
/*
================
idAnimatedEntity::GetAnimator
================
*/
idAnimator* idAnimatedEntity::GetAnimator()
{
return &animator;
}
/*
================
idAnimatedEntity::SetModel
================
*/
void idAnimatedEntity::SetModel( const char* modelname )
{
FreeModelDef();
renderEntity.hModel = animator.SetModel( modelname );
if( !renderEntity.hModel )
{
idEntity::SetModel( modelname );
return;
}
if( !renderEntity.customSkin )
{
renderEntity.customSkin = animator.ModelDef()->GetDefaultSkin();
}
// set the callback to update the joints
renderEntity.callback = idEntity::ModelCallback;
animator.GetJoints( &renderEntity.numJoints, &renderEntity.joints );
animator.GetBounds( gameLocal.time, renderEntity.bounds );
UpdateVisuals();
}
/*
=====================
idAnimatedEntity::GetJointWorldTransform
=====================
*/
bool idAnimatedEntity::GetJointWorldTransform( jointHandle_t jointHandle, int currentTime, idVec3& offset, idMat3& axis )
{
if( !animator.GetJointTransform( jointHandle, currentTime, offset, axis ) )
{
return false;
}
ConvertLocalToWorldTransform( offset, axis );
return true;
}
/*
==============
idAnimatedEntity::GetJointTransformForAnim
==============
*/
bool idAnimatedEntity::GetJointTransformForAnim( jointHandle_t jointHandle, int animNum, int frameTime, idVec3& offset, idMat3& axis ) const
{
const idAnim* anim;
int numJoints;
idJointMat* frame;
anim = animator.GetAnim( animNum );
if( !anim )
{
assert( 0 );
return false;
}
numJoints = animator.NumJoints();
if( ( jointHandle < 0 ) || ( jointHandle >= numJoints ) )
{
assert( 0 );
return false;
}
frame = ( idJointMat* )_alloca16( numJoints * sizeof( idJointMat ) );
gameEdit->ANIM_CreateAnimFrame( animator.ModelHandle(), anim->MD5Anim( 0 ), renderEntity.numJoints, frame, frameTime, animator.ModelDef()->GetVisualOffset(), animator.RemoveOrigin() );
offset = frame[ jointHandle ].ToVec3();
axis = frame[ jointHandle ].ToMat3();
return true;
}
/*
==============
idAnimatedEntity::AddDamageEffect
Dammage effects track the animating impact position, spitting out particles.
==============
*/
void idAnimatedEntity::AddDamageEffect( const trace_t& collision, const idVec3& velocity, const char* damageDefName )
{
jointHandle_t jointNum;
idVec3 origin, dir, localDir, localOrigin, localNormal;
idMat3 axis;
if( !g_bloodEffects.GetBool() || renderEntity.joints == NULL )
{
return;
}
const idDeclEntityDef* def = gameLocal.FindEntityDef( damageDefName, false );
if( def == NULL )
{
return;
}
jointNum = CLIPMODEL_ID_TO_JOINT_HANDLE( collision.c.id );
if( jointNum == INVALID_JOINT )
{
return;
}
dir = velocity;
dir.Normalize();
axis = renderEntity.joints[jointNum].ToMat3() * renderEntity.axis;
origin = renderEntity.origin + renderEntity.joints[jointNum].ToVec3() * renderEntity.axis;
localOrigin = ( collision.c.point - origin ) * axis.Transpose();
localNormal = collision.c.normal * axis.Transpose();
localDir = dir * axis.Transpose();
AddLocalDamageEffect( jointNum, localOrigin, localNormal, localDir, def, collision.c.material );
}
/*
==============
idAnimatedEntity::GetDefaultSurfaceType
==============
*/
int idAnimatedEntity::GetDefaultSurfaceType() const
{
return SURFTYPE_METAL;
}
/*
==============
idAnimatedEntity::AddLocalDamageEffect
==============
*/
void idAnimatedEntity::AddLocalDamageEffect( jointHandle_t jointNum, const idVec3& localOrigin, const idVec3& localNormal, const idVec3& localDir, const idDeclEntityDef* def, const idMaterial* collisionMaterial )
{
const char* sound, *splat, *decal, *bleed, *key;
damageEffect_t* de;
idVec3 origin, dir;
idMat3 axis;
SetTimeState ts( timeGroup );
axis = renderEntity.joints[jointNum].ToMat3() * renderEntity.axis;
origin = renderEntity.origin + renderEntity.joints[jointNum].ToVec3() * renderEntity.axis;
origin = origin + localOrigin * axis;
dir = localDir * axis;
int type = collisionMaterial->GetSurfaceType();
if( type == SURFTYPE_NONE )
{
type = GetDefaultSurfaceType();
}
const char* materialType = gameLocal.sufaceTypeNames[ type ];
// start impact sound based on material type
key = va( "snd_%s", materialType );
sound = spawnArgs.GetString( key );
if( *sound == '\0' )
{
sound = def->dict.GetString( key );
}
if( *sound != '\0' )
{
StartSoundShader( declManager->FindSound( sound ), SND_CHANNEL_BODY, 0, false, NULL );
}
// blood splats are thrown onto nearby surfaces
key = va( "mtr_splat_%s", materialType );
splat = spawnArgs.RandomPrefix( key, gameLocal.random );
if( *splat == '\0' )
{
splat = def->dict.RandomPrefix( key, gameLocal.random );
}
if( *splat != '\0' )
{
gameLocal.BloodSplat( origin, dir, 64.0f, splat );
}
// can't see wounds on the player model in single player mode
if( !( IsType( idPlayer::Type ) && !common->IsMultiplayer() ) )
{
// place a wound overlay on the model
key = va( "mtr_wound_%s", materialType );
decal = spawnArgs.RandomPrefix( key, gameLocal.random );
if( *decal == '\0' )
{
decal = def->dict.RandomPrefix( key, gameLocal.random );
}
if( *decal != '\0' )
{
ProjectOverlay( origin, dir, 20.0f, decal );
}
}
// a blood spurting wound is added
key = va( "smoke_wound_%s", materialType );
bleed = spawnArgs.GetString( key );
if( *bleed == '\0' )
{
bleed = def->dict.GetString( key );
}
if( *bleed != '\0' )
{
de = new( TAG_ENTITY ) damageEffect_t;
de->next = this->damageEffects;
this->damageEffects = de;
de->jointNum = jointNum;
de->localOrigin = localOrigin;
de->localNormal = localNormal;
de->type = static_cast( declManager->FindType( DECL_PARTICLE, bleed ) );
de->time = gameLocal.time;
}
}
/*
==============
idAnimatedEntity::UpdateDamageEffects
==============
*/
void idAnimatedEntity::UpdateDamageEffects()
{
damageEffect_t* de, **prev;
// free any that have timed out
prev = &this->damageEffects;
while( *prev )
{
de = *prev;
if( de->time == 0 ) // FIXME:SMOKE
{
*prev = de->next;
delete de;
}
else
{
prev = &de->next;
}
}
if( !g_bloodEffects.GetBool() )
{
return;
}
// emit a particle for each bleeding wound
for( de = this->damageEffects; de; de = de->next )
{
idVec3 origin, start;
idMat3 axis;
animator.GetJointTransform( de->jointNum, gameLocal.time, origin, axis );
axis *= renderEntity.axis;
origin = renderEntity.origin + origin * renderEntity.axis;
start = origin + de->localOrigin * axis;
if( !gameLocal.smokeParticles->EmitSmoke( de->type, de->time, gameLocal.random.CRandomFloat(), start, axis, timeGroup /*_D3XP*/ ) )
{
de->time = 0;
}
}
}
/*
================
idAnimatedEntity::ClientReceiveEvent
================
*/
bool idAnimatedEntity::ClientReceiveEvent( int event, int time, const idBitMsg& msg )
{
int damageDefIndex;
int materialIndex;
jointHandle_t jointNum;
idVec3 localOrigin, localNormal, localDir;
switch( event )
{
case EVENT_ADD_DAMAGE_EFFECT:
{
jointNum = ( jointHandle_t ) msg.ReadShort();
localOrigin[0] = msg.ReadFloat();
localOrigin[1] = msg.ReadFloat();
localOrigin[2] = msg.ReadFloat();
localNormal = msg.ReadDir( 24 );
localDir = msg.ReadDir( 24 );
damageDefIndex = gameLocal.ClientRemapDecl( DECL_ENTITYDEF, msg.ReadLong() );
materialIndex = gameLocal.ClientRemapDecl( DECL_MATERIAL, msg.ReadLong() );
const idDeclEntityDef* damageDef = static_cast( declManager->DeclByIndex( DECL_ENTITYDEF, damageDefIndex ) );
const idMaterial* collisionMaterial = static_cast( declManager->DeclByIndex( DECL_MATERIAL, materialIndex ) );
AddLocalDamageEffect( jointNum, localOrigin, localNormal, localDir, damageDef, collisionMaterial );
return true;
}
default:
{
return idEntity::ClientReceiveEvent( event, time, msg );
}
}
}
/*
================
idAnimatedEntity::Event_GetJointHandle
looks up the number of the specified joint. returns INVALID_JOINT if the joint is not found.
================
*/
void idAnimatedEntity::Event_GetJointHandle( const char* jointname )
{
jointHandle_t joint;
joint = animator.GetJointHandle( jointname );
idThread::ReturnInt( joint );
}
/*
================
idAnimatedEntity::Event_ClearAllJoints
removes any custom transforms on all joints
================
*/
void idAnimatedEntity::Event_ClearAllJoints()
{
animator.ClearAllJoints();
}
/*
================
idAnimatedEntity::Event_ClearJoint
removes any custom transforms on the specified joint
================
*/
void idAnimatedEntity::Event_ClearJoint( jointHandle_t jointnum )
{
animator.ClearJoint( jointnum );
}
/*
================
idAnimatedEntity::Event_SetJointPos
modifies the position of the joint based on the transform type
================
*/
void idAnimatedEntity::Event_SetJointPos( jointHandle_t jointnum, jointModTransform_t transform_type, const idVec3& pos )
{
animator.SetJointPos( jointnum, transform_type, pos );
}
/*
================
idAnimatedEntity::Event_SetJointAngle
modifies the orientation of the joint based on the transform type
================
*/
void idAnimatedEntity::Event_SetJointAngle( jointHandle_t jointnum, jointModTransform_t transform_type, const idAngles& angles )
{
idMat3 mat;
mat = angles.ToMat3();
animator.SetJointAxis( jointnum, transform_type, mat );
}
/*
================
idAnimatedEntity::Event_GetJointPos
returns the position of the joint in worldspace
================
*/
void idAnimatedEntity::Event_GetJointPos( jointHandle_t jointnum )
{
idVec3 offset;
idMat3 axis;
if( !GetJointWorldTransform( jointnum, gameLocal.time, offset, axis ) )
{
gameLocal.Warning( "Joint # %d out of range on entity '%s'", jointnum, name.c_str() );
}
idThread::ReturnVector( offset );
}
/*
================
idAnimatedEntity::Event_GetJointAngle
returns the orientation of the joint in worldspace
================
*/
void idAnimatedEntity::Event_GetJointAngle( jointHandle_t jointnum )
{
idVec3 offset;
idMat3 axis;
if( !GetJointWorldTransform( jointnum, gameLocal.time, offset, axis ) )
{
gameLocal.Warning( "Joint # %d out of range on entity '%s'", jointnum, name.c_str() );
}
idAngles ang = axis.ToAngles();
idVec3 vec( ang[ 0 ], ang[ 1 ], ang[ 2 ] );
idThread::ReturnVector( vec );
}