Tiberian Technologies Scripts Reference Revision: 9000
Loading...
Searching...
No Matches
RigidBodyClass.h
1#ifndef TT_INCLUDE__RIGIDBODYCLASS_H
2#define TT_INCLUDE__RIGIDBODYCLASS_H
3#include "MoveablePhysClass.h"
4#include "ODESystemClass.h"
5#include "AABoxClass.h"
6#include "Quaternion.h"
7#include "Matrix3.h"
8#include "PhysicsConstants.h"
9class RigidBodyDefClass;
10class OBBoxRenderObjClass;
11class PaddedBoxClass;
12class OctBoxClass;
13class RBodyHistoryClass;
14struct CastResultStruct;
15const int MAX_CONTACT_POINTS = 10;
16const float RBODY_SLEEP_DELAY = 0.5f; // if still for this many seconds, shut off simulation
17struct RigidBodyStateStruct
18{
19 RigidBodyStateStruct(void) {}
20 RigidBodyStateStruct(const RigidBodyStateStruct & that);
21 RigidBodyStateStruct & operator = (const RigidBodyStateStruct & that);
22 void Reset(void);
23 void To_Vector(StateVectorClass & vec);
24 int From_Vector(const StateVectorClass & vec,int index);
25 static void Lerp(const RigidBodyStateStruct & s0,const RigidBodyStateStruct & s1,float fraction,RigidBodyStateStruct * res);
26 bool Is_Valid(void) { return (Position.Is_Valid() && Orientation.Is_Valid() && LMomentum.Is_Valid() && AMomentum.Is_Valid()); }
27 Vector3 Position;
28 Quaternion Orientation;
29 Vector3 LMomentum;
30 Vector3 AMomentum;
31};
32inline RigidBodyStateStruct::RigidBodyStateStruct(const RigidBodyStateStruct & that)
33{
34 *this = that;
35}
36inline RigidBodyStateStruct & RigidBodyStateStruct::operator = (const RigidBodyStateStruct & that)
37{
38 Position = that.Position;
39 Orientation = that.Orientation;
40 LMomentum = that.LMomentum;
41 AMomentum = that.AMomentum;
42 return *this;
43}
44inline void RigidBodyStateStruct::Reset(void)
45{
46 Position.Set(0,0,0);
47 Orientation.Make_Identity();
48 LMomentum.Set(0,0,0);
49 AMomentum.Set(0,0,0);
50}
51inline void RigidBodyStateStruct::To_Vector(StateVectorClass & vec)
52{
53 vec.Add(Position[0]);
54 vec.Add(Position[1]);
55 vec.Add(Position[2]);
56
57 vec.Add(Orientation[0]);
58 vec.Add(Orientation[1]);
59 vec.Add(Orientation[2]);
60 vec.Add(Orientation[3]);
61
62 vec.Add(LMomentum[0]);
63 vec.Add(LMomentum[1]);
64 vec.Add(LMomentum[2]);
65
66 vec.Add(AMomentum[0]);
67 vec.Add(AMomentum[1]);
68 vec.Add(AMomentum[2]);
69}
70inline int RigidBodyStateStruct::From_Vector(const StateVectorClass & vec,int index)
71{
72 Position[0] = vec[index++];
73 Position[1] = vec[index++];
74 Position[2] = vec[index++];
75
76 Orientation[0] = vec[index++];
77 Orientation[1] = vec[index++];
78 Orientation[2] = vec[index++];
79 Orientation[3] = vec[index++];
80
81 LMomentum[0] = vec[index++];
82 LMomentum[1] = vec[index++];
83 LMomentum[2] = vec[index++];
84
85 AMomentum[0] = vec[index++];
86 AMomentum[1] = vec[index++];
87 AMomentum[2] = vec[index++];
88
89 return index;
90}
91inline void RigidBodyStateStruct::Lerp
92(
93 const RigidBodyStateStruct & s0,
94 const RigidBodyStateStruct & s1,
95 float fraction,
96 RigidBodyStateStruct * res
97)
98{
99 Vector3::Lerp(s0.Position,s1.Position,fraction,&(res->Position));
100 Vector3::Lerp(s0.LMomentum,s1.LMomentum,fraction,&(res->LMomentum));
101 Vector3::Lerp(s0.AMomentum,s1.AMomentum,fraction,&(res->AMomentum));
102 ::Fast_Slerp(res->Orientation,s0.Orientation,s1.Orientation,fraction);
103}
104
105class RigidBodyClass : public MoveablePhysClass , public ODESystemClass
106{
107public:
108 RigidBodyClass(void);
109 virtual ~RigidBodyClass(void);
110 virtual RigidBodyClass * As_RigidBodyClass(void) { return this; }
111 RigidBodyDefClass * Get_RigidBodyDef(void) { return (RigidBodyDefClass *)Definition; }
112 void Init(const RigidBodyDefClass & definition);
113 virtual const AABoxClass & Get_Bounding_Box(void) const;
114 virtual const Matrix3D & Get_Transform(void) const;
115 virtual void Set_Transform(const Matrix3D & m);
116 virtual bool Cast_Ray(PhysRayCollisionTestClass & raytest);
117 virtual bool Cast_AABox(PhysAABoxCollisionTestClass & boxtest);
118 virtual bool Cast_OBBox(PhysOBBoxCollisionTestClass & boxtest);
119 virtual bool Intersection_Test(PhysAABoxIntersectionTestClass & test);
120 virtual bool Intersection_Test(PhysOBBoxIntersectionTestClass & test);
121 virtual bool Intersection_Test(PhysMeshIntersectionTestClass & test);
122 virtual bool Can_Teleport(const Matrix3D &new_tm, bool check_dyn_only = false,MultiListClass<PhysClass> * result_list = NULL);
123 virtual bool Can_Teleport_And_Stand(const Matrix3D &new_tm, Matrix3D *out);
124 void Get_Orientation(Quaternion * set_q) const { *set_q = State.Orientation; }
125 void Set_Orientation(Quaternion & new_q) { State.Orientation = new_q; }
126 virtual void Get_Velocity(Vector3 * set_vel) const;
127 virtual void Get_Angular_Velocity(Vector3 * set_avel) const;
128 virtual void Set_Velocity(const Vector3 & newvel);
129 virtual void Set_Angular_Velocity(const Vector3 & newavel);
130 virtual void Apply_Impulse(const Vector3 & imp);
131 virtual void Apply_Impulse(const Vector3 & imp, const Vector3 & wpos);
132 virtual void Timestep(float dt);
133 void Compute_Point_Velocity(const Vector3 & p,Vector3 * pdot);
134 float Get_Last_Timestep(void) { return LastTimestep; }
135 void Network_Interpolate_State_Update( const Vector3 & new_pos,
136 const Quaternion & new_orientation,
137 const Vector3 & new_vel,
138 const Vector3 & new_avel,
139 float blend_fraction);
140 void Network_Latency_State_Update( const Vector3 & new_pos,
141 const Quaternion & new_orientation,
142 const Vector3 & new_vel,
143 const Vector3 & new_avel);
144 static void Set_Correction_Time(float time) { _CorrectionTime = time; }
145 static float Get_Correction_Time(void) { return _CorrectionTime; }
146 virtual void Set_Model(RenderObjClass * model);
147 virtual void Set_Mass(float mass);
148 virtual void Get_Inertia_Inv(Matrix3 * set_I_inv);
149 void Set_Inertia(const Matrix3 & I);
150 void Get_Inertia(Matrix3 * I);
151 void Set_Contact_Parameters(float length);
152 void Get_Contact_Parameters(float * stiffness,float * damping,float * length);
153 float Get_Weight(void) { return GravScale * Mass * (-PhysicsConstants::GravityAcceleration.Z); }
154 virtual void Get_Shadow_Blob_Box(AABoxClass * set_obj_space_box);
155 virtual bool Push(const Vector3 & move);
156 virtual const PersistFactoryClass & Get_Factory (void) const;
157 virtual bool Save (ChunkSaveClass &csave);
158 virtual bool Load (ChunkLoadClass &cload);
159 virtual void On_Post_Load(void);
160 OBBoxRenderObjClass* Peek_Box() { return Box; }
161protected:
162 virtual void Get_State(StateVectorClass & set_state);
163 virtual int Set_State(const StateVectorClass & new_state,int start_index);
164 void Set_State(const RigidBodyStateStruct & new_state);
165 virtual int Compute_Derivatives(float t,StateVectorClass * test_state,StateVectorClass * set_derivs,int start_index);
166 void Integrate(float time);
167 void Update_Cached_Model_Parameters(void);
168 virtual void Compute_Inertia(void);
169 void Update_Auxiliary_State(void);
170 virtual void Compute_Force_And_Torque(Vector3 * force,Vector3 * torque);
171 void Compute_Impact(const CastResultStruct & result,Vector3 * impulse);
172 void Compute_Impact(const Vector3 & point,const Vector3 & normal,Vector3 * impulse);
173 bool Is_Colliding(const Vector3 & point, const Vector3 & normal);
174 void Set_Moving_Collision_Region(float dt);
175 void Set_Stationary_Collision_Region(void);
176 virtual bool Can_Go_To_Sleep(float dt);
177 bool Find_State_In_Contact_Zone(const RigidBodyStateStruct & oldstate);
178 bool Push_Phys3_Object_Away(Phys3Class * p3obj,const CastResultStruct & contact);
179 void Network_Latency_Error_Correction(float dt);
180 void Assert_State_Valid(void) const;
181 void Assert_Not_Intersecting(void);
182 void Dump_State(void) const;
183 OBBoxRenderObjClass * Box; // World-Space Box
184 Matrix3 IBody; // Body space inertia tensor
185 Matrix3 IBodyInv; // Inverse of the body space inertia tensor
186 OctBoxClass * ContactBox; // datastructure for finding contact points
187 float ContactThickness; // Dimension of the contact region
188 RigidBodyStateStruct State; // current state vector
189 Matrix3 Rotation;
190 Matrix3 IInv;
191 Vector3 Velocity;
192 Vector3 AngularVelocity;
193 bool IsInContact;
194 int ContactCount;
195 Vector3 ContactPoint[MAX_CONTACT_POINTS];
196 Vector3 ContactNormal;
197 int StickCount;
198 float LastTimestep;
199 float GoToSleepTimer;
200 RBodyHistoryClass * History;
201 RigidBodyStateStruct LatencyError;
202 RigidBodyStateStruct LastKnownState;
203 static float _CorrectionTime;
204private:
205 RigidBodyClass(const RigidBodyClass &);
206 RigidBodyClass & operator = (const RigidBodyClass &);
207}; // 02B0 02B0 02CC 02C8
208#endif
Generated by doxygen 1.10.0