mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-12-11 13:11:47 +00:00
9eeea7adf3
mostly -Wreorder, use const char* instead of char* for "static strings", fix inappropriate usage of NULL (e.g. instead of '\0' or (int)0)
6716 lines
144 KiB
C++
6716 lines
144 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
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 <http://www.gnu.org/licenses/>.
|
|
|
|
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( "<postspawn>", NULL );
|
|
const idEventDef EV_FindTargets( "<findTargets>", NULL );
|
|
const idEventDef EV_Touch( "<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( "<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( "<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<const idDeclModelDef*>( 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<idClass*&>( 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<idClass*&>( bindMaster ) );
|
|
savefile->ReadJoint( bindJoint );
|
|
savefile->ReadInt( bindBody );
|
|
savefile->ReadObject( reinterpret_cast<idClass*&>( teamMaster ) );
|
|
savefile->ReadObject( reinterpret_cast<idClass*&>( 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<idAFEntity_Base*>( 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<idAFEntity_Base*>( 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<idActor*>( this );
|
|
|
|
// set master delta angles for actors
|
|
if( GetBindMaster() )
|
|
{
|
|
idAngles delta = actor->GetDeltaViewAngles();
|
|
if( moveBack )
|
|
{
|
|
delta.yaw -= static_cast<idPhysics_Actor*>( physics )->GetMasterDeltaYaw();
|
|
}
|
|
else
|
|
{
|
|
delta.yaw += static_cast<idPhysics_Actor*>( 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<idActor*>( 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<const idDeclEmail*>( declManager->FindType( DECL_EMAIL, "highScore", false ) ) );
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
|
|
if( !token.Icmp( "martianbuddycomplete" ) )
|
|
{
|
|
gameLocal.GetLocalPlayer()->GiveEmail( static_cast<const idDeclEmail*>( 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<idVec3>* idEntity::GetSpline() const
|
|
{
|
|
int i, numPoints, t;
|
|
const idKeyValue* kv;
|
|
idLexer lex;
|
|
idVec3 v;
|
|
idCurve_Spline<idVec3>* 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<idVec3>();
|
|
}
|
|
else if( str.Icmp( "nubs" ) == 0 )
|
|
{
|
|
spline = new( TAG_ENTITY ) idCurve_NonUniformBSpline<idVec3>();
|
|
}
|
|
else if( str.Icmp( "nurbs" ) == 0 )
|
|
{
|
|
spline = new( TAG_ENTITY ) idCurve_NURBS<idVec3>();
|
|
}
|
|
else
|
|
{
|
|
spline = new( TAG_ENTITY ) idCurve_BSpline<idVec3>();
|
|
}
|
|
|
|
spline->SetBoundaryType( idCurve_Spline<idVec3>::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<idPhysics_Parametric*>( 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<const idDeclParticle*>( 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<const idDeclEntityDef*>( declManager->DeclByIndex( DECL_ENTITYDEF, damageDefIndex ) );
|
|
const idMaterial* collisionMaterial = static_cast<const idMaterial*>( 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 );
|
|
}
|