mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-12-11 13:11:47 +00:00
1270 lines
24 KiB
C++
1270 lines
24 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.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#pragma hdrstop
|
|
#include "../../idlib/precompiled.h"
|
|
|
|
|
|
#include "../Game_local.h"
|
|
|
|
CLASS_DECLARATION( idPhysics, idPhysics_StaticMulti )
|
|
END_CLASS
|
|
|
|
staticPState_t defaultState;
|
|
staticInterpolatePState_t defaultInterpolateState;
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::idPhysics_StaticMulti
|
|
================
|
|
*/
|
|
idPhysics_StaticMulti::idPhysics_StaticMulti()
|
|
{
|
|
self = NULL;
|
|
hasMaster = false;
|
|
isOrientated = false;
|
|
|
|
defaultState.origin.Zero();
|
|
defaultState.axis.Identity();
|
|
defaultState.localOrigin.Zero();
|
|
defaultState.localAxis.Identity();
|
|
|
|
defaultInterpolateState.origin.Zero();
|
|
defaultInterpolateState.axis = defaultState.axis.ToQuat();
|
|
defaultInterpolateState.localAxis = defaultInterpolateState.axis;
|
|
defaultInterpolateState.localOrigin.Zero();
|
|
|
|
current.SetNum( 1 );
|
|
current[0] = defaultState;
|
|
previous.SetNum( 1 );
|
|
previous[0] = defaultInterpolateState;
|
|
next.SetNum( 1 );
|
|
next[0] = defaultInterpolateState;
|
|
clipModels.SetNum( 1 );
|
|
clipModels[0] = NULL;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::~idPhysics_StaticMulti
|
|
================
|
|
*/
|
|
idPhysics_StaticMulti::~idPhysics_StaticMulti()
|
|
{
|
|
if( self && self->GetPhysics() == this )
|
|
{
|
|
self->SetPhysics( NULL );
|
|
}
|
|
idForce::DeletePhysics( this );
|
|
for( int i = 0; i < clipModels.Num(); i++ )
|
|
{
|
|
delete clipModels[i];
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::Save
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::Save( idSaveGame* savefile ) const
|
|
{
|
|
int i;
|
|
|
|
savefile->WriteObject( self );
|
|
|
|
savefile->WriteInt( current.Num() );
|
|
for( i = 0; i < current.Num(); i++ )
|
|
{
|
|
savefile->WriteVec3( current[i].origin );
|
|
savefile->WriteMat3( current[i].axis );
|
|
savefile->WriteVec3( current[i].localOrigin );
|
|
savefile->WriteMat3( current[i].localAxis );
|
|
}
|
|
|
|
savefile->WriteInt( clipModels.Num() );
|
|
for( i = 0; i < clipModels.Num(); i++ )
|
|
{
|
|
savefile->WriteClipModel( clipModels[i] );
|
|
}
|
|
|
|
savefile->WriteBool( hasMaster );
|
|
savefile->WriteBool( isOrientated );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::Restore
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::Restore( idRestoreGame* savefile )
|
|
{
|
|
int i, num;
|
|
|
|
savefile->ReadObject( reinterpret_cast<idClass*&>( self ) );
|
|
|
|
savefile->ReadInt( num );
|
|
current.AssureSize( num );
|
|
for( i = 0; i < num; i++ )
|
|
{
|
|
savefile->ReadVec3( current[i].origin );
|
|
savefile->ReadMat3( current[i].axis );
|
|
savefile->ReadVec3( current[i].localOrigin );
|
|
savefile->ReadMat3( current[i].localAxis );
|
|
}
|
|
|
|
savefile->ReadInt( num );
|
|
clipModels.SetNum( num );
|
|
for( i = 0; i < num; i++ )
|
|
{
|
|
savefile->ReadClipModel( clipModels[i] );
|
|
}
|
|
|
|
savefile->ReadBool( hasMaster );
|
|
savefile->ReadBool( isOrientated );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::SetSelf
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::SetSelf( idEntity* e )
|
|
{
|
|
assert( e );
|
|
self = e;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::RemoveIndex
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::RemoveIndex( int id, bool freeClipModel )
|
|
{
|
|
if( id < 0 || id >= clipModels.Num() )
|
|
{
|
|
return;
|
|
}
|
|
if( clipModels[id] && freeClipModel )
|
|
{
|
|
delete clipModels[id];
|
|
clipModels[id] = NULL;
|
|
}
|
|
clipModels.RemoveIndex( id );
|
|
current.RemoveIndex( id );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::SetClipModel
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::SetClipModel( idClipModel* model, float density, int id, bool freeOld )
|
|
{
|
|
int i;
|
|
|
|
assert( self );
|
|
|
|
if( id >= clipModels.Num() )
|
|
{
|
|
current.AssureSize( id + 1, defaultState );
|
|
clipModels.AssureSize( id + 1, NULL );
|
|
}
|
|
|
|
if( clipModels[id] && clipModels[id] != model && freeOld )
|
|
{
|
|
delete clipModels[id];
|
|
}
|
|
clipModels[id] = model;
|
|
if( clipModels[id] )
|
|
{
|
|
clipModels[id]->Link( gameLocal.clip, self, id, current[id].origin, current[id].axis );
|
|
|
|
}
|
|
|
|
for( i = clipModels.Num() - 1; i >= 1; i-- )
|
|
{
|
|
if( clipModels[i] )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
current.SetNum( i + 1 );
|
|
clipModels.SetNum( i + 1 );
|
|
|
|
// Assure that on first setup, our next/previous is the same as current.
|
|
previous.SetNum( current.Num() );
|
|
next.SetNum( previous.Num() );
|
|
for( int curIdx = 0; curIdx < current.Num(); curIdx++ )
|
|
{
|
|
previous[curIdx] = ConvertPStateToInterpolateState( current[curIdx] );
|
|
previous[curIdx] = next[curIdx];
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetClipModel
|
|
================
|
|
*/
|
|
idClipModel* idPhysics_StaticMulti::GetClipModel( int id ) const
|
|
{
|
|
if( id >= 0 && id < clipModels.Num() && clipModels[id] )
|
|
{
|
|
return clipModels[id];
|
|
}
|
|
return gameLocal.clip.DefaultClipModel();
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetNumClipModels
|
|
================
|
|
*/
|
|
int idPhysics_StaticMulti::GetNumClipModels() const
|
|
{
|
|
return clipModels.Num();
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::SetMass
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::SetMass( float mass, int id )
|
|
{
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetMass
|
|
================
|
|
*/
|
|
float idPhysics_StaticMulti::GetMass( int id ) const
|
|
{
|
|
return 0.0f;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::SetContents
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::SetContents( int contents, int id )
|
|
{
|
|
int i;
|
|
|
|
if( id >= 0 && id < clipModels.Num() )
|
|
{
|
|
if( clipModels[id] )
|
|
{
|
|
clipModels[id]->SetContents( contents );
|
|
}
|
|
}
|
|
else if( id == -1 )
|
|
{
|
|
for( i = 0; i < clipModels.Num(); i++ )
|
|
{
|
|
if( clipModels[i] )
|
|
{
|
|
clipModels[i]->SetContents( contents );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetContents
|
|
================
|
|
*/
|
|
int idPhysics_StaticMulti::GetContents( int id ) const
|
|
{
|
|
int i, contents = 0;
|
|
|
|
if( id >= 0 && id < clipModels.Num() )
|
|
{
|
|
if( clipModels[id] )
|
|
{
|
|
contents = clipModels[id]->GetContents();
|
|
}
|
|
}
|
|
else if( id == -1 )
|
|
{
|
|
for( i = 0; i < clipModels.Num(); i++ )
|
|
{
|
|
if( clipModels[i] )
|
|
{
|
|
contents |= clipModels[i]->GetContents();
|
|
}
|
|
}
|
|
}
|
|
return contents;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::SetClipMask
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::SetClipMask( int mask, int id )
|
|
{
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetClipMask
|
|
================
|
|
*/
|
|
int idPhysics_StaticMulti::GetClipMask( int id ) const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetBounds
|
|
================
|
|
*/
|
|
const idBounds& idPhysics_StaticMulti::GetBounds( int id ) const
|
|
{
|
|
int i;
|
|
static idBounds bounds;
|
|
|
|
if( id >= 0 && id < clipModels.Num() )
|
|
{
|
|
if( clipModels[id] )
|
|
{
|
|
return clipModels[id]->GetBounds();
|
|
}
|
|
}
|
|
if( id == -1 )
|
|
{
|
|
bounds.Clear();
|
|
for( i = 0; i < clipModels.Num(); i++ )
|
|
{
|
|
if( clipModels[i] )
|
|
{
|
|
bounds.AddBounds( clipModels[i]->GetAbsBounds() );
|
|
}
|
|
}
|
|
for( i = 0; i < clipModels.Num(); i++ )
|
|
{
|
|
if( clipModels[i] )
|
|
{
|
|
bounds[0] -= clipModels[i]->GetOrigin();
|
|
bounds[1] -= clipModels[i]->GetOrigin();
|
|
break;
|
|
}
|
|
}
|
|
return bounds;
|
|
}
|
|
return bounds_zero;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetAbsBounds
|
|
================
|
|
*/
|
|
const idBounds& idPhysics_StaticMulti::GetAbsBounds( int id ) const
|
|
{
|
|
int i;
|
|
static idBounds absBounds;
|
|
|
|
if( id >= 0 && id < clipModels.Num() )
|
|
{
|
|
if( clipModels[id] )
|
|
{
|
|
return clipModels[id]->GetAbsBounds();
|
|
}
|
|
}
|
|
if( id == -1 )
|
|
{
|
|
absBounds.Clear();
|
|
for( i = 0; i < clipModels.Num(); i++ )
|
|
{
|
|
if( clipModels[i] )
|
|
{
|
|
absBounds.AddBounds( clipModels[i]->GetAbsBounds() );
|
|
}
|
|
}
|
|
return absBounds;
|
|
}
|
|
return bounds_zero;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::Evaluate
|
|
================
|
|
*/
|
|
bool idPhysics_StaticMulti::Evaluate( int timeStepMSec, int endTimeMSec )
|
|
{
|
|
int i;
|
|
idVec3 masterOrigin;
|
|
idMat3 masterAxis;
|
|
|
|
if( hasMaster )
|
|
{
|
|
self->GetMasterPosition( masterOrigin, masterAxis );
|
|
for( i = 0; i < clipModels.Num(); i++ )
|
|
{
|
|
current[i].origin = masterOrigin + current[i].localOrigin * masterAxis;
|
|
if( isOrientated )
|
|
{
|
|
current[i].axis = current[i].localAxis * masterAxis;
|
|
}
|
|
else
|
|
{
|
|
current[i].axis = current[i].localAxis;
|
|
}
|
|
if( clipModels[i] )
|
|
{
|
|
clipModels[i]->Link( gameLocal.clip, self, i, current[i].origin, current[i].axis );
|
|
}
|
|
}
|
|
|
|
// FIXME: return false if master did not move
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::Interpolate
|
|
================
|
|
*/
|
|
bool idPhysics_StaticMulti::Interpolate( const float fraction )
|
|
{
|
|
// If the sizes don't match, just use the latest version.
|
|
// TODO: This might cause visual snapping, is there a better solution?
|
|
if( current.Num() != previous.Num() ||
|
|
current.Num() != next.Num() )
|
|
{
|
|
current.SetNum( next.Num() );
|
|
for( int i = 0; i < next.Num(); ++i )
|
|
{
|
|
current[i] = InterpolateStaticPState( next[i], next[i], 1.0f );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
for( int i = 0; i < current.Num(); ++i )
|
|
{
|
|
current[i] = InterpolateStaticPState( previous[i], next[i], fraction );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::UpdateTime
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::UpdateTime( int endTimeMSec )
|
|
{
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetTime
|
|
================
|
|
*/
|
|
int idPhysics_StaticMulti::GetTime() const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetImpactInfo
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::GetImpactInfo( const int id, const idVec3& point, impactInfo_t* info ) const
|
|
{
|
|
memset( info, 0, sizeof( *info ) );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::ApplyImpulse
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::ApplyImpulse( const int id, const idVec3& point, const idVec3& impulse )
|
|
{
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::AddForce
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::AddForce( const int id, const idVec3& point, const idVec3& force )
|
|
{
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::Activate
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::Activate()
|
|
{
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::PutToRest
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::PutToRest()
|
|
{
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::IsAtRest
|
|
================
|
|
*/
|
|
bool idPhysics_StaticMulti::IsAtRest() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetRestStartTime
|
|
================
|
|
*/
|
|
int idPhysics_StaticMulti::GetRestStartTime() const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::IsPushable
|
|
================
|
|
*/
|
|
bool idPhysics_StaticMulti::IsPushable() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::SaveState
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::SaveState()
|
|
{
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::RestoreState
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::RestoreState()
|
|
{
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::SetOrigin
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::SetOrigin( const idVec3& newOrigin, int id )
|
|
{
|
|
idVec3 masterOrigin;
|
|
idMat3 masterAxis;
|
|
|
|
if( id >= 0 && id < clipModels.Num() )
|
|
{
|
|
current[id].localOrigin = newOrigin;
|
|
if( hasMaster )
|
|
{
|
|
self->GetMasterPosition( masterOrigin, masterAxis );
|
|
current[id].origin = masterOrigin + newOrigin * masterAxis;
|
|
}
|
|
else
|
|
{
|
|
current[id].origin = newOrigin;
|
|
}
|
|
if( clipModels[id] )
|
|
{
|
|
clipModels[id]->Link( gameLocal.clip, self, id, current[id].origin, current[id].axis );
|
|
}
|
|
}
|
|
else if( id == -1 )
|
|
{
|
|
if( hasMaster )
|
|
{
|
|
self->GetMasterPosition( masterOrigin, masterAxis );
|
|
Translate( masterOrigin + masterAxis * newOrigin - current[0].origin );
|
|
}
|
|
else
|
|
{
|
|
Translate( newOrigin - current[0].origin );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::SetAxis
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::SetAxis( const idMat3& newAxis, int id )
|
|
{
|
|
idVec3 masterOrigin;
|
|
idMat3 masterAxis;
|
|
|
|
if( id >= 0 && id < clipModels.Num() )
|
|
{
|
|
current[id].localAxis = newAxis;
|
|
if( hasMaster && isOrientated )
|
|
{
|
|
self->GetMasterPosition( masterOrigin, masterAxis );
|
|
current[id].axis = newAxis * masterAxis;
|
|
}
|
|
else
|
|
{
|
|
current[id].axis = newAxis;
|
|
}
|
|
if( clipModels[id] )
|
|
{
|
|
clipModels[id]->Link( gameLocal.clip, self, id, current[id].origin, current[id].axis );
|
|
}
|
|
}
|
|
else if( id == -1 )
|
|
{
|
|
idMat3 axis;
|
|
idRotation rotation;
|
|
|
|
if( hasMaster )
|
|
{
|
|
self->GetMasterPosition( masterOrigin, masterAxis );
|
|
axis = current[0].axis.Transpose() * ( newAxis * masterAxis );
|
|
}
|
|
else
|
|
{
|
|
axis = current[0].axis.Transpose() * newAxis;
|
|
}
|
|
rotation = axis.ToRotation();
|
|
rotation.SetOrigin( current[0].origin );
|
|
|
|
Rotate( rotation );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::Translate
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::Translate( const idVec3& translation, int id )
|
|
{
|
|
int i;
|
|
|
|
if( id >= 0 && id < clipModels.Num() )
|
|
{
|
|
current[id].localOrigin += translation;
|
|
current[id].origin += translation;
|
|
|
|
if( clipModels[id] )
|
|
{
|
|
clipModels[id]->Link( gameLocal.clip, self, id, current[id].origin, current[id].axis );
|
|
}
|
|
}
|
|
else if( id == -1 )
|
|
{
|
|
for( i = 0; i < clipModels.Num(); i++ )
|
|
{
|
|
current[i].localOrigin += translation;
|
|
current[i].origin += translation;
|
|
|
|
if( clipModels[i] )
|
|
{
|
|
clipModels[i]->Link( gameLocal.clip, self, i, current[i].origin, current[i].axis );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::Rotate
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::Rotate( const idRotation& rotation, int id )
|
|
{
|
|
int i;
|
|
idVec3 masterOrigin;
|
|
idMat3 masterAxis;
|
|
|
|
if( id >= 0 && id < clipModels.Num() )
|
|
{
|
|
current[id].origin *= rotation;
|
|
current[id].axis *= rotation.ToMat3();
|
|
|
|
if( hasMaster )
|
|
{
|
|
self->GetMasterPosition( masterOrigin, masterAxis );
|
|
current[id].localAxis *= rotation.ToMat3();
|
|
current[id].localOrigin = ( current[id].origin - masterOrigin ) * masterAxis.Transpose();
|
|
}
|
|
else
|
|
{
|
|
current[id].localAxis = current[id].axis;
|
|
current[id].localOrigin = current[id].origin;
|
|
}
|
|
|
|
if( clipModels[id] )
|
|
{
|
|
clipModels[id]->Link( gameLocal.clip, self, id, current[id].origin, current[id].axis );
|
|
}
|
|
}
|
|
else if( id == -1 )
|
|
{
|
|
for( i = 0; i < clipModels.Num(); i++ )
|
|
{
|
|
current[i].origin *= rotation;
|
|
current[i].axis *= rotation.ToMat3();
|
|
|
|
if( hasMaster )
|
|
{
|
|
self->GetMasterPosition( masterOrigin, masterAxis );
|
|
current[i].localAxis *= rotation.ToMat3();
|
|
current[i].localOrigin = ( current[i].origin - masterOrigin ) * masterAxis.Transpose();
|
|
}
|
|
else
|
|
{
|
|
current[i].localAxis = current[i].axis;
|
|
current[i].localOrigin = current[i].origin;
|
|
}
|
|
|
|
if( clipModels[i] )
|
|
{
|
|
clipModels[i]->Link( gameLocal.clip, self, i, current[i].origin, current[i].axis );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetOrigin
|
|
================
|
|
*/
|
|
const idVec3& idPhysics_StaticMulti::GetOrigin( int id ) const
|
|
{
|
|
if( id >= 0 && id < clipModels.Num() )
|
|
{
|
|
return current[id].origin;
|
|
}
|
|
if( clipModels.Num() )
|
|
{
|
|
return current[0].origin;
|
|
}
|
|
else
|
|
{
|
|
return vec3_origin;
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetAxis
|
|
================
|
|
*/
|
|
const idMat3& idPhysics_StaticMulti::GetAxis( int id ) const
|
|
{
|
|
if( id >= 0 && id < clipModels.Num() )
|
|
{
|
|
return current[id].axis;
|
|
}
|
|
if( clipModels.Num() )
|
|
{
|
|
return current[0].axis;
|
|
}
|
|
else
|
|
{
|
|
return mat3_identity;
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::SetLinearVelocity
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::SetLinearVelocity( const idVec3& newLinearVelocity, int id )
|
|
{
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::SetAngularVelocity
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::SetAngularVelocity( const idVec3& newAngularVelocity, int id )
|
|
{
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetLinearVelocity
|
|
================
|
|
*/
|
|
const idVec3& idPhysics_StaticMulti::GetLinearVelocity( int id ) const
|
|
{
|
|
return vec3_origin;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetAngularVelocity
|
|
================
|
|
*/
|
|
const idVec3& idPhysics_StaticMulti::GetAngularVelocity( int id ) const
|
|
{
|
|
return vec3_origin;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::SetGravity
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::SetGravity( const idVec3& newGravity )
|
|
{
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetGravity
|
|
================
|
|
*/
|
|
const idVec3& idPhysics_StaticMulti::GetGravity() const
|
|
{
|
|
static idVec3 gravity( 0, 0, -g_gravity.GetFloat() );
|
|
return gravity;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetGravityNormal
|
|
================
|
|
*/
|
|
const idVec3& idPhysics_StaticMulti::GetGravityNormal() const
|
|
{
|
|
static idVec3 gravity( 0, 0, -1 );
|
|
return gravity;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::ClipTranslation
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::ClipTranslation( trace_t& results, const idVec3& translation, const idClipModel* model ) const
|
|
{
|
|
memset( &results, 0, sizeof( trace_t ) );
|
|
gameLocal.Warning( "idPhysics_StaticMulti::ClipTranslation called" );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::ClipRotation
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::ClipRotation( trace_t& results, const idRotation& rotation, const idClipModel* model ) const
|
|
{
|
|
memset( &results, 0, sizeof( trace_t ) );
|
|
gameLocal.Warning( "idPhysics_StaticMulti::ClipRotation called" );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::ClipContents
|
|
================
|
|
*/
|
|
int idPhysics_StaticMulti::ClipContents( const idClipModel* model ) const
|
|
{
|
|
int i, contents;
|
|
|
|
contents = 0;
|
|
for( i = 0; i < clipModels.Num(); i++ )
|
|
{
|
|
if( clipModels[i] )
|
|
{
|
|
if( model )
|
|
{
|
|
contents |= gameLocal.clip.ContentsModel( clipModels[i]->GetOrigin(), clipModels[i], clipModels[i]->GetAxis(), -1,
|
|
model->Handle(), model->GetOrigin(), model->GetAxis() );
|
|
}
|
|
else
|
|
{
|
|
contents |= gameLocal.clip.Contents( clipModels[i]->GetOrigin(), clipModels[i], clipModels[i]->GetAxis(), -1, NULL );
|
|
}
|
|
}
|
|
}
|
|
return contents;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::DisableClip
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::DisableClip()
|
|
{
|
|
int i;
|
|
|
|
for( i = 0; i < clipModels.Num(); i++ )
|
|
{
|
|
if( clipModels[i] )
|
|
{
|
|
clipModels[i]->Disable();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::EnableClip
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::EnableClip()
|
|
{
|
|
int i;
|
|
|
|
for( i = 0; i < clipModels.Num(); i++ )
|
|
{
|
|
if( clipModels[i] )
|
|
{
|
|
clipModels[i]->Enable();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::UnlinkClip
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::UnlinkClip()
|
|
{
|
|
int i;
|
|
|
|
for( i = 0; i < clipModels.Num(); i++ )
|
|
{
|
|
if( clipModels[i] )
|
|
{
|
|
clipModels[i]->Unlink();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::LinkClip
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::LinkClip()
|
|
{
|
|
int i;
|
|
|
|
for( i = 0; i < clipModels.Num(); i++ )
|
|
{
|
|
if( clipModels[i] )
|
|
{
|
|
clipModels[i]->Link( gameLocal.clip, self, i, current[i].origin, current[i].axis );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::EvaluateContacts
|
|
================
|
|
*/
|
|
bool idPhysics_StaticMulti::EvaluateContacts()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetNumContacts
|
|
================
|
|
*/
|
|
int idPhysics_StaticMulti::GetNumContacts() const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetContact
|
|
================
|
|
*/
|
|
const contactInfo_t& idPhysics_StaticMulti::GetContact( int num ) const
|
|
{
|
|
static contactInfo_t info;
|
|
memset( &info, 0, sizeof( info ) );
|
|
return info;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::ClearContacts
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::ClearContacts()
|
|
{
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::AddContactEntity
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::AddContactEntity( idEntity* e )
|
|
{
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::RemoveContactEntity
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::RemoveContactEntity( idEntity* e )
|
|
{
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::HasGroundContacts
|
|
================
|
|
*/
|
|
bool idPhysics_StaticMulti::HasGroundContacts() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::IsGroundEntity
|
|
================
|
|
*/
|
|
bool idPhysics_StaticMulti::IsGroundEntity( int entityNum ) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::IsGroundClipModel
|
|
================
|
|
*/
|
|
bool idPhysics_StaticMulti::IsGroundClipModel( int entityNum, int id ) const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::SetPushed
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::SetPushed( int deltaTime )
|
|
{
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetPushedLinearVelocity
|
|
================
|
|
*/
|
|
const idVec3& idPhysics_StaticMulti::GetPushedLinearVelocity( const int id ) const
|
|
{
|
|
return vec3_origin;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetPushedAngularVelocity
|
|
================
|
|
*/
|
|
const idVec3& idPhysics_StaticMulti::GetPushedAngularVelocity( const int id ) const
|
|
{
|
|
return vec3_origin;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::SetMaster
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::SetMaster( idEntity* master, const bool orientated )
|
|
{
|
|
int i;
|
|
idVec3 masterOrigin;
|
|
idMat3 masterAxis;
|
|
|
|
if( master )
|
|
{
|
|
if( !hasMaster )
|
|
{
|
|
// transform from world space to master space
|
|
self->GetMasterPosition( masterOrigin, masterAxis );
|
|
for( i = 0; i < clipModels.Num(); i++ )
|
|
{
|
|
current[i].localOrigin = ( current[i].origin - masterOrigin ) * masterAxis.Transpose();
|
|
if( orientated )
|
|
{
|
|
current[i].localAxis = current[i].axis * masterAxis.Transpose();
|
|
}
|
|
else
|
|
{
|
|
current[i].localAxis = current[i].axis;
|
|
}
|
|
}
|
|
hasMaster = true;
|
|
isOrientated = orientated;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( hasMaster )
|
|
{
|
|
hasMaster = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetBlockingInfo
|
|
================
|
|
*/
|
|
const trace_t* idPhysics_StaticMulti::GetBlockingInfo() const
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetBlockingEntity
|
|
================
|
|
*/
|
|
idEntity* idPhysics_StaticMulti::GetBlockingEntity() const
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetLinearEndTime
|
|
================
|
|
*/
|
|
int idPhysics_StaticMulti::GetLinearEndTime() const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::GetAngularEndTime
|
|
================
|
|
*/
|
|
int idPhysics_StaticMulti::GetAngularEndTime() const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::WriteToSnapshot
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::WriteToSnapshot( idBitMsg& msg ) const
|
|
{
|
|
int i;
|
|
idCQuat quat, localQuat;
|
|
|
|
msg.WriteByte( current.Num() );
|
|
|
|
for( i = 0; i < current.Num(); i++ )
|
|
{
|
|
quat = current[i].axis.ToCQuat();
|
|
localQuat = current[i].localAxis.ToCQuat();
|
|
|
|
msg.WriteFloat( current[i].origin[0] );
|
|
msg.WriteFloat( current[i].origin[1] );
|
|
msg.WriteFloat( current[i].origin[2] );
|
|
msg.WriteFloat( quat.x );
|
|
msg.WriteFloat( quat.y );
|
|
msg.WriteFloat( quat.z );
|
|
msg.WriteDeltaFloat( current[i].origin[0], current[i].localOrigin[0] );
|
|
msg.WriteDeltaFloat( current[i].origin[1], current[i].localOrigin[1] );
|
|
msg.WriteDeltaFloat( current[i].origin[2], current[i].localOrigin[2] );
|
|
msg.WriteDeltaFloat( quat.x, localQuat.x );
|
|
msg.WriteDeltaFloat( quat.y, localQuat.y );
|
|
msg.WriteDeltaFloat( quat.z, localQuat.z );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idPhysics_StaticMulti::ReadFromSnapshot
|
|
================
|
|
*/
|
|
void idPhysics_StaticMulti::ReadFromSnapshot( const idBitMsg& msg )
|
|
{
|
|
int i, num;
|
|
idCQuat quat, localQuat;
|
|
|
|
num = msg.ReadByte();
|
|
assert( num == current.Num() );
|
|
|
|
previous = next;
|
|
|
|
next.SetNum( num );
|
|
|
|
for( i = 0; i < current.Num(); i++ )
|
|
{
|
|
next[i] = ReadStaticInterpolatePStateFromSnapshot( msg );
|
|
}
|
|
}
|