// Handles the WM_KEYDOWN message
LRESULT CApplication::OnKeyDown(WPARAM wParam)
{
LRESULT lr = 0;
if (_state == CApplication::VIEW_STATE::ZOOMEDOUT)
{
if (wParam == '1' && _currentVisual != 0)
{
lr = UpdateVisuals(_currentVisual, 0);
_currentVisual = 0;
}
else if (wParam == '2' && _currentVisual != 1)
{
lr = UpdateVisuals(_currentVisual, 1);
_currentVisual = 1;
}
else if (wParam == '3' && _currentVisual != 2)
{
lr = UpdateVisuals(_currentVisual, 2);
_currentVisual = 2;
}
else if (wParam == '4' && _currentVisual != 3)
{
lr = UpdateVisuals(_currentVisual, 3);
_currentVisual = 3;
}
}
return lr;
}
/*
================
rvEffect::UpdateChangeableSpawnArgs
================
*/
void rvEffect::UpdateChangeableSpawnArgs( const idDict *source ) {
const char* fx;
const idDecl *newEffect;
bool newLoop;
idEntity::UpdateChangeableSpawnArgs(source);
if ( !source ) {
return;
}
if ( source->GetString ( "fx", "", &fx ) && *fx ) {
newEffect = ( const idDecl * )declManager->FindEffect( fx );
} else {
newEffect = NULL;
}
idVec3 color;
source->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[ SHADERPARM_ALPHA ] = source->GetFloat ( "_alpha", "1" );
renderEntity.shaderParms[ SHADERPARM_BRIGHTNESS ] = source->GetFloat ( "_brightness", "1" );
if ( clientEffect ) {
clientEffect->SetColor ( idVec4(color[0],color[1],color[2],renderEntity.shaderParms[ SHADERPARM_ALPHA ]) );
clientEffect->SetBrightness ( renderEntity.shaderParms[ SHADERPARM_BRIGHTNESS ] );
}
source->GetBool ( "loop", "0", newLoop );
spawnArgs.Copy( *source );
// IF the effect handle has changed or the loop status has changed then restart the effect
if ( newEffect != effect || loop != newLoop ) {
Stop ( false );
loop = newLoop;
effect = newEffect;
if ( effect ) {
Play ( );
BecomeActive( TH_THINK );
UpdateVisuals();
} else {
BecomeInactive ( TH_THINK );
UpdateVisuals();
}
}
}
void idTrembler::Arm( void )
{
if ( !itemEnt.IsValid() )
{
idStr itemName = spawnArgs.GetString( "itemname", "" );
if ( itemName.Length() )
{
itemEnt = gameLocal.FindEntity( itemName );
if (!itemEnt.IsValid())
{
common->Warning("idTrembler %s couldn't find item '%s'.", name.c_str(), itemName.c_str());
}
}
else
{
common->Warning("idTrembler %s has no 'itemname' value.", name.c_str());
}
}
if (itemEnt.IsValid())
{
itemOriginalPosition = itemEnt.GetEntity()->GetPhysics()->GetOrigin();
}
state = 0;
renderEntity.shaderParms[ SHADERPARM_RED ] = 1;
renderEntity.shaderParms[ SHADERPARM_GREEN ] = 1;
renderEntity.shaderParms[ SHADERPARM_BLUE ] = 0;
UpdateVisuals();
}
void hhFuncEmitter::ReadFromSnapshot( const idBitMsgDelta &msg ) {
renderEntity.shaderParms[ SHADERPARM_PARTICLE_STOPTIME ] = msg.ReadFloat();
renderEntity.shaderParms[ SHADERPARM_TIMEOFFSET ] = msg.ReadFloat();
if ( msg.HasChanged() ) {
UpdateVisuals();
}
}
void hhShuttleForceField::ReadFromSnapshot( const idBitMsgDelta &msg ) {
int contents = msg.ReadBits(32);
if (contents != GetPhysics()->GetContents()) {
GetPhysics()->SetContents(contents);
}
nextCollideFxTime = msg.ReadBits(32);
fieldState = (States)msg.ReadBits(8);
fade.SetStartTime(msg.ReadFloat());
fade.SetDuration(msg.ReadFloat());
fade.SetStartValue(msg.ReadFloat());
fade.SetEndValue(msg.ReadFloat());
float f;
bool changed = false;
f = msg.ReadFloat();
changed = (changed || (renderEntity.shaderParms[SHADERPARM_TIMEOFFSET] != f));
renderEntity.shaderParms[SHADERPARM_TIMEOFFSET] = f;
f = msg.ReadFloat();
changed = (changed || (renderEntity.shaderParms[SHADERPARM_MODE] != f));
renderEntity.shaderParms[SHADERPARM_MODE] = f;
if (changed) {
UpdateVisuals();
}
}
END_CLASS
/*
==============
sdSnowEffect::Spawn
==============
*/
void sdSnowEffect::Spawn( void ) {
renderEntity_t *re = GetRenderEntity();
re->numInsts = MAX_GROUPS;
re->insts = new sdInstInfo[ re->numInsts ];
idVec3 zero;
idMat3 I;
zero.Zero();
I.Identity();
this->SetPosition( zero, I );
idBounds modelbb = re->hModel->Bounds();
idVec3 extents = (modelbb.GetMaxs() - modelbb.GetMins()) * 0.5f;
idPlayer *p = gameLocal.GetLocalViewPlayer();
idVec3 const &v = p->GetViewPos();
for (int i=0; i<MAX_GROUPS; i++) {
groups[i].time = -1.f;
}
BecomeActive( TH_THINK );
UpdateVisuals();
}
/*
================
idSecurityCamera::SetAlertMode
================
*/
void idSecurityCamera::SetAlertMode( int alert ) {
if( alert >= SCANNING && alert <= ACTIVATED ) {
alertMode = alert;
}
renderEntity.shaderParms[ SHADERPARM_MODE ] = alertMode;
UpdateVisuals();
}
/*
================
idExplodingBarrel::Event_Respawn
================
*/
void idExplodingBarrel::Event_Respawn() {
int i;
int minRespawnDist = spawnArgs.GetInt( "respawn_range", "256" );
if ( minRespawnDist ) {
float minDist = -1;
for ( i = 0; i < gameLocal.numClients; i++ ) {
if ( !gameLocal.entities[ i ] || !gameLocal.entities[ i ]->IsType( idPlayer::Type ) ) {
continue;
}
idVec3 v = gameLocal.entities[ i ]->GetPhysics()->GetOrigin() - GetPhysics()->GetOrigin();
float dist = v.Length();
if ( minDist < 0 || dist < minDist ) {
minDist = dist;
}
}
if ( minDist < minRespawnDist ) {
PostEventSec( &EV_Respawn, spawnArgs.GetInt( "respawn_again", "10" ) );
return;
}
}
const char *temp = spawnArgs.GetString( "model" );
if ( temp && *temp ) {
SetModel( temp );
}
health = spawnArgs.GetInt( "health", "5" );
fl.takedamage = true;
physicsObj.SetOrigin( spawnOrigin );
physicsObj.SetAxis( spawnAxis );
physicsObj.SetContents( CONTENTS_SOLID );
physicsObj.DropToFloor();
state = NORMAL;
Show();
UpdateVisuals();
}
/*
==============
sdRainEffect::Think
==============
*/
void sdRainEffect::Think( void ) {
renderEntity_t *re = GetRenderEntity();
if ( re->hModel == NULL ) {
return;
}
idBounds modelbb = re->hModel->Bounds();
idVec3 extents = (modelbb.GetMaxs() - modelbb.GetMins()) * 0.5f;
idPlayer *p = gameLocal.GetLocalViewPlayer();
idVec3 const &v = p->GetViewPos();
int gridx = idMath::Ftoi( idMath::Floor(v.x / extents.x) );
int gridy = idMath::Ftoi( idMath::Floor(v.y / extents.y) );
idBounds bounds;
bounds.Clear();
sdInstInfo *inst = re->insts;
for (int y=-1; y<=1; y++) {
for (int x=-1; x<=1; x++) {
idBounds bb2;
inst->fadeOrigin = inst->inst.origin = idVec3( (x + gridx) * extents.x, (y + gridy) * extents.y, v.z );
inst->inst.axis.Identity();
inst->maxVisDist = 0;
inst->minVisDist = 0.f;
bb2 = modelbb.Translate( inst->inst.origin );
bounds.AddBounds( bb2 );
inst++;
}
}
re->flags.overridenBounds = true;
re->bounds = bounds;
UpdateVisuals();
Present();
}
/*
============
sdGeneralMover::StartTimedMove
============
*/
void sdGeneralMover::StartTimedMove( int from, int to, int ms, int startTime ) {
if( from < 0 || from >= _positions.Num() || to < 0 || to >= _positions.Num() ) {
gameLocal.Warning( "sdGeneralMover: one or more index out of range: from = %d, to = %d", from, to );
return;
}
_curMove.startPos = from;
_curMove.endPos = to;
_curMove.moveTime = ms;
_curMove.startTime = startTime;
_physicsObj.StartMove( _positions[ _curMove.startPos ].pos, _positions[ _curMove.endPos ].pos,
_positions[ _curMove.startPos ].angles, _positions[ _curMove.endPos ].angles, _curMove.startTime, _curMove.moveTime );
if ( gameLocal.isServer ) {
sdEntityBroadcastEvent event( this, EVENT_MOVE );
event.WriteLong( _curMove.startPos );
event.WriteLong( _curMove.endPos );
event.WriteLong( _curMove.moveTime );
event.WriteLong( _curMove.startTime );
event.Send( true, sdReliableMessageClientInfoAll() );
}
UpdateVisuals();
}
/*
======================
idMoveableItem::ReadFromSnapshot
======================
*/
void idMoveableItem::ReadFromSnapshot(const idBitMsgDelta &msg)
{
physicsObj.ReadFromSnapshot(msg);
if (msg.HasChanged()) {
UpdateVisuals();
}
}
/*
============
sdGeneralMover::Event_SetPosition
============
*/
void sdGeneralMover::Event_SetPosition( int index ) {
if( index < 0 || index >= _positions.Num() ) {
gameLocal.Warning( "sdGeneralMover::Event_SetPosition: index out of range: %d", index );
return;
}
StartTimedMove( index, index, 0, gameLocal.time );
UpdateVisuals();
}
/*
================
sdWalker::Spawn
================
*/
void sdWalker::Spawn( void ) {
animator.RemoveOriginOffset( true );
animator.ClearAllAnims( gameLocal.time, 0 );
animator.ClearAllJoints();
int anim = animator.GetAnim( "base" );
animator.PlayAnim( ANIMCHANNEL_TORSO, anim, gameLocal.time, 0 );
animator.CreateFrame( gameLocal.time, true );
LoadAF();
LoadVehicleScript();
if ( !spawnArgs.GetBool( "ik_disabled", "0" ) ) {
LoadIK();
}
physicsObj.SetSelf( this );
physicsObj.SetClipModel( new idClipModel( GetPhysics()->GetClipModel() ), 1.0f );
physicsObj.SetMass( spawnArgs.GetFloat( "mass", "10000" ) );
physicsObj.SetClipMask( MASK_VEHICLESOLID | CONTENTS_WALKERCLIP | CONTENTS_MONSTER );
// move up to make sure the monster is at least an epsilon above the floor
physicsObj.SetOrigin( GetPhysics()->GetOrigin() + idVec3( 0, 0, CM_CLIP_EPSILON ) );
physicsObj.SetAxis( mat3_identity );
idVec3 gravity = spawnArgs.GetVector( "gravityDir", "0 0 -1" );
float gravityScale;
if ( spawnArgs.GetFloat( "gravity", DEFAULT_GRAVITY_STRING, gravityScale ) ) {
gravity *= gravityScale;
} else {
gravity *= g_gravity.GetFloat();
}
physicsObj.SetGravity( gravity );
SetPhysics( &physicsObj );
BecomeActive( TH_THINK );
physicsObj.SetMaxStepHeight( spawnArgs.GetFloat( "ik_maxStepSpeed", "1" ) );
physicsObj.SetContents( CONTENTS_MONSTER );
stompDamage = gameLocal.declDamageType[ spawnArgs.GetString( "dmg_stomp" ) ];
minStompScale = spawnArgs.GetFloat( "stomp_min_scale" );
maxStompScale = spawnArgs.GetFloat( "stomp_max_scale" );
stompSpeedScale = spawnArgs.GetFloat( "stomp_speed_scale" );
groundPoundMinSpeed = spawnArgs.GetFloat( "ground_pound_min_speed", "200" );
groundPoundForce = spawnArgs.GetFloat( "ground_pound_force", "25000000" );
groundPoundRange = spawnArgs.GetFloat( "ground_pound_range", "512" );
kickForce = spawnArgs.GetFloat( "kick_force", "25000000" );
UpdateVisuals();
Present();
}
/*
================
idLight::BecomeBroken
================
*/
void idLight::BecomeBroken( idEntity *activator ) {
const char *damageDefName;
fl.takedamage = false;
if ( brokenModel.Length() ) {
SetModel( brokenModel );
if ( !spawnArgs.GetBool( "nonsolid" ) ) {
GetPhysics()->SetClipModel( new idClipModel( brokenModel.c_str() ), 1.0f );
GetPhysics()->SetContents( CONTENTS_SOLID );
}
} else if ( spawnArgs.GetBool( "hideModelOnBreak" ) ) {
SetModel( "" );
GetPhysics()->SetContents( 0 );
}
if ( gameLocal.isServer ) {
ServerSendEvent( EVENT_BECOMEBROKEN, NULL, true, -1 );
if ( spawnArgs.GetString( "def_damage", "", &damageDefName ) ) {
idVec3 origin = renderEntity.origin + renderEntity.bounds.GetCenter() * renderEntity.axis;
gameLocal.RadiusDamage( origin, activator, activator, this, this, damageDefName );
}
}
ActivateTargets( activator );
// offset the start time of the shader to sync it to the game time
renderEntity.shaderParms[ SHADERPARM_TIMEOFFSET ] = -MS2SEC( gameLocal.time );
renderLight.shaderParms[ SHADERPARM_TIMEOFFSET ] = -MS2SEC( gameLocal.time );
// set the state parm
renderEntity.shaderParms[ SHADERPARM_MODE ] = 1;
renderLight.shaderParms[ SHADERPARM_MODE ] = 1;
// if the light has a sound, either start the alternate (broken) sound, or stop the sound
const char *parm = spawnArgs.GetString( "snd_broken" );
if ( refSound.shader || ( parm && *parm ) ) {
StopSound( SND_CHANNEL_ANY, false );
const idSoundShader *alternate = refSound.shader ? refSound.shader->GetAltSound() : declManager->FindSound( parm );
if ( alternate ) {
// start it with no diversity, so the leadin break sound plays
refSound.referenceSound->StartSound( alternate, SND_CHANNEL_ANY, 0.0, 0 );
}
}
parm = spawnArgs.GetString( "mtr_broken" );
if ( parm && *parm ) {
SetShader( parm );
}
UpdateVisuals();
}
/*
=====================
sdWalker::SetAxis
=====================
*/
void sdWalker::SetAxis( const idMat3& axis ) {
viewAxis = axis;
if ( vehicleControl ) {
idAngles angles = axis.ToAngles();
vehicleControl->OnYawChanged( angles.yaw );
}
UpdateVisuals();
}
void hhProxDoorSection::ReadFromSnapshot( const idBitMsgDelta &msg ) {
ReadBindFromSnapshot(msg);
GetPhysics()->ReadFromSnapshot(msg);
if (msg.HasChanged()) {
Show();
UpdateVisuals();
Present();
GetPhysics()->LinkClip();
}
}
void hhControlHand::ClientPredictionThink( void ) {
RunPhysics();
// HUMANHEAD pdm
if (thinkFlags & TH_TICKER) {
Ticker();
}
UpdateAnimation();
UpdateVisuals();
Present();
}
/*
================
idLight::UpdateChangeableSpawnArgs
================
*/
void idLight::UpdateChangeableSpawnArgs( const idDict *source ) {
idEntity::UpdateChangeableSpawnArgs( source );
if( source ) {
source->Print();
}
FreeSoundEmitter( true );
gameEdit->ParseSpawnArgsToRefSound( source ? source : &spawnArgs, &refSound );
if( refSound.shader && !refSound.waitfortrigger ) {
StartSoundShader( refSound.shader, SND_CHANNEL_ANY, 0, false, NULL );
}
gameEdit->ParseSpawnArgsToRenderLight( source ? source : &spawnArgs, &renderLight );
UpdateVisuals();
}
/*
================
idExplodingBarrel::Event_Respawn
================
*/
void idExplodingBarrel::Event_Respawn() {
const char *temp = spawnArgs.GetString( "model" );
if ( temp && *temp ) {
SetModel( temp );
}
health = spawnArgs.GetInt( "health", "5" );
fl.takedamage = (health > 0);
physicsObj.SetOrigin( spawnOrigin );
physicsObj.SetAxis( spawnAxis );
physicsObj.SetContents( CONTENTS_SOLID );
physicsObj.DropToFloor();
state = NORMAL;
Show();
UpdateVisuals();
}
void hhFuncEmitter::Ticker() {
if( IsHidden() ) {
return;
}
if( particle && particleStartTime != -1 ) {
if( !gameLocal.smokeParticles->EmitSmoke(particle, particleStartTime, gameLocal.random.RandomFloat(), GetOrigin(), GetAxis()) ) {
particleStartTime = -1;
}
}
if( modelDefHandle != -1 ) {
renderEntity.origin = GetOrigin();
renderEntity.axis = GetAxis();
UpdateVisuals();
}
}
void idTrembler::Reset( void )
{
StopSound( SND_CHANNEL_ANY, false );
renderEntity.shaderParms[ SHADERPARM_RED ] = 0;
renderEntity.shaderParms[ SHADERPARM_GREEN ] = 0.7f;
renderEntity.shaderParms[ SHADERPARM_BLUE ] = 1;
UpdateVisuals();
state = -1;
int resettime = spawnArgs.GetInt("armtime");
Event_PlayAnim("idle", 1);
PostEventMS( &EV_TremblerArm, resettime ); //give a little delay to let physics settle the objects down.
}
/*
================
rvEffect::Think
================
*/
void rvEffect::Think( void ) {
if( clientEntities.IsListEmpty ( ) ) {
BecomeInactive( TH_THINK );
// Should the func_fx be removed now?
if( !(gameLocal.editors & EDITOR_FX) && spawnArgs.GetBool( "remove" ) ) {
PostEventMS( &EV_Remove, 0 );
}
return;
}
else if( lookAtTarget ) {
// If activated and looking at its target then update the target information
ProcessEvent( &EV_LookAtTarget );
}
UpdateVisuals();
Present ( );
}
void hhForceField::ReadFromSnapshot( const idBitMsgDelta &msg ) {
physicsObj.ReadFromSnapshot(msg);
damagedState = !!msg.ReadBits(1);
activationRate = msg.ReadFloat();
deactivationRate = msg.ReadFloat();
undamageFadeRate = msg.ReadFloat();
applyImpulseAttempts = msg.ReadBits(32);
cachedContents = msg.ReadBits(32);
fade = msg.ReadFloat();
nextCollideFxTime = msg.ReadBits(32);
fieldState = (States)msg.ReadBits(4);
bool hidden = !!msg.ReadBits(1);
if (IsHidden() != hidden) {
if (hidden) {
Hide();
SetSkinByName( spawnArgs.GetString("skin_off" ) );
GetPhysics()->SetContents( 0 );
}
else {
Show();
SetSkinByName( NULL );
GetPhysics()->SetContents( cachedContents );
}
}
float f;
bool changed = false;
f = msg.ReadFloat();
changed = (changed || (renderEntity.shaderParms[SHADERPARM_TIMEOFFSET] != f));
renderEntity.shaderParms[SHADERPARM_TIMEOFFSET] = f;
f = msg.ReadFloat();
changed = (changed || (renderEntity.shaderParms[SHADERPARM_MODE] != f));
renderEntity.shaderParms[SHADERPARM_MODE] = f;
if (changed) {
UpdateModel();
UpdateVisuals();
}
}
END_CLASS
void hhWallWalkable::Spawn( void ) {
wallwalkOn = spawnArgs.GetBool("active");
flicker = spawnArgs.GetBool("flicker");
// Get skin references (already precached)
onSkin = declManager->FindSkin( spawnArgs.GetString("skinOn") );
offSkin = declManager->FindSkin( spawnArgs.GetString("skinOff") );
if (wallwalkOn) {
SetSkin( onSkin );
alphaOn.Init(gameLocal.time, 0, 1.0f, 1.0f);
}
else {
SetSkin( offSkin );
alphaOn.Init(gameLocal.time, 0, 0.0f, 0.0f);
}
alphaOn.SetHermiteParms(WALLWALK_HERM_S1, WALLWALK_HERM_S2);
SetShaderParm(4, alphaOn.GetCurrentValue(gameLocal.time));
UpdateVisuals();
fl.networkSync = true;
}
END_CLASS
/*
==============
sdRainEffect::Spawn
==============
*/
void sdRainEffect::Spawn( void ) {
renderEntity_t *re = GetRenderEntity();
re->numInsts = 9;
re->insts = new sdInstInfo[ re->numInsts ];
idVec3 zero;
idMat3 I;
zero.Zero();
I.Identity();
this->SetPosition( zero, I );
BecomeActive( TH_THINK );
UpdateVisuals();
}
/*
================
idLight::Spawn
================
*/
void idLight::Spawn( void ) {
bool start_off;
bool needBroken;
const char *demonic_shader;
// do the parsing the same way dmap and the editor do
gameEdit->ParseSpawnArgsToRenderLight( &spawnArgs, &renderLight );
// we need the origin and axis relative to the physics origin/axis
localLightOrigin = ( renderLight.origin - GetPhysics()->GetOrigin() ) * GetPhysics()->GetAxis().Transpose();
localLightAxis = renderLight.axis * GetPhysics()->GetAxis().Transpose();
// set the base color from the shader parms
baseColor.Set( renderLight.shaderParms[ SHADERPARM_RED ], renderLight.shaderParms[ SHADERPARM_GREEN ], renderLight.shaderParms[ SHADERPARM_BLUE ] );
// set the number of light levels
spawnArgs.GetInt( "levels", "1", levels );
currentLevel = levels;
if ( levels <= 0 ) {
gameLocal.Error( "Invalid light level set on entity #%d(%s)", entityNumber, name.c_str() );
}
// make sure the demonic shader is cached
if ( spawnArgs.GetString( "mat_demonic", NULL, &demonic_shader ) ) {
declManager->FindType( DECL_MATERIAL, demonic_shader );
}
// game specific functionality, not mirrored in
// editor or dmap light parsing
// also put the light texture on the model, so light flares
// can get the current intensity of the light
renderEntity.referenceShader = renderLight.shader;
lightDefHandle = -1; // no static version yet
// see if an optimized shadow volume exists
// the renderer will ignore this value after a light has been moved,
// but there may still be a chance to get it wrong if the game moves
// a light before the first present, and doesn't clear the prelight
renderLight.prelightModel = 0;
if ( name[ 0 ] ) {
// this will return 0 if not found
renderLight.prelightModel = renderModelManager->CheckModel( va( "_prelight_%s", name.c_str() ) );
}
spawnArgs.GetBool( "start_off", "0", start_off );
if ( start_off ) {
Off();
}
health = spawnArgs.GetInt( "health", "0" );
spawnArgs.GetString( "broken", "", brokenModel );
spawnArgs.GetBool( "break", "0", breakOnTrigger );
spawnArgs.GetInt( "count", "1", count );
triggercount = 0;
fadeFrom.Set( 1, 1, 1, 1 );
fadeTo.Set( 1, 1, 1, 1 );
fadeStart = 0;
fadeEnd = 0;
// if we have a health make light breakable
if ( health ) {
idStr model = spawnArgs.GetString( "model" ); // get the visual model
if ( !model.Length() ) {
gameLocal.Error( "Breakable light without a model set on entity #%d(%s)", entityNumber, name.c_str() );
}
fl.takedamage = true;
// see if we need to create a broken model name
needBroken = true;
if ( model.Length() && !brokenModel.Length() ) {
int pos;
needBroken = false;
pos = model.Find( "." );
if ( pos < 0 ) {
pos = model.Length();
}
if ( pos > 0 ) {
model.Left( pos, brokenModel );
}
brokenModel += "_broken";
if ( pos > 0 ) {
brokenModel += &model[ pos ];
}
}
// make sure the model gets cached
if ( !renderModelManager->CheckModel( brokenModel ) ) {
if ( needBroken ) {
gameLocal.Error( "Model '%s' not found for entity %d(%s)", brokenModel.c_str(), entityNumber, name.c_str() );
} else {
brokenModel = "";
}
}
GetPhysics()->SetContents( spawnArgs.GetBool( "nonsolid" ) ? 0 : CONTENTS_SOLID );
// make sure the collision model gets cached
idClipModel::CheckModel( brokenModel );
}
PostEventMS( &EV_PostSpawn, 0 );
// sikk---> Soft Shadows PostProcess
// only put lights that cast shadows into the list
if ( spawnArgs.GetInt( "noshadows" ) == 0 ) {
gameLocal.currentLights.Append( entityNumber );
}
// <---sikk
UpdateVisuals();
}
/*
==============
sdSnowEffect::Think
==============
*/
void sdSnowEffect::Think( void ) {
renderEntity_t *re = GetRenderEntity();
if ( re->hModel == NULL ) {
return;
}
idBounds modelbb = re->hModel->Bounds();
idVec3 extents = (modelbb.GetMaxs() - modelbb.GetMins()) * 0.5f;
idPlayer *p = gameLocal.GetLocalViewPlayer();
idVec3 const &v = p->GetViewPos();
for (int i=0; i<MAX_GROUPS; i++) {
groups[i].time -= 1.f / 30.f;
if ( groups[i].time < 0.f ) {
groups[i].axis = idVec3( idRandom::StaticRandom().RandomFloat()- 0.15f , idRandom::StaticRandom().RandomFloat() - 0.5f , idRandom::StaticRandom().RandomFloat() - 0.5f );
groups[i].axis.z *= 40.25f;
groups[i].axis.Normalize();
groups[i].rotate = 0.f;
groups[i].rotateSpeed = idRandom::StaticRandom().RandomFloat() * 50.f + 50.f;
groups[i].rotationPoint = idVec3( idRandom::StaticRandom().RandomFloat() * extents.x,
idRandom::StaticRandom().RandomFloat() * extents.y,
idRandom::StaticRandom().RandomFloat() * extents.z );
groups[i].alpha = 0.f;
groups[i].time = idRandom::StaticRandom().RandomFloat() * 1.f + 1.f;
groups[i].worldPos = v + idVec3( (idRandom::StaticRandom().RandomFloat()-0.5f) * extents.x * 3,
(idRandom::StaticRandom().RandomFloat()-0.5f) * extents.y * 3,
(idRandom::StaticRandom().RandomFloat()-0.5f) * extents.z * 3 );
} else {
if ( groups[i].time > 0.25f ) {
groups[i].alpha += 1.f / 7.5f;
if ( groups[i].alpha > 1.f ) {
groups[i].alpha = 1.f;
}
} else {
groups[i].alpha = groups[i].time * 4.f;
if ( groups[i].alpha < 0.f ) {
groups[i].alpha = 0.f;
}
}
groups[i].worldPos += idVec3( 0.f, 0.f, -600.f ) * 1.f / 30.f;
groups[i].rotate += groups[i].rotateSpeed * 1.f / 30.f;
}
}
int gridx = idMath::Ftoi( idMath::Floor(v.x / extents.x) );
int gridy = idMath::Ftoi( idMath::Floor(v.y / extents.y) );
idBounds bounds;
bounds.Clear();
sdInstInfo *inst = re->insts;
for (int i=0; i<MAX_GROUPS; i++) {
idRotation r( groups[i].rotationPoint, groups[i].axis, groups[i].rotate );
idBounds bb2;
inst->inst.color[0] = 0xff;
inst->inst.color[1] = 0xff;
inst->inst.color[2] = 0xff;
inst->inst.color[3] = 0xff;
inst->fadeOrigin = inst->inst.origin = groups[i].worldPos;
inst->inst.axis = r.ToMat3();
inst->maxVisDist = 0;
inst->minVisDist = 0.f;
bb2.FromTransformedBounds( modelbb, inst->inst.origin, inst->inst.axis );
bounds.AddBounds( bb2 );
inst++;
}
re->flags.overridenBounds = true;
re->bounds = bounds;
UpdateVisuals();
Present();
}
/*
===========
hhForceField::Ticker
===========
*/
void hhForceField::Ticker( void ) {
if( fieldState == StatePreTurningOn ) {
idEntity* entityList[MAX_GENTITIES];
idEntity* entity = NULL;
idPhysics* physics = NULL;
int numEntities = 0;
int numEntitiesImpulseAppliedTo = 0;
idVec3 force = DetermineForce() * GetAxis();
numEntities = gameLocal.clip.EntitiesTouchingBounds( GetPhysics()->GetAbsBounds(), MASK_SOLID, entityList, MAX_GENTITIES );
for( int ix = 0; ix < numEntities; ++ix ) {
entity = entityList[ix];
if( !entity ) {
continue;
}
if( entity == this ) {
continue;
}
//Removing mass from any calculations regarding impulse
entity->ApplyImpulse( this, 0, entity->GetOrigin(), force * entity->GetPhysics()->GetMass() );
numEntitiesImpulseAppliedTo++;
}
--applyImpulseAttempts;
if( !numEntitiesImpulseAppliedTo || !applyImpulseAttempts ) {
fieldState = StateTurningOn;
GetPhysics()->SetContents( cachedContents );
SetSkin( NULL );
StartSound( "snd_start", SND_CHANNEL_ANY );
Show();
EnterTurningOnState();
}
} else if( fieldState == StateTurningOn ) {
float deltaTime = MS2SEC( gameLocal.msec );
renderEntity.shaderParms[SHADERPARM_TIMEOFFSET] += activationRate * deltaTime;
if( renderEntity.shaderParms[SHADERPARM_TIMEOFFSET] >= 1.0f ) {
EnterOnState();
}
UpdateVisuals();
} else if( fieldState == StateTurningOff ) {
float deltaTime = MS2SEC( gameLocal.msec );
renderEntity.shaderParms[SHADERPARM_TIMEOFFSET] -= deactivationRate * deltaTime;
if( renderEntity.shaderParms[SHADERPARM_TIMEOFFSET] <= 0.0f ) {
EnterOffState();
}
UpdateVisuals();
}
if( damagedState ) {
float deltaTime = MS2SEC( gameLocal.msec );
// Fade parm back to normal
fade -= undamageFadeRate * deltaTime;
if ( fade <= 0.0f ) { // Finished fading
fade = 0;
damagedState = false;
}
SetShaderParm( SHADERPARM_MODE, fade );
}
if (!damagedState && (fieldState==StateOn || fieldState==StateOff)) {
BecomeInactive( TH_TICKER );
}
}
void idTrembler::Event_Touch( idEntity *other, trace_t *trace )
{
if (state == 0)
{
idEntity *entityList[ MAX_GENTITIES ];
int i;
int flyforce;
state = 1;
Event_PlayAnim("bounce", 1);
StartSound( "snd_trigger", SND_CHANNEL_BODY, 0, false, NULL );
StartSound( "snd_trigger_idle", SND_CHANNEL_BODY2, 0, false, NULL );
ticksoundTime = gameLocal.time + (spawnArgs.GetInt("ticktime", "10") * 1000);
if (g_skill.GetInteger() > 0)
{
ActivateTargets(this); //activate alarm.
}
int listedEntities = gameLocal.EntitiesWithinRadius( GetPhysics()->GetOrigin(), FLYRADIUS, entityList, MAX_GENTITIES );
flyforce = spawnArgs.GetInt("force", "256");
renderEntity.shaderParms[ SHADERPARM_RED ] = 1;
renderEntity.shaderParms[ SHADERPARM_GREEN ] = 0;
renderEntity.shaderParms[ SHADERPARM_BLUE ] = 0;
UpdateVisuals();
//KA BOIIIIINNNGGGGGG
for (i = 0; i < listedEntities; i++)
{
idEntity *ent = entityList[ i ];
if (!ent)
{
continue;
}
float ent_zpos = ent->GetPhysics()->GetOrigin().z;
float trembler_zpos = this->GetPhysics()->GetOrigin().z;
//only affect things above the trembler.
if (ent_zpos < trembler_zpos)
continue;
//only affect things within X height of trembler.
if (ent_zpos > trembler_zpos + HEIGHT_MAX)
continue;
if ( !ent->IsType( idMoveableItem::Type ) && !ent->IsType( idMoveable::Type ) )
continue;
ent->GetPhysics()->SetLinearVelocity(idVec3(0,0,1) * flyforce);
}
}
}
void hhFuncEmitter::Event_Activate( idEntity *activator ) {
(IsHidden() || spawnArgs.GetBool("cycleTrigger")) ? Show() : Hide();
UpdateVisuals();
}
