1134 lines
37 KiB
C++
1134 lines
37 KiB
C++
// Copyright (C) 2007 Id Software, Inc.
|
|
//
|
|
|
|
#ifndef __GAME_VEHICLE_COMPONENTS_H__
|
|
#define __GAME_VEHICLE_COMPONENTS_H__
|
|
|
|
#include "../effects/Effects.h"
|
|
#include "../effects/WaterEffects.h"
|
|
#include "VehicleSuspension.h"
|
|
#include "Transport.h"
|
|
|
|
|
|
class sdVehicle;
|
|
class sdVehicleInput;
|
|
class sdDeclVehiclePart;
|
|
class sdTransport_AF;
|
|
class sdDeclAFPart;
|
|
class sdDeclRigidBodyPart;
|
|
class sdDeclVehiclePartSimple;
|
|
class sdDeclRigidBodyWheel;
|
|
class sdDeclRigidBodyHover;
|
|
class sdDeclRigidBodyRotor;
|
|
class sdTransport;
|
|
class sdTransport_RB;
|
|
class sdVehicle_RigidBody;
|
|
class sdVehicleSuspension;
|
|
class sdVehicleRigidBodyVtol;
|
|
class sdVehicleRigidBodyAntiGrav;
|
|
class sdPhysics_RigidBodyMultiple;
|
|
|
|
class sdVehicleDriveObject : public idClass {
|
|
public:
|
|
CLASS_PROTOTYPE( sdVehicleDriveObject );
|
|
|
|
sdVehicleDriveObject( void );
|
|
virtual ~sdVehicleDriveObject( void );
|
|
virtual int GetBodyId( void ) = 0;
|
|
virtual void GetBounds( idBounds& bounds ) = 0;
|
|
virtual void UpdatePrePhysics( const sdVehicleInput& input ) = 0;
|
|
virtual void UpdatePostPhysics( const sdVehicleInput& input ) = 0;
|
|
virtual void GetWorldOrigin( idVec3& vec ) = 0;
|
|
virtual void GetWorldAxis( idMat3& axis ) = 0;
|
|
virtual void GetWorldPhysicsOrigin( idVec3& vec ) { GetWorldOrigin( vec ); }
|
|
virtual void GetWorldPhysicsAxis( idMat3& axis ) { GetWorldAxis( axis ); }
|
|
virtual void Detach( bool createDebris, bool decay ) = 0;
|
|
virtual void Reattach( void ) = 0;
|
|
virtual void Damage( int damage, idEntity *inflictor, idEntity *attacker, const idVec3 &dir, const trace_t* collision ) = 0;
|
|
virtual void Decay( void ) = 0;
|
|
virtual int Repair( int repair ) = 0;
|
|
virtual bool CanDamage( void ) = 0;
|
|
virtual const partDamageInfo_t* GetDamageInfo( void ) const = 0;
|
|
virtual int EvaluateContacts( contactInfo_t* list, contactInfoExt_t* listExt, int max ) { return 0; }
|
|
virtual int AddCustomConstraints( constraintInfo_t* list, int max ) { return 0; }
|
|
virtual void PostInit( void );
|
|
virtual bool UpdateSuspensionIK( void ) { return false; }
|
|
virtual void ClearSuspensionIK( void ) { ; }
|
|
|
|
virtual bool Mask( int mask ) const { return false; }
|
|
virtual bool DestroyFirst( void ) const { return false; }
|
|
virtual void CheckWater( const idVec3& waterBodyOrg, const idMat3& waterBodyAxis, idCollisionModel* waterBodyModel ) { ; }
|
|
virtual const sdDeclSurfaceType* GetSurfaceType( void ) const { return NULL; }
|
|
|
|
virtual sdTransport* GetParent( void ) const = 0;
|
|
|
|
virtual bool HasPhysics( void ) const { return false; }
|
|
|
|
bool IsHidden( void ) const { return hidden; }
|
|
void Hide( void );
|
|
void Show( void );
|
|
|
|
const char* Name( void ) const { return name; }
|
|
virtual idScriptObject* GetScriptObject( void ) const { return scriptObject; }
|
|
|
|
virtual void SetThrust( float thrust ) {};
|
|
|
|
|
|
virtual bool IsNetworked() { return false; }
|
|
virtual void ApplyNetworkState( networkStateMode_t mode, const sdEntityStateNetworkData& newState ) { ; }
|
|
virtual void ReadNetworkState( networkStateMode_t mode, const sdEntityStateNetworkData& baseState, sdEntityStateNetworkData& newState, const idBitMsg& msg ) const { ; }
|
|
virtual void WriteNetworkState( networkStateMode_t mode, const sdEntityStateNetworkData& baseState, sdEntityStateNetworkData& newState, idBitMsg& msg ) const { ; }
|
|
virtual bool CheckNetworkStateChanges( networkStateMode_t mode, const sdEntityStateNetworkData& baseState ) const { return false; }
|
|
virtual sdEntityStateNetworkData* CreateNetworkStructure( networkStateMode_t mode ) const { return NULL; }
|
|
|
|
|
|
virtual bool GoesInPartList() { return true; }
|
|
|
|
protected:
|
|
virtual void CreateExplosionDebris( void ) = 0;
|
|
virtual void CreateDecayDebris( void ) = 0;
|
|
|
|
bool hidden;
|
|
idScriptObject* scriptObject;
|
|
idStr name;
|
|
|
|
|
|
|
|
|
|
public:
|
|
// static stuff for scaling the amount of debris that can exist
|
|
enum debrisPriority_t {
|
|
PRIORITY_LOW = 0,
|
|
PRIORITY_MEDIUM,
|
|
PRIORITY_HIGH,
|
|
PRIORITY_EXTRA_HIGH
|
|
};
|
|
|
|
static bool CanAddDebris( debrisPriority_t priority, const idVec3& origin );
|
|
static void AddDebris( rvClientMoveable* debris, debrisPriority_t priority );
|
|
|
|
protected:
|
|
static const int MAX_DEBRIS = 128;
|
|
typedef idStaticList< rvClientEntityPtr< rvClientMoveable >, MAX_DEBRIS > debrisList_t;
|
|
|
|
static debrisList_t extraHighDebris;
|
|
static debrisList_t highDebris;
|
|
static debrisList_t mediumDebris;
|
|
static debrisList_t lowDebris;
|
|
};
|
|
|
|
class sdVehiclePart : public sdVehicleDriveObject {
|
|
public:
|
|
CLASS_PROTOTYPE( sdVehiclePart );
|
|
|
|
sdVehiclePart( void );
|
|
virtual ~sdVehiclePart( void );
|
|
|
|
void Init( const sdDeclVehiclePart& part );
|
|
virtual void OnKilled( void ) { }
|
|
|
|
void SetIndex( int _index ) { partIndex = _index; }
|
|
int GetIndex( void ) { return partIndex; }
|
|
void AddSurface( const char* surfaceName );
|
|
|
|
void HideSurfaces( void );
|
|
void ShowSurfaces( void );
|
|
|
|
virtual int GetBodyId( void ) { return bodyId; }
|
|
virtual void GetBounds( idBounds& bounds );
|
|
virtual void GetWorldOrigin( idVec3& vec );
|
|
virtual void GetWorldAxis( idMat3& axis );
|
|
virtual void UpdatePrePhysics( const sdVehicleInput& input ) { assert( false ); }
|
|
virtual void UpdatePostPhysics( const sdVehicleInput& input ) { }
|
|
virtual void Detach( bool createDebris, bool decay );
|
|
virtual void Reattach( void );
|
|
virtual void Damage( int damage, idEntity *inflictor, idEntity *attacker, const idVec3 &dir, const trace_t* collision );
|
|
virtual void Decay( void );
|
|
virtual int Repair( int repair );
|
|
virtual jointHandle_t GetJoint( void ) const { return INVALID_JOINT; }
|
|
virtual bool CanDamage( void ) { return health > 0; }
|
|
virtual const partDamageInfo_t* GetDamageInfo( void ) const { return &damageInfo; }
|
|
|
|
virtual void CheckWater( const idVec3& waterBodyOrg, const idMat3& waterBodyAxis, idCollisionModel* waterBodyModel );
|
|
virtual idBounds CalcSurfaceBounds( jointHandle_t joint );
|
|
virtual bool DestroyFirst( void ) const { return flipMaster; }
|
|
|
|
// Callable by scripts
|
|
void Event_GetHealth( void );
|
|
void Event_GetOrigin( void );
|
|
void Event_GetAngles( void );
|
|
void Event_GetParent( void );
|
|
void Event_GetJoint( void );
|
|
protected:
|
|
virtual void CreateExplosionDebris( void );
|
|
virtual void CreateDecayDebris( void );
|
|
|
|
int health;
|
|
int maxHealth;
|
|
int oldcontents;
|
|
int oldclipmask;
|
|
int bodyId;
|
|
idList< int > surfaces;
|
|
int partIndex;
|
|
partDamageInfo_t damageInfo;
|
|
const idDeclEntityDef* brokenPart;
|
|
idBounds partBounds;
|
|
sdWaterEffects* waterEffects;
|
|
bool noAutoHide;
|
|
|
|
float flipPower;
|
|
bool flipMaster;
|
|
int reattachTime;
|
|
};
|
|
|
|
class sdVehiclePartSimple : public sdVehiclePart {
|
|
public:
|
|
CLASS_PROTOTYPE( sdVehiclePartSimple );
|
|
|
|
virtual sdTransport* GetParent( void ) const { return parent; }
|
|
virtual jointHandle_t GetJoint( void ) const { return joint; }
|
|
void Init( const sdDeclVehiclePart& part, sdTransport* _parent );
|
|
virtual void GetWorldAxis( idMat3& axis );
|
|
virtual void GetWorldOrigin( idVec3& vec );
|
|
virtual void GetWorldPhysicsOrigin( idVec3& vec );
|
|
virtual void GetWorldPhysicsAxis( idMat3& axis );
|
|
bool CanDamage( void ) { return health > 0; }
|
|
bool ShouldDisplayDebugInfo() const;
|
|
|
|
protected:
|
|
jointHandle_t joint;
|
|
sdTransport* parent;
|
|
};
|
|
|
|
class sdVehiclePartScripted : public sdVehiclePartSimple {
|
|
public:
|
|
CLASS_PROTOTYPE( sdVehiclePartScripted );
|
|
virtual void Init( const sdDeclVehiclePart& part, sdTransport* _parent );
|
|
virtual void OnKilled( void );
|
|
virtual void Damage( int damage, idEntity *inflictor, idEntity *attacker, const idVec3 &dir, const trace_t* collision );
|
|
virtual void Decay( void ) { }
|
|
|
|
protected:
|
|
const sdProgram::sdFunction *onKilled;
|
|
const sdProgram::sdFunction *onPostDamage;
|
|
};
|
|
|
|
class sdVehicleRigidBodyPart : public sdVehiclePart {
|
|
public:
|
|
CLASS_PROTOTYPE( sdVehicleRigidBodyPart );
|
|
|
|
sdTransport_RB* GetRBParent( void ) { return parent; }
|
|
virtual sdTransport* GetParent( void ) const;
|
|
virtual jointHandle_t GetJoint( void ) const { return joint; }
|
|
void Init( const sdDeclVehiclePart& part, sdTransport_RB* _parent );
|
|
virtual void GetWorldOrigin( idVec3& vec );
|
|
|
|
bool ShouldDisplayDebugInfo() const;
|
|
|
|
protected:
|
|
jointHandle_t joint;
|
|
sdTransport_RB* parent;
|
|
};
|
|
|
|
class sdVehicleRigidBodyPartSimple : public sdVehiclePart {
|
|
public:
|
|
CLASS_PROTOTYPE( sdVehicleRigidBodyPartSimple );
|
|
|
|
sdTransport_RB* GetRBParent( void ) { return parent; }
|
|
virtual sdTransport* GetParent( void ) const;
|
|
virtual jointHandle_t GetJoint( void ) const { return joint; }
|
|
void Init( const sdDeclVehiclePart& part, sdTransport_RB* _parent );
|
|
virtual void GetWorldOrigin( idVec3& vec );
|
|
virtual void GetWorldPhysicsOrigin( idVec3& vec );
|
|
bool CanDamage( void ) { return health > 0; }
|
|
|
|
bool ShouldDisplayDebugInfo() const;
|
|
|
|
protected:
|
|
jointHandle_t joint;
|
|
sdTransport_RB* parent;
|
|
};
|
|
|
|
class sdVehicleRigidBodyWheel : public sdVehicleRigidBodyPartSimple {
|
|
private:
|
|
class sdSuspension : public sdVehicleSuspensionInterface {
|
|
public:
|
|
sdSuspension( void ) { }
|
|
void Init( sdVehicleRigidBodyWheel* owner ) { _owner = owner; }
|
|
|
|
virtual sdTransport* GetParent( void ) const { return _owner->GetParent(); }
|
|
virtual float GetOffset( void ) const { return _owner->wheelOffset; }
|
|
virtual jointHandle_t GetJoint( void ) const { return _owner->GetWheelJoint(); }
|
|
|
|
sdVehicleRigidBodyWheel* _owner;
|
|
};
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( sdVehicleRigidBodyWheel );
|
|
|
|
sdVehicleRigidBodyWheel( void );
|
|
virtual ~sdVehicleRigidBodyWheel( void );
|
|
|
|
void Init( const sdDeclVehiclePart& wheel, sdTransport_RB* _parent );
|
|
void TrackWheelInit( const sdDeclVehiclePart& track, int index, sdTransport_RB* _parent );
|
|
|
|
virtual void UpdatePrePhysics( const sdVehicleInput& input );
|
|
virtual void UpdatePostPhysics( const sdVehicleInput& input );
|
|
float GetLinearSpeed( void );
|
|
virtual int EvaluateContacts( contactInfo_t* list, contactInfoExt_t* listExt, int max );
|
|
void CalcForces( float& maxForce, float& velocity );
|
|
|
|
virtual bool Mask( int mask ) const { return mask & VPT_WHEEL ? true : false; }
|
|
|
|
virtual bool HasPhysics( void ) const { return true; }
|
|
|
|
bool HasDrive( void ) { return wheelFlags.hasDrive; }
|
|
bool HasSteering( void ) { return wheelFlags.hasSteering; }
|
|
bool HasInverseSteering( void ) { return wheelFlags.inverseSteering; }
|
|
|
|
bool SlowsOnLeft( void ) { return wheelFlags.slowsOnLeft; }
|
|
bool SlowsOnRight( void ) { return wheelFlags.slowsOnRight; }
|
|
|
|
bool IsLeftWheel( void ) { return wheelFlags.isLeftWheel; }
|
|
bool IsRightWheel( void ) { return !wheelFlags.isLeftWheel; }
|
|
|
|
const trace_t& GetGroundTrace( void ) const { return groundTrace; }
|
|
|
|
float GetInputSpeed( const sdVehicleInput& input );
|
|
|
|
const idVec3& GetRotationAxis( void ) const { return rotationAxis; }
|
|
|
|
jointHandle_t GetWheelJoint( void ) const { return joint; }
|
|
float GetWheelAngle( void ) const { return angle; }
|
|
bool HasVisualStateChanged( void ) const { return state.changed; }
|
|
void ResetVisualState( void ) { state.changed = false; }
|
|
const idMat3& GetFrictionAxes( void ) { return frictionAxes; }
|
|
virtual bool UpdateSuspensionIK( void );
|
|
virtual void ClearSuspensionIK( void );
|
|
|
|
idVec3 GetBaseWorldOrg( void ) const;
|
|
const idMat3& GetBaseAxes( void ) const { return baseAxes; }
|
|
void UpdateRotation( float speed );
|
|
bool IsGrounded( void ) const { return state.grounded; }
|
|
void DisableSuspension( bool disable ) { state.suspensionDisabled = disable; }
|
|
virtual void CheckWater( const idVec3& waterBodyOrg, const idMat3& waterBodyAxis, idCollisionModel* waterBodyModel );
|
|
void UpdateFriction( const sdVehicleInput& input );
|
|
void UpdateSkidding();
|
|
|
|
virtual const sdDeclSurfaceType* GetSurfaceType( void ) const { return state.grounded ? groundTrace.c.surfaceType : NULL; }
|
|
|
|
|
|
virtual bool IsNetworked() { return false; }
|
|
|
|
void UpdateSuspension( const sdVehicleInput& input );
|
|
void UpdateMotor( const sdVehicleInput& input, float motorForce );
|
|
|
|
virtual bool GoesInPartList() { return !wheelFlags.partOfTrack; }
|
|
|
|
protected:
|
|
void CommonInit( const sdDeclVehiclePart& part );
|
|
virtual void CreateDecayDebris( void );
|
|
|
|
typedef struct wheelFlags_s {
|
|
bool hasDrive : 1;
|
|
bool hasSteering : 1;
|
|
bool inverseSteering : 1;
|
|
bool slowsOnLeft : 1;
|
|
bool slowsOnRight : 1;
|
|
bool isLeftWheel : 1;
|
|
bool isFrontWheel : 1;
|
|
bool noRotation : 1;
|
|
bool noPhysics : 1;
|
|
bool hasHandBrake : 1;
|
|
bool partOfTrack : 1;
|
|
} wheelFlags_t;
|
|
|
|
|
|
typedef struct wheelState_s {
|
|
bool moving : 1;
|
|
bool steeringChanged : 1;
|
|
bool changed : 1;
|
|
bool grounded : 1;
|
|
bool rested : 1;
|
|
bool suspensionDisabled : 1;
|
|
bool spinning : 1;
|
|
bool setSteering : 1;
|
|
bool skidding : 1;
|
|
} wheelState_t;
|
|
|
|
wheelFlags_t wheelFlags;
|
|
float steerScale;
|
|
float steerAngle;
|
|
float idealSteerAngle;
|
|
float angle;
|
|
float rotationspeed;
|
|
float radius;
|
|
float velocityScale;
|
|
idVec3 currentFriction;
|
|
idVec3 normalFriction;
|
|
wheelState_t state;
|
|
idMat3 frictionAxes;
|
|
float motorForce;
|
|
float motorSpeed;
|
|
idClipModel* wheelModel;
|
|
idVec3 rotationAxis;
|
|
|
|
float brakingForce;
|
|
float handBrakeSlipScale;
|
|
float maxSlip;
|
|
|
|
|
|
idList< float > traction;
|
|
idLinkList< sdEffect > activeEffects;
|
|
|
|
float wheelSpinForceThreshold;
|
|
float wheelSkidVelocityThreshold;
|
|
|
|
sdSuspension suspensionInterface;
|
|
sdVehicleSuspension* suspension;
|
|
float wheelOffset;
|
|
|
|
typedef struct suspensionInfo_s {
|
|
float upTrace;
|
|
float downTrace;
|
|
float totalDist;
|
|
float kCompress;
|
|
float damping;
|
|
float velocityScale;
|
|
float maxRestVelocity;
|
|
float base;
|
|
float range;
|
|
bool aggressiveDampening;
|
|
float slowScale;
|
|
float slowScaleSpeed;
|
|
float hardStopScale;
|
|
bool alternateSuspensionModel;
|
|
} suspensionInfo_t;
|
|
|
|
suspensionInfo_t suspensionInfo;
|
|
|
|
idVec3 baseOrg;
|
|
idVec3 baseOrgOffset;
|
|
idMat3 baseAxes;
|
|
trace_t groundTrace;
|
|
float suspensionForce;
|
|
float suspensionVelocity;
|
|
|
|
vehicleEffectList_t dustEffects;
|
|
vehicleEffectList_t spinEffects;
|
|
vehicleEffectList_t skidEffects;
|
|
int numSurfaceTypesAtSpawn;
|
|
|
|
unsigned int treadId;
|
|
bool stroggTread;
|
|
|
|
// Stuff to allow wheel traces to be throttled instead of all run every frame
|
|
int traceIndex;
|
|
int totalWheels;
|
|
|
|
// 16 is sufficient to cover some unplayable pings - 500+
|
|
const static int MAX_WHEEL_MEMORY = 16;
|
|
idStaticList< float, MAX_WHEEL_MEMORY > wheelFractionMemory;
|
|
int currentMemoryFrame;
|
|
int currentMemoryIndex;
|
|
|
|
protected:
|
|
void UpdateRotation( const sdVehicleInput& input );
|
|
void UpdateParticles( const sdVehicleInput& input );
|
|
};
|
|
|
|
class sdVehicleTrack : public sdVehicleDriveObject {
|
|
public :
|
|
CLASS_PROTOTYPE( sdVehicleTrack );
|
|
|
|
virtual ~sdVehicleTrack( void );
|
|
|
|
void Init( const sdDeclVehiclePart& track, sdTransport_RB* _parent );
|
|
|
|
virtual int GetBodyId( void ) { return -1; }
|
|
virtual int GetSurfaceId( void ) { return -1; }
|
|
virtual void GetBounds( idBounds& bounds ) { }
|
|
virtual void UpdatePrePhysics( const sdVehicleInput& input );
|
|
virtual void UpdatePostPhysics( const sdVehicleInput& input );
|
|
virtual void GetWorldOrigin( idVec3& vec ) { vec = vec3_origin; }
|
|
virtual void GetWorldAxis( idMat3& axis ) { axis = mat3_identity; }
|
|
virtual void Detach( bool createDebris, bool decay ) { }
|
|
virtual void Reattach( void ) { }
|
|
virtual void Damage( int damage, idEntity *inflictor, idEntity *attacker, const idVec3 &dir, const trace_t* collision ) { }
|
|
virtual void Decay( void ) { };
|
|
virtual int Repair( int repair ) { return 0; }
|
|
virtual bool CanDamage( void ) { return false; }
|
|
virtual const partDamageInfo_t* GetDamageInfo( void ) const { return NULL; }
|
|
virtual void PostInit( void );
|
|
float GetInputSpeed( const sdVehicleInput& input ) const;
|
|
bool IsLeftTrack( void ) const { return leftTrack; }
|
|
|
|
virtual int EvaluateContacts( contactInfo_t* list, contactInfoExt_t* listExt, int max );
|
|
virtual void CheckWater( const idVec3& waterBodyOrg, const idMat3& waterBodyAxis, idCollisionModel* waterBodyModel );
|
|
virtual const sdDeclSurfaceType* GetSurfaceType( void ) const;
|
|
|
|
virtual sdTransport* GetParent( void ) const;
|
|
|
|
virtual bool HasPhysics( void ) const { return true; }
|
|
|
|
virtual bool UpdateSuspensionIK( void );
|
|
virtual void ClearSuspensionIK( void );
|
|
|
|
bool IsGrounded( void ) const;
|
|
|
|
protected:
|
|
const static int TRACK_MAX_WHEELS = 8;
|
|
|
|
virtual void CreateExplosionDebris( void ) { }
|
|
virtual void CreateDecayDebris( void ) { }
|
|
|
|
sdTransport_RB* parent;
|
|
jointHandle_t joint;
|
|
int shaderParmIndex;
|
|
idVec3 direction;
|
|
idStaticList< sdVehicleRigidBodyWheel*, TRACK_MAX_WHEELS > wheels;
|
|
bool leftTrack;
|
|
|
|
const sdDeclVehiclePart* spawnPart;
|
|
};
|
|
|
|
class sdVehicleThruster : public sdVehicleDriveObject {
|
|
public :
|
|
CLASS_PROTOTYPE( sdVehicleThruster );
|
|
|
|
void Init( const sdDeclVehiclePart& thruster, sdTransport_RB* _parent );
|
|
|
|
virtual bool HasPhysics( void ) const { return true; }
|
|
|
|
virtual int GetBodyId( void ) { return -1; }
|
|
virtual int GetSurfaceId( void ) { return -1; }
|
|
virtual void GetBounds( idBounds& bounds ) { }
|
|
virtual void UpdatePrePhysics( const sdVehicleInput& input );
|
|
virtual void UpdatePostPhysics( const sdVehicleInput& input ) { }
|
|
virtual void GetWorldOrigin( idVec3& vec ) { vec = vec3_origin; }
|
|
virtual void GetWorldAxis( idMat3& axis ) { axis = mat3_identity; }
|
|
virtual void Detach( bool createDebris, bool decay ) { }
|
|
virtual void Reattach( void ) { }
|
|
virtual void Damage( int damage, idEntity *inflictor, idEntity *attacker, const idVec3 &dir, const trace_t* collision ) { }
|
|
virtual void Decay( void ) { };
|
|
virtual int Repair( int repair ) { return 0; }
|
|
virtual bool CanDamage( void ) { return false; }
|
|
virtual const partDamageInfo_t* GetDamageInfo( void ) const { return NULL; }
|
|
virtual void CheckWater( const idVec3& waterBodyOrg, const idMat3& waterBodyAxis, idCollisionModel* waterBodyModel );
|
|
|
|
virtual sdTransport* GetParent( void ) const;
|
|
|
|
void CalcPos( idVec3& pos );
|
|
|
|
bool IsInWater( void ) const { return inWater; }
|
|
float GetThrust( void ) const { return thrustScale; }
|
|
|
|
virtual void SetThrust( float thrust );
|
|
void Event_SetThrust( float thrust );
|
|
|
|
protected:
|
|
virtual void CreateExplosionDebris( void ) { }
|
|
virtual void CreateDecayDebris( void ) { }
|
|
|
|
sdTransport_RB* parent;
|
|
idVec3 direction;
|
|
idVec3 fixedDirection;
|
|
idVec3 origin;
|
|
bool needWater;
|
|
bool inWater;
|
|
float thrustScale;
|
|
float reverseScale;
|
|
};
|
|
|
|
class sdVehicleAirBrake : public sdVehicleDriveObject {
|
|
public :
|
|
CLASS_PROTOTYPE( sdVehicleAirBrake );
|
|
|
|
void Init( const sdDeclVehiclePart& airBrake, sdTransport_RB* _parent );
|
|
|
|
virtual bool HasPhysics( void ) const { return true; }
|
|
|
|
virtual int GetBodyId( void ) { return -1; }
|
|
virtual int GetSurfaceId( void ) { return -1; }
|
|
virtual void GetBounds( idBounds& bounds ) { }
|
|
virtual void UpdatePrePhysics( const sdVehicleInput& input );
|
|
virtual void UpdatePostPhysics( const sdVehicleInput& input ) { }
|
|
virtual void GetWorldOrigin( idVec3& vec ) { vec = vec3_origin; }
|
|
virtual void GetWorldAxis( idMat3& axis ) { axis = mat3_identity; }
|
|
virtual void Detach( bool createDebris, bool decay ) { }
|
|
virtual void Reattach( void ) { }
|
|
virtual void Damage( int damage, idEntity *inflictor, idEntity *attacker, const idVec3 &dir, const trace_t* collision ) { }
|
|
virtual void Decay( void ) { }
|
|
virtual int Repair( int repair ) { return 0; }
|
|
virtual bool CanDamage( void ) { return false; }
|
|
virtual const partDamageInfo_t* GetDamageInfo( void ) const { return NULL; }
|
|
|
|
virtual sdTransport* GetParent( void ) const { return parent; }
|
|
|
|
void Enable( void ) { enabled = true; }
|
|
void Disable( void ) { enabled = false; }
|
|
|
|
protected:
|
|
virtual void CreateExplosionDebris( void ) { }
|
|
virtual void CreateDecayDebris( void ) { }
|
|
|
|
sdTransport* parent;
|
|
bool enabled;
|
|
float factor;
|
|
float maxSpeed;
|
|
};
|
|
|
|
class sdVehicleSuspensionPoint : public sdVehicleDriveObject {
|
|
class sdSuspension : public sdVehicleSuspensionInterface {
|
|
public:
|
|
sdSuspension( void ) { }
|
|
void Init( sdVehicleSuspensionPoint* owner ) { _owner = owner; }
|
|
|
|
virtual sdTransport* GetParent( void ) const { return _owner->GetParent(); }
|
|
virtual float GetOffset( void ) const { return _owner->offset; }
|
|
virtual jointHandle_t GetJoint( void ) const { return _owner->joint; }
|
|
|
|
sdVehicleSuspensionPoint* _owner;
|
|
};
|
|
|
|
public :
|
|
CLASS_PROTOTYPE( sdVehicleSuspensionPoint );
|
|
|
|
sdVehicleSuspensionPoint( void );
|
|
~sdVehicleSuspensionPoint( void );
|
|
|
|
void Init( const sdDeclVehiclePart& point, sdTransport_RB* _parent );
|
|
|
|
virtual bool HasPhysics( void ) const { return true; }
|
|
|
|
virtual int GetBodyId( void ) { return -1; }
|
|
virtual int GetSurfaceId( void ) { return -1; }
|
|
virtual void GetBounds( idBounds& bounds ) { }
|
|
virtual void UpdatePrePhysics( const sdVehicleInput& input );
|
|
virtual void UpdatePostPhysics( const sdVehicleInput& input ) { }
|
|
virtual void GetWorldOrigin( idVec3& vec ) { vec = vec3_origin; }
|
|
virtual void GetWorldAxis( idMat3& axis ) { axis = mat3_identity; }
|
|
virtual void Detach( bool createDebris, bool decay ) { }
|
|
virtual void Reattach( void ) { }
|
|
virtual void Damage( int damage, idEntity *inflictor, idEntity *attacker, const idVec3 &dir, const trace_t* collision ) { }
|
|
virtual void Decay( void ) { }
|
|
virtual int Repair( int repair ) { return 0; }
|
|
virtual bool CanDamage( void ) { return false; }
|
|
virtual const partDamageInfo_t* GetDamageInfo( void ) const { return NULL; }
|
|
virtual int EvaluateContacts( contactInfo_t* list, contactInfoExt_t* listExt, int max );
|
|
|
|
virtual sdTransport* GetParent( void ) const;
|
|
void CalcForces( float& maxForce, float& velocity, const idVec3& traceDir );
|
|
|
|
virtual bool UpdateSuspensionIK( void );
|
|
virtual void ClearSuspensionIK( void );
|
|
|
|
protected:
|
|
virtual void CreateExplosionDebris( void ) { }
|
|
virtual void CreateDecayDebris( void ) { }
|
|
|
|
typedef struct suspensionState_s {
|
|
bool grounded : 1;
|
|
bool rested : 1;
|
|
} suspensionState_t;
|
|
|
|
typedef struct suspensionInfo_s {
|
|
float totalDist;
|
|
float kCompress;
|
|
float damping;
|
|
float velocityScale;
|
|
} suspensionInfo_t;
|
|
|
|
suspensionInfo_t suspensionInfo;
|
|
sdTransport_RB* parent;
|
|
float offset;
|
|
float radius;
|
|
jointHandle_t joint;
|
|
jointHandle_t startJoint;
|
|
idVec3 baseOrg;
|
|
idVec3 baseStartOrg;
|
|
|
|
trace_t groundTrace;
|
|
float suspensionForce;
|
|
float suspensionVelocity;
|
|
|
|
suspensionState_t state;
|
|
|
|
sdSuspension suspensionInterface;
|
|
sdVehicleSuspension* suspension;
|
|
|
|
idVec3 contactFriction;
|
|
idMat3 frictionAxes;
|
|
bool aggressiveDampening;
|
|
};
|
|
|
|
// FIXME: Split main and tail rotor into two seperate classes
|
|
class sdVehicleRigidBodyRotor : public sdVehicleRigidBodyPartSimple {
|
|
public:
|
|
CLASS_PROTOTYPE( sdVehicleRigidBodyRotor );
|
|
|
|
sdVehicleRigidBodyRotor( void );
|
|
virtual ~sdVehicleRigidBodyRotor( void );
|
|
|
|
void Init( const sdDeclVehiclePart& rotor, sdTransport_RB* _parent );
|
|
|
|
virtual bool HasPhysics( void ) const { return true; }
|
|
|
|
virtual void UpdatePrePhysics( const sdVehicleInput& input );
|
|
virtual void UpdatePostPhysics( const sdVehicleInput& input );
|
|
|
|
void UpdatePrePhysics_Main( const sdVehicleInput& input );
|
|
void UpdatePrePhysics_Tail( const sdVehicleInput& input );
|
|
|
|
void UpdatePostPhysics_Tail( const sdVehicleInput& input );
|
|
void UpdatePostPhysics_Main( const sdVehicleInput& input );
|
|
|
|
float GetSpeed( void ) const { return speed; }
|
|
float GetTopGoalSpeed( void ) const;
|
|
void ResetCollective( void );
|
|
|
|
float GetCollective( void ) const { return advanced.collective; }
|
|
void SetCollective( float value ) { advanced.collective = value; }
|
|
|
|
protected:
|
|
typedef struct advancedControls_s {
|
|
float cyclicBank;
|
|
float cyclicPitch;
|
|
float cyclicPitchRate;
|
|
float cyclicBankRate;
|
|
|
|
float collective;
|
|
} advancedControls_t;
|
|
|
|
typedef struct rotorJoint_s {
|
|
jointHandle_t joint;
|
|
idMat3 jointAxes;
|
|
float speedScale;
|
|
float angle;
|
|
bool isYaw;
|
|
} rotorJoint_t;
|
|
|
|
advancedControls_t advanced;
|
|
|
|
float liftCoefficient;
|
|
|
|
idList< rotorJoint_t > animJoints;
|
|
|
|
rotorType_t type;
|
|
float maxPitchDeflect;
|
|
float maxYawDeflect;
|
|
|
|
float sideScale;
|
|
|
|
float speed;
|
|
|
|
float oldPitch;
|
|
float oldYaw;
|
|
|
|
int lastYawChange;
|
|
int lastPitchChange;
|
|
|
|
float zOffset;
|
|
};
|
|
|
|
class sdVehicleRigidBodyHoverPad : public sdVehicleRigidBodyPartSimple {
|
|
public:
|
|
CLASS_PROTOTYPE( sdVehicleRigidBodyHoverPad );
|
|
|
|
sdVehicleRigidBodyHoverPad( void );
|
|
virtual ~sdVehicleRigidBodyHoverPad( void );
|
|
|
|
virtual bool HasPhysics( void ) const { return false; }
|
|
|
|
void Init( const sdDeclVehiclePart& part, sdTransport_RB* _parent );
|
|
virtual void UpdatePostPhysics( const sdVehicleInput& input );
|
|
virtual int EvaluateContacts( contactInfo_t* list, contactInfoExt_t* listExt, int max );
|
|
|
|
protected:
|
|
float maxTraceLength;
|
|
idVec3 traceDir;
|
|
|
|
// Initial positions of the joint
|
|
idVec3 baseOrg;
|
|
idMat3 baseAxes;
|
|
|
|
// Rot limits so they don't stick into the body
|
|
idAngles minAngles;
|
|
idAngles maxAngles;
|
|
|
|
// Movement info
|
|
idQuat currentAxes;
|
|
float adaptSpeed;
|
|
idVec3 lastVelocity;
|
|
|
|
// Lightning related
|
|
sdEffect engineEffect;
|
|
int nextBeamTime;
|
|
const sdDeclTargetInfo *beamTargetInfo;
|
|
int shaderParmIndex;
|
|
};
|
|
|
|
#define PSEUDO_HOVER_MAX_CASTS 8
|
|
|
|
class sdPseudoHoverBroadcastData : public sdEntityStateNetworkData {
|
|
public:
|
|
sdPseudoHoverBroadcastData( void ) { ; }
|
|
|
|
virtual void MakeDefault( void );
|
|
|
|
virtual void Write( idFile* file ) const;
|
|
virtual void Read( idFile* file );
|
|
|
|
bool parkMode;
|
|
bool foundPark;
|
|
bool lockedPark;
|
|
int startParkTime;
|
|
int endParkTime;
|
|
int lastParkUpdateTime;
|
|
idVec3 chosenParkOrigin;
|
|
idMat3 chosenParkAxis;
|
|
};
|
|
|
|
class sdPseudoHoverNetworkData : public sdEntityStateNetworkData {
|
|
public:
|
|
sdPseudoHoverNetworkData( void ) { ; }
|
|
|
|
virtual void MakeDefault( void );
|
|
|
|
virtual void Write( idFile* file ) const;
|
|
virtual void Read( idFile* file );
|
|
|
|
float lastFrictionScale;
|
|
};
|
|
|
|
class sdVehicleRigidBodyPseudoHover : public sdVehiclePart {
|
|
public:
|
|
CLASS_PROTOTYPE( sdVehicleRigidBodyPseudoHover );
|
|
|
|
sdVehicleRigidBodyPseudoHover( void );
|
|
virtual ~sdVehicleRigidBodyPseudoHover( void );
|
|
|
|
virtual bool HasPhysics( void ) const { return true; }
|
|
|
|
void Init( const sdDeclVehiclePart& part, sdTransport_RB* _parent );
|
|
virtual void UpdatePrePhysics( const sdVehicleInput& input );
|
|
virtual void UpdatePostPhysics( const sdVehicleInput& input );
|
|
virtual int AddCustomConstraints( constraintInfo_t* list, int max );
|
|
|
|
virtual sdTransport* GetParent( void ) const { return parent; }
|
|
|
|
virtual bool IsNetworked() { return true; }
|
|
virtual void ApplyNetworkState( networkStateMode_t mode, const sdEntityStateNetworkData& newState );
|
|
virtual void ReadNetworkState( networkStateMode_t mode, const sdEntityStateNetworkData& baseState, sdEntityStateNetworkData& newState, const idBitMsg& msg ) const;
|
|
virtual void WriteNetworkState( networkStateMode_t mode, const sdEntityStateNetworkData& baseState, sdEntityStateNetworkData& newState, idBitMsg& msg ) const;
|
|
virtual bool CheckNetworkStateChanges( networkStateMode_t mode, const sdEntityStateNetworkData& baseState ) const;
|
|
virtual sdEntityStateNetworkData* CreateNetworkStructure( networkStateMode_t mode ) const;
|
|
|
|
protected:
|
|
|
|
// hoverEvalState_t is just used to pass around to the various evaluation functions
|
|
// note that it DOES NOT store anything across frames.
|
|
typedef struct {
|
|
sdClipModelCollection clipLocale;
|
|
|
|
float timeStep;
|
|
|
|
// position
|
|
idVec3 origin;
|
|
idVec3 linVelocity;
|
|
|
|
// physical properties
|
|
float mass;
|
|
idVec3 gravity;
|
|
idMat3 inertiaTensor;
|
|
|
|
// orientation
|
|
idMat3 axis;
|
|
idVec3 angVelocity;
|
|
|
|
// game properties
|
|
sdPhysics_RigidBodyMultiple* physics;
|
|
idPlayer* driver;
|
|
|
|
// evaluation
|
|
idVec3 surfaceNormal;
|
|
idQuat surfaceQuat;
|
|
idMat3 surfaceAxis;
|
|
idVec3 hoverForce;
|
|
idVec3 drivingForce;
|
|
idVec3 frictionForce;
|
|
|
|
idQuat surfaceMatchingQuat;
|
|
idVec3 steeringAngVel;
|
|
} hoverEvalState_t;
|
|
|
|
void DoRepulsors();
|
|
void DoRepulsionForCast( const idVec3& start, const idVec3& end, float desiredFraction, const trace_t& trace, float& height, int numForces );
|
|
void CalculateSurfaceAxis();
|
|
void CalculateDrivingForce( const sdVehicleInput& input );
|
|
void CalculateFrictionForce( const sdVehicleInput& input );
|
|
void CalculateTilting( const sdVehicleInput& input );
|
|
void CalculateYaw( const sdVehicleInput& input );
|
|
|
|
void ChooseParkPosition();
|
|
void DoParkRepulsors();
|
|
|
|
|
|
// state
|
|
bool grounded;
|
|
sdTransport* parent;
|
|
idPlayer* oldDriver;
|
|
|
|
trace_t groundTrace;
|
|
|
|
float lastFrictionScale; // sync this!
|
|
|
|
hoverEvalState_t evalState;
|
|
|
|
idVec3 targetVelocity;
|
|
idQuat targetQuat;
|
|
|
|
//
|
|
// "park" mode
|
|
//
|
|
|
|
bool parkMode; // sync this!
|
|
int startParkTime; // sync this!
|
|
int endParkTime; // sync this!
|
|
int lastParkUpdateTime; // sync this!
|
|
idVec3 chosenParkOrigin; // sync this!
|
|
idMat3 chosenParkAxis; // sync this!
|
|
bool foundPark; // sync this!
|
|
bool lockedPark; // sync this!
|
|
|
|
int lastParkEffectTime;
|
|
int lastUnparkEffectTime;
|
|
|
|
// Physics tuning parameters
|
|
float hoverHeight;
|
|
float parkHeight;
|
|
|
|
float repulsionSpeedCoeff;
|
|
float repulsionSpeedHeight;
|
|
float repulsionSpeedMax;
|
|
|
|
float yawCoeff;
|
|
|
|
float fwdCoeff;
|
|
float fwdSpeedDampCoeff;
|
|
float fwdSpeedDampPower;
|
|
float fwdSpeedDampMax;
|
|
|
|
float frontCastPos;
|
|
float backCastPos;
|
|
|
|
float castOffset;
|
|
float maxSlope;
|
|
float slopeDropoff;
|
|
|
|
float parkTime;
|
|
|
|
idBounds mainBounds;
|
|
idClipModel* mainClipModel;
|
|
|
|
jointHandle_t effectJoint;
|
|
|
|
// casts
|
|
idStaticList< idVec3, PSEUDO_HOVER_MAX_CASTS > castStarts;
|
|
idStaticList< idVec3, PSEUDO_HOVER_MAX_CASTS > castDirections;
|
|
};
|
|
|
|
class sdVehicleRigidBodyVtol : public sdVehicleRigidBodyPartSimple {
|
|
public:
|
|
CLASS_PROTOTYPE( sdVehicleRigidBodyVtol );
|
|
|
|
sdVehicleRigidBodyVtol( void );
|
|
virtual ~sdVehicleRigidBodyVtol( void );
|
|
|
|
void Init( const sdDeclVehiclePart& part, sdTransport_RB* _parent );
|
|
virtual void UpdatePrePhysics( const sdVehicleInput& input );
|
|
virtual void UpdatePostPhysics( const sdVehicleInput& input );
|
|
|
|
protected:
|
|
|
|
// Initial positions of the joints
|
|
int shoulderAxis;
|
|
int elbowAxis;
|
|
jointHandle_t elbowJoint;
|
|
jointHandle_t effectJoint;
|
|
idMat3 shoulderBaseAxes;
|
|
idMat3 elbowBaseAxes;
|
|
|
|
float oldShoulderAngle;
|
|
float oldElbowAngle;
|
|
|
|
// Parameters
|
|
float shoulderAngleScale, elbowAngleScale;
|
|
idVec2 shoulderAnglesBounds;
|
|
idVec2 elbowAnglesBounds;
|
|
sdEffect engineEffect;
|
|
|
|
// Radom movements of the hover
|
|
float noisePhase;
|
|
float noiseFreq;
|
|
float noiseAmplitude;
|
|
};
|
|
|
|
class sdVehicleRigidBodyAntiGrav : public sdVehiclePartSimple {
|
|
public:
|
|
CLASS_PROTOTYPE( sdVehicleRigidBodyAntiGrav );
|
|
|
|
sdVehicleRigidBodyAntiGrav( void );
|
|
virtual ~sdVehicleRigidBodyAntiGrav( void );
|
|
|
|
void Init( const sdDeclVehiclePart& part, sdTransport* _parent );
|
|
virtual void UpdatePrePhysics( const sdVehicleInput& input );
|
|
virtual void UpdatePostPhysics( const sdVehicleInput& input );
|
|
|
|
void UpdateEffect();
|
|
|
|
void SetClientParent( rvClientEntity* p );
|
|
|
|
protected:
|
|
void SetupJoints( idAnimator* targetAnimator );
|
|
|
|
// Initial positions of the joints
|
|
idMat3 baseAxes;
|
|
|
|
// Parameters
|
|
idVec2 mountAnglesBounds;
|
|
sdEffect engineMainEffect;
|
|
sdEffect engineBoostEffect;
|
|
|
|
idVec3 oldVelocity;
|
|
float oldAngle;
|
|
|
|
// Axes and stuff
|
|
int rotAxis; // The engines will rotate around this axis
|
|
int tailUpAxis;
|
|
int tailSideAxis;
|
|
|
|
float fanRotation;
|
|
float targetAngle;
|
|
|
|
jointHandle_t fanJoint;
|
|
jointHandle_t tailJoint;
|
|
idStr fanJointName;
|
|
idStr tailJointName;
|
|
|
|
rvClientEntity* clientParent;
|
|
|
|
int lastGroundEffectsTime;
|
|
|
|
// fan speed stuff
|
|
float fanSpeedMultiplier;
|
|
float fanSpeedOffset;
|
|
float fanSpeedMax;
|
|
float fanSpeedRampRate;
|
|
float lastFanSpeed;
|
|
};
|
|
|
|
class sdVehicleRigidBodyDragPlane : public sdVehiclePart {
|
|
public:
|
|
CLASS_PROTOTYPE( sdVehicleRigidBodyDragPlane );
|
|
|
|
sdVehicleRigidBodyDragPlane( void );
|
|
virtual ~sdVehicleRigidBodyDragPlane( void );
|
|
|
|
virtual bool HasPhysics( void ) const { return true; }
|
|
|
|
void Init( const sdDeclVehiclePart& part, sdTransport_RB* _parent );
|
|
virtual void UpdatePrePhysics( const sdVehicleInput& input );
|
|
virtual void UpdatePostPhysics( const sdVehicleInput& input );
|
|
|
|
virtual sdTransport* GetParent( void ) const { return parent; }
|
|
|
|
protected:
|
|
sdTransport* parent;
|
|
|
|
idVec3 normal;
|
|
idVec3 origin; // point of application of the drag force
|
|
float coefficient;
|
|
float maxForce;
|
|
float minForce;
|
|
bool doubleSided;
|
|
bool useAngleScale;
|
|
};
|
|
|
|
class sdVehicleRigidBodyRudder : public sdVehicleRigidBodyDragPlane {
|
|
public:
|
|
CLASS_PROTOTYPE( sdVehicleRigidBodyRudder );
|
|
|
|
virtual bool HasPhysics( void ) const { return true; }
|
|
|
|
void Init( const sdDeclVehiclePart& part, sdTransport_RB* _parent );
|
|
virtual void UpdatePrePhysics( const sdVehicleInput& input );
|
|
|
|
protected:
|
|
};
|
|
|
|
class sdVehicleRigidBodyHurtZone : public sdVehicleRigidBodyPart {
|
|
public:
|
|
CLASS_PROTOTYPE( sdVehicleRigidBodyHurtZone );
|
|
|
|
void Init( const sdDeclVehiclePart& part, sdTransport_RB* _parent );
|
|
};
|
|
|
|
class sdVehicleAntiRoll : public sdVehiclePart {
|
|
public:
|
|
CLASS_PROTOTYPE( sdVehicleAntiRoll );
|
|
|
|
sdVehicleAntiRoll( void );
|
|
virtual ~sdVehicleAntiRoll( void );
|
|
|
|
virtual bool HasPhysics( void ) const { return true; }
|
|
|
|
void Init( const sdDeclVehiclePart& part, sdTransport_RB* _parent );
|
|
virtual void UpdatePrePhysics( const sdVehicleInput& input );
|
|
virtual void UpdatePostPhysics( const sdVehicleInput& input );
|
|
virtual int AddCustomConstraints( constraintInfo_t* list, int max );
|
|
|
|
virtual sdTransport* GetParent( void ) const { return parent; }
|
|
|
|
protected:
|
|
sdTransport_RB* parent;
|
|
|
|
float currentStrength;
|
|
bool active;
|
|
|
|
float startAngle;
|
|
float endAngle;
|
|
float strength;
|
|
bool needsGround;
|
|
};
|
|
|
|
class sdVehicleAntiPitch : public sdVehiclePart {
|
|
public:
|
|
CLASS_PROTOTYPE( sdVehicleAntiPitch );
|
|
|
|
sdVehicleAntiPitch( void );
|
|
virtual ~sdVehicleAntiPitch( void );
|
|
|
|
virtual bool HasPhysics( void ) const { return true; }
|
|
|
|
void Init( const sdDeclVehiclePart& part, sdTransport_RB* _parent );
|
|
virtual void UpdatePrePhysics( const sdVehicleInput& input );
|
|
virtual void UpdatePostPhysics( const sdVehicleInput& input );
|
|
virtual int AddCustomConstraints( constraintInfo_t* list, int max );
|
|
|
|
virtual sdTransport* GetParent( void ) const { return parent; }
|
|
|
|
protected:
|
|
sdTransport_RB* parent;
|
|
|
|
float currentStrength;
|
|
bool active;
|
|
|
|
float startAngle;
|
|
float endAngle;
|
|
float strength;
|
|
bool needsGround;
|
|
};
|
|
|
|
#endif // __GAME_VEHICLE_COMPONENTS_H__
|