hkpRigidBody.h
上传用户:yisoukefu
上传日期:2020-08-09
资源大小:39506k
文件大小:26k
源码类别:

其他游戏

开发平台:

Visual C++

  1. /* 
  2.  * 
  3.  * Confidential Information of Telekinesys Research Limited (t/a Havok). Not for disclosure or distribution without Havok's
  4.  * prior written consent. This software contains code, techniques and know-how which is confidential and proprietary to Havok.
  5.  * Level 2 and Level 3 source code contains trade secrets of Havok. Havok Software (C) Copyright 1999-2009 Telekinesys Research Limited t/a Havok. All Rights Reserved. Use of this software is subject to the terms of an end user license agreement.
  6.  * 
  7.  */
  8. #ifndef HK_DYNAMICS2_RIGID_BODY_H
  9. #define HK_DYNAMICS2_RIGID_BODY_H
  10. #include <Physics/Dynamics/World/hkpWorld.h>
  11. #include <Physics/Dynamics/Entity/hkpEntity.h>
  12. #include <Physics/Dynamics/Entity/hkpRigidBodyCinfo.h>
  13. #include <Physics/Dynamics/Entity/hkpRigidBodyDeactivator.h>
  14. extern const hkClass hkpRigidBodyClass;
  15. /// Helper function that returns a hkpRigidBody if the collidable's broadphase handle is of type hkpWorldObject::BROAD_PHASE_ENTITY
  16. inline class hkpRigidBody* hkGetRigidBody( const hkpCollidable* collidable );
  17. /// This is the basic rigid body class. Rigid bodies are objects whose shape never changes.
  18. /// They are central to Havok dynamics, as they easily allow for rapid physical simulation
  19. /// in real time.
  20. /// An hkpRigidBody wraps an hkpMotion that stores all the information relating to how
  21. /// the rigid body moves, including its mass and velocity. It also has an hkpCollidable member
  22. /// that contains the information needed for the body to work with the collision detection
  23. /// system, such as its hkpShape.
  24. class hkpRigidBody : public hkpEntity
  25. {
  26. public:
  27. HK_DECLARE_REFLECTION();
  28. /// The constructor takes the information from the passed info parameter.
  29. /// This contains all the information necessary to create a valid rigid body.
  30. hkpRigidBody( const hkpRigidBodyCinfo& info );
  31. /// Default destructor.
  32. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  33. virtual ~hkpRigidBody();
  34. /// Get construction info from this rigid body.
  35. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RO] );
  36. void getCinfo(hkpRigidBodyCinfo& info) const;
  37. //
  38. // MASS, INERTIA AND DENSITY PROPERTIES.
  39. //
  40. /// Gets the mass of the rigid body.
  41. inline hkReal getMass() const;
  42. /// Gets the 1.0/mass of the rigid body.
  43. inline hkReal getMassInv() const;
  44. /// Sets the mass of the rigid body. N.B. This does NOT automatically update other dependent mass properties i.e. the inertia tensor.
  45. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  46. void setMass(hkReal m);
  47. /// Sets the mass of the rigid body.
  48. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  49. void setMassInv(hkReal mInv);
  50. /// Gets the inertia tensor (around the center of mass) in local space.
  51. inline void getInertiaLocal(hkMatrix3& inertiaOut) const;
  52. /// Gets the inertia tensor (around the center of mass) in world space.
  53. inline void getInertiaWorld(hkMatrix3& inertiaOut) const;
  54. /// Sets the inertia tensor of the rigid body. Advanced use only.
  55. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  56. void setInertiaLocal(const hkMatrix3& inertia);
  57. /// Sets the inertia tensor of the rigid body by supplying its inverse. Advanced use only.
  58. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  59. void setInertiaInvLocal(const hkMatrix3& inertiaInv);
  60. /// Gets the inverse inertia tensor in local space.
  61. inline void getInertiaInvLocal(hkMatrix3& inertiaInv) const;
  62. /// Gets the inverse inertia tensor in world space.
  63. inline void getInertiaInvWorld(hkMatrix3& inertiaInvOut) const;
  64. //
  65. // CENTER OF MASS.
  66. //
  67. /// Explicitly sets the center of mass of the rigid body in local space.
  68. /// Note that this does <b>not</b> change the position of the rigid body.
  69. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  70. void setCenterOfMassLocal(const hkVector4& centerOfMass);
  71. /// Gets the center of mass of the rigid body in the rigid body's local space.
  72. inline const hkVector4& getCenterOfMassLocal() const;
  73. /// Gets the center of mass of the rigid body in world space.
  74. inline const hkVector4& getCenterOfMassInWorld() const;
  75. //
  76. // POSITION ACCESS.
  77. //
  78. /// Returns the position (the local space origin) for this rigid body, in world space.
  79. /// Note that the center of mass may no longer be the local space origin.
  80. inline const hkVector4& getPosition() const;
  81. /// Sets the position (the local space origin) of this rigid body, in world space.
  82. /// Note that this function may cause contactPointRemovedCallbacks fired.
  83. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  84. void setPosition(const hkVector4& position);
  85. /// Returns the rotation from local to world space for this rigid body.
  86. inline const hkQuaternion& getRotation() const;
  87. /// Sets the rotation from local to world Space for this rigid body.
  88. /// This activates the body and its simulation island if it is inactive.
  89. /// Note that this function may cause contactPointRemovedCallbacks fired.
  90. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  91. void setRotation(const hkQuaternion& rotation);
  92. /// Sets the position and rotation of the rigid body, in world space.
  93. /// Note that this function may cause contactPointRemovedCallbacks fired.
  94. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  95. void setPositionAndRotation(const hkVector4& position, const hkQuaternion& rotation);
  96. /// Returns the rigid body (local) to world transformation.
  97. /// This is the transform at the end of the timestep. If you run physics
  98. /// and graphics asynchronously you should use approxTransformAt 
  99. inline const hkTransform& getTransform() const;
  100. /// Sets the rigid body (local) to world transformation
  101. /// Note that this function may cause contactPointRemovedCallbacks fired.
  102. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  103. void setTransform(const hkTransform& transform);
  104. /// like setPositionAndRotation, except its effect will be delayed if the
  105. /// hkpWorld is locked. That means this function is multi threaded safe
  106. /// and should be used if you want to change the position of an object
  107. /// from a callback and you cannot use the setPositionAndRotation (access check asserts
  108. /// are getting fired. 
  109. /// Note: If you call this function from callbacks in a multithreaded environment,
  110. /// the engine becomes non deterministic.
  111. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_RW] [this,HK_ACCESS_RW] );
  112. void setPositionAndRotationAsCriticalOperation(const hkVector4& position, const hkQuaternion& rotation);
  113. /// Interpolate the matrix for the 'time' time; for asynchronous simulation only.
  114. /// You should use this function to display the rigid bodies position if
  115. /// you use an asynchronous simulation. To get the current time, 
  116. /// use world->m_currentTime.
  117. inline void approxTransformAt( hkTime time, hkTransform& transformOut ) const;
  118. /// Approximates the body's transform at the current world's time.
  119. inline void approxCurrentTransform( hkTransform& transformOut ) const;
  120. //
  121. // VELOCITY ACCESS.
  122. //
  123. /// Returns the linear velocity of the center of mass of the rigid body, in world space.
  124. inline const hkVector4& getLinearVelocity() const;
  125. /// Sets the linear velocity at the center of mass, in world space.
  126. /// This activates the body and its simulation island if it is inactive.
  127. inline void setLinearVelocity(const hkVector4& newVel);
  128. /// Returns the angular velocity around the center of mass, in world space.
  129. inline const hkVector4& getAngularVelocity() const;
  130. /// Sets the angular velocity around the center of mass, in world space.
  131. /// This activates the body and its simulation island if it is inactive.
  132. inline void setAngularVelocity(const hkVector4& newVel);
  133. /// Gets the velocity of point p on the rigid body in world space.
  134. inline void getPointVelocity(const hkVector4& p, hkVector4& vecOut) const;
  135. /// Like setLinearVelocity, but effect will be delayed if world is locked.
  136. /// See setPositionAndRotationAsCriticalOperation() for details
  137. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  138. void setLinearVelocityAsCriticalOperation(const hkVector4& newVel);
  139. /// Like setAngularVelocity, but effect will be delayed if world is locked.
  140. /// See setPositionAndRotationAsCriticalOperation() for details
  141. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  142. void setAngularVelocityAsCriticalOperation(const hkVector4& newVel);
  143. //
  144. // IMPULSE APPLICATION.
  145. //
  146. /// Applies an impulse (in world space) to the center of mass.
  147. /// This activates the body and its simulation island if it is inactive.
  148. inline void applyLinearImpulse(const hkVector4& imp);
  149. /// Applies an impulse (in world space) at the point p in world space.
  150. /// This activates the body and its simulation island if it is inactive.
  151. inline void applyPointImpulse(const hkVector4& imp, const hkVector4& p);
  152. /// Applies an instantaneous change in angular velocity (in world space) around
  153. /// the center of mass.
  154. /// This activates the body and its simulation island if it is inactive.
  155. inline void applyAngularImpulse(const hkVector4& imp);
  156. /// World-lock--safe version of applyLinearImpulse. The effect of the call may be postponed until the world is unlocked.
  157. /// See setPositionAndRotationAsCriticalOperation() description for more info on thread-safe usage.
  158. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  159. void applyLinearImpulseAsCriticalOperation(const hkVector4& imp);
  160. /// World-lock--safe version of applyPointImpulse. The effect of the call may be postponed until the world is unlocked.
  161. /// See setPositionAndRotationAsCriticalOperation() description for more info on thread-safe usage.
  162. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  163. void applyPointImpulseAsCriticalOperation(const hkVector4& imp, const hkVector4& p);
  164. /// World-lock--safe version of applyAngularImpulse. The effect of the call may be postponed until the world is unlocked.
  165. /// See setPositionAndRotationAsCriticalOperation() description for more info on thread-safe usage.
  166. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  167. void applyAngularImpulseAsCriticalOperation(const hkVector4& imp);
  168. //
  169. // FORCE AND TORQUE APPLICATION.
  170. //
  171. /// Applies a force (in world space) to the rigid body. The force is applied to the
  172. /// center of mass.
  173. /// This activates the body and its simulation island if it is inactive.
  174. /// As forces are immediately converted to impulses and applied , you must pass a correct step delta-time related to the simulation's hkStepInfo.
  175. inline void applyForce(const hkReal deltaTime, const hkVector4& force);
  176. /// Applies a force (in world space) to the rigid body at the point p in world space.
  177. /// This activates the body and its simulation island if it is inactive.
  178. /// As forces are immediately converted to impulses and applied , you must pass a correct step delta-time related to the simulation's hkStepInfo.
  179. inline void applyForce(const hkReal deltaTime, const hkVector4& force, const hkVector4& p);
  180. /// Applies the specified torque (in world space) to the rigid body.
  181. /// Specify the torque as an hkVector4. The direction of the vector indicates the axis (in
  182. /// world space) that you want the body to rotate around, and the magnitude of the vector indicates
  183. /// the strength of the force applied. The change in the body's angular velocity after torques are
  184. /// applied is proportional to the simulation delta time value and inversely proportional to the body's
  185. /// inertia.
  186. /// This activates the body and its simulation island if it is inactive.
  187. /// As forces are immediately converted to impulses and applied , you must pass a correct step delta-time related to the simulation's hkStepInfo.
  188. inline void applyTorque(const hkReal deltaTime, const hkVector4& torque);
  189. //
  190. // DAMPING.
  191. //
  192. /// Naive momentum damping.
  193. inline hkReal getLinearDamping() const;
  194. /// Naive momentum damping.
  195. inline void setLinearDamping( hkReal d );
  196. /// Naive momentum damping.
  197. inline hkReal getAngularDamping() const;
  198. /// Naive momentum damping.
  199. inline void setAngularDamping( hkReal d );
  200. /// Gravity scaling accessor
  201. inline hkReal getGravityFactor( void ) const;
  202. /// Gravity scaling mutator
  203. inline void setGravityFactor( hkReal f );
  204. //
  205. // Clipping Velocities
  206. //
  207. /// Get the linear velocity cap for this rigid body
  208. inline hkReal getMaxLinearVelocity() const;
  209. /// Sets the linear velocity maximum
  210. inline void setMaxLinearVelocity( hkReal maxVel );
  211. /// Get the Angular velocity cap for this rigid body
  212. inline hkReal getMaxAngularVelocity() const;
  213. /// Sets the Angular velocity maximum
  214. /// The units used here are half revolutions per sec rather than the usual radians per second.
  215. inline void setMaxAngularVelocity( hkReal maxVel );
  216. //
  217. // DEACTIVATION
  218. //
  219. /// Sets the deactivator for this rigid body using a enum hkpRigidBodyDeactivator::DeactivatorType.
  220. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_RO] [this,HK_ACCESS_RW] );
  221. void setDeactivator( hkpRigidBodyDeactivator::DeactivatorType rigidBodyDeactivatorType );
  222. hkpRigidBodyDeactivator::DeactivatorType getDeactivatorType() const;
  223. //
  224. // COLLISION FILTERS
  225. //
  226. ///Gets the collision filter info. This is an identifying value used by collision filters
  227. /// - for example, if a group filter is used, this value would encode a collision group and a system group
  228. /// ###ACCESS_CHECKS###( [m_world,HK_ACCESS_IGNORE] [this,HK_ACCESS_RO] );
  229. HK_FORCE_INLINE hkUint32 getCollisionFilterInfo() const;
  230. ///Sets the collision filter info. This is an identifying value used by collision filters
  231. /// - for example, if a group filter is used, this value would encode a collision group and a system group
  232. /// Note: this function call does not update internal collision detection caches.
  233. ///       Please read hkpWorld::updateCollisionFilterOnEntity()
  234. /// ###ACCESS_CHECKS###( [m_world,HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  235. HK_FORCE_INLINE void setCollisionFilterInfo( hkUint32 info );
  236. //
  237. // QUALITY TYPE
  238. //
  239. /// ###ACCESS_CHECKS###( [m_world,HK_ACCESS_IGNORE] [this,HK_ACCESS_RO] );
  240. HK_FORCE_INLINE hkpCollidableQualityType getQualityType() const;
  241. /// Sets the quality type of this collidable.
  242. /// Note: Changing this value only affects new agents and constraints,
  243. /// existing collision agent are still unchanged.
  244. /// Please read hkpWorld::updateCollisionFilterOnEntity()
  245. /// ###ACCESS_CHECKS###( [m_world,HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  246. HK_FORCE_INLINE void setQualityType(hkpCollidableQualityType type);
  247. //
  248. // PENETRATION DEPTH
  249. //
  250. /// Gets the current allowed penetration depth.
  251. /// This is a hint to the continuous physics to allow some penetration for this object 
  252. /// to reduce CPU load. Note: this is not a hard limit but more a guideline to the engine.
  253. /// Depending on the qualityType, this allowed penetration can be breached sooner or later.
  254. /// See user guide on continuous physics for details.
  255. /// ###ACCESS_CHECKS###( [m_world,HK_ACCESS_IGNORE] [this,HK_ACCESS_RO] );
  256. HK_FORCE_INLINE hkReal getAllowedPenetrationDepth() const;
  257. /// Sets the current allowed penetration depth. See getAllowedPenetrationDepth for details.
  258. /// ###ACCESS_CHECKS###( [m_world,HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  259. HK_FORCE_INLINE void setAllowedPenetrationDepth( hkReal val );
  260. //
  261. // MOTION
  262. //
  263. /// Change the motion type. The motion type can be fixed, keyframed or dynamic.
  264. /// When changing to KEYFRAMED or DYNAMIC state you should specify appropriate activation state (acts analogically to 
  265. /// addEntity(entity, activationState)).
  266. /// You may choose to perform a full broadphase query to check whether new agents should be created or decide to only verify validity of currently
  267. /// present agents. The latter option is useful when pinning a body and we know that we only are going to remove the 
  268. /// body's collision agents with other fixed or keyframed bodies.
  269. ///
  270. /// Important: This function updates hkpCollidableQualityType of this rigid body when changing to/from fixed or keyframed state. When
  271. /// motion type is changed from a dynamic motion, the original quality type of the rigid body is stored in the new keyframed motion
  272. /// and replaced by a fixed/keyframed quality appropriately. When a body is then changed back to its dynamic state, its original 
  273. /// quality type is restored (along with its also-stored original dynamic motion).
  274. /// Similarly, when changing a motion's type from dynamic to fixed or keyframed, the original dynamic motion's data is saved and can be later 
  275. /// restored when the motion's type is switched back to dynamic.
  276. ///
  277. /// Note that this doesn't recreate agents (and doesn't switch between their predicitve and non-predictive versions), therefore
  278. /// having two non-continuously colliding dynamic objects, and fixing one of them, doesn't result in continuous collision detection,
  279. /// between the objects if the agent is already created. The current agent will be replaced by its continuous version only after the
  280. /// bodies separate and loose their broadphase overlap (when their agent is destroyed) and then come into proximity again (creating
  281. /// a new agent of type conforming to their current qualityType settings).
  282. ///
  283. /// -   Fixed (hkpMotion::MOTION_FIXED) entities are unmovable and effectively have infinite mass. 
  284. /// -   Keyframed (hkpMotion::MOTION_KEYFRAMED) entities can have their kinematics explicitly altered,
  285. ///     but ignore external impulses and forces e.g. from collisions or actions.
  286. /// -   Dynamic (e.g. hkpMotion::MOTION_DYNAMIC, hkpMotion::MOTION_BOX_INERTIA) entities are
  287. ///     affected by external forces and impulses.n
  288. ///
  289. /// For keyframed and fixed types there is some special treatment.
  290. /// To see whether a keyframed/fixed body has been changed from a dynamic state, use  
  291. /// hkpRigidBody::getStoredDynamicMotion().n
  292. /// Note: If an object is created as keyframed or fixed it cannot be changed to be dynamic later
  293. /// but dynamic objects can be changed to fixed or keyframed.n
  294. /// Note: When a body is made keyframed its velocities are zeroed. Its transform and centre of
  295. /// mass are preserved. It is expected that should a user wish to transfer velocities during such a
  296. /// transition they can get and set as necessary using getLinearVelocity(), getAngularVelocity() and
  297. /// setLinearVelocity(), setAngularVelocity(). This means that passing hkpMotion::MOTION_FIXED to setMotionType()
  298. /// will "stop" a body, but not move it. When a body is "unkeyframed" by passing hkpMotion::MOTION_DYNAMIC to setMotionType()
  299. /// it preserves both the transform <b>and</b> velocities of the current motion, as well as its original center of mass.
  300. /// It effectively continues on from the same position and with the same velocity that it had just
  301. /// prior to being "unkeyframed" but is now under dynamic control. All position and velocity information
  302. /// stored at the point in time when the body was actually "made" keyframed are lost, it is overwritten
  303. /// with the current values. Fixed bodies' velocities will always be zeroed.
  304. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_RW] [this,HK_ACCESS_RW] );
  305. void setMotionType( hkpMotion::MotionType newState, 
  306. hkpEntityActivation preferredActivationState = HK_ENTITY_ACTIVATION_DO_ACTIVATE, 
  307. hkpUpdateCollisionFilterOnEntityMode collisionFilterUpdateMode = HK_UPDATE_FILTER_ON_ENTITY_FULL_CHECK);
  308. /// Returns the body's motion type.
  309. inline hkpMotion::MotionType getMotionType() const;
  310. /// If the rigid body has been "set" to be keyframed, by passing hkpMotion::MOTION_KEYFRAMED to
  311. /// setMotionType(), this allows you to get the original dynamic motion (which is stored), and hence get
  312. /// the "unkeyframed" mass and inertia of the rigid body. Otherwise e.g. if the body was constructed
  313. /// using hkpMotion::MOTION_KEYFRAMED type, this function returns HK_NULL.
  314. hkpMotion* getStoredDynamicMotion();
  315. /// Const version of the above.
  316. const hkpMotion* getStoredDynamicMotion() const;
  317. /// Updates shape-based cached motion information in the rigid body. It also returns the extents (size of the AABB).
  318. void updateCachedShapeInfo (const hkpShape* shape, hkVector4& extentOut );
  319. //
  320. // Friction and Restitution
  321. //
  322. /// Returns the friction coefficient (dynamic and static) from the material.
  323. inline hkReal getFriction() const;
  324. #if defined HK_ENABLE_ROLLING_FRICITON_CODE
  325. /// Returns the rolling friction coefficient (dynamic and static) from the material.
  326. inline hkReal getRollingFriction() const;
  327. #endif
  328. /// Returns the default restitution from the material.
  329. //  restitution = bounciness (1 should give object all its energy back, 0 means it just sits there, etc.).
  330. inline hkReal getRestitution() const;
  331. /// Sets the friction coefficient of the material. Note: Setting this will not update existing contact information.
  332. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  333. void setFriction( hkReal newFriction, hkReal newRollingFriction = -1.0f );
  334. /// Sets the restitution coefficient of the material. Note: Setting this will not update existing contact information.
  335. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RW] );
  336. void setRestitution( hkReal newRestitution );
  337. //
  338. // LAZY CONSTRUCTION
  339. //
  340. /// Calls hkpEntity::setShape(), setMotionDeltaAngleMultiplier() and 
  341. /// setDeactivatorRadiusSqrd(). 
  342. /// NB: This function is NOT intended to be called at runtime i.e. after
  343. /// the hkpRigidBody has been added to an hkpWorld. It is intended as
  344. /// a feature for use during setup e.g. if a complex toolchain makes
  345. /// filling all members of hkpRigidBodyCinfo difficult.
  346. ///
  347. /// This function resets the shape of the rigid body, it also performs all necessary reinitialization
  348. /// except mass and volume properties.
  349. /// NB: It is NOT recommended to compute mass and volume properties at runtime, the calculations should
  350. /// be done by calling methods of the hkpInertiaTensorComputer class.
  351. ///
  352. /// Note: if you call this function for a body with no shape, it checks whether m_allowedPenetrationDepth is set to -1.0f
  353. /// if so it performs automatic calculation of allowedPenetrationDepth, otherwise it does not alter the value.
  354. /// If you alternatively call this function for a body with an non-null old shape, it always automatically recalculates 
  355. /// its new allowed penetration depth. You can later override it.
  356. /// Note2: this function removes and re-adds the body to broadphase, therefore all agents and all cached agents of 
  357. /// hkCachingShapePhantoms will be correctly reset.
  358. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_RW] [this,HK_ACCESS_RW] );
  359. hkWorldOperation::Result setShape(const hkpShape* shape);
  360. /// Given a rigidbody (this), return a new rigidbody that shares all static data
  361. /// such as the shapes, but clones the dynamic runtime data such as the current 
  362. /// motions and user defined properties.  This method does NOT clone any attached
  363. /// listeners.
  364. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_IGNORE] [this,HK_ACCESS_RO] );
  365. virtual hkpRigidBody* clone() const; 
  366. public:
  367. //
  368. // INTERNAL FUNCTIONS
  369. // 
  370. inline hkpMotion* getRigidMotion() const;
  371. hkBool checkPerformance() const;
  372. public:
  373. /// Internal function. Used by hkpWorldOperationUtil::setRigidBodyMotionType().
  374. static void HK_CALL createDynamicRigidMotion( hkpMotion::MotionType motionType, 
  375. const hkVector4& position, const hkQuaternion& rotation, 
  376. hkReal mass, const hkMatrix3& inertiaLocal, const hkVector4& centreOfMassLocal,
  377. hkReal maxLinearVelocity, hkReal maxAngularVelocity,
  378. hkpMaxSizeMotion* motionBufferOut );
  379. /// ###ACCESS_CHECKS###( [world,HK_ACCESS_RW] [entity,HK_ACCESS_RW] );
  380. static void HK_CALL updateBroadphaseAndResetCollisionInformationOfWarpedBody( hkpEntity* entity );
  381. protected:
  382. /// ###ACCESS_CHECKS###( [getWorld(),HK_ACCESS_RW] [this,HK_ACCESS_RW] );
  383. virtual hkMotionState* getMotionState();
  384. public:
  385. hkpRigidBody( class hkFinishLoadedObjectFlag flag ) : hkpEntity( flag ) {}
  386. };
  387. #include <Physics/Dynamics/Entity/hkpRigidBody.inl>
  388. #endif // HK_DYNAMICS2_RIGID_BODY_H
  389. /*
  390. * Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20090216)
  391. * Confidential Information of Havok.  (C) Copyright 1999-2009
  392. * Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
  393. * Logo, and the Havok buzzsaw logo are trademarks of Havok.  Title, ownership
  394. * rights, and intellectual property rights in the Havok software remain in
  395. * Havok and/or its suppliers.
  396. * Use of this software for evaluation purposes is subject to and indicates
  397. * acceptance of the End User licence Agreement for this product. A copy of
  398. * the license is included with this software and is also available at www.havok.com/tryhavok.
  399. */