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

其他游戏

开发平台:

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_WORLD_H
  9. #define HK_DYNAMICS2_WORLD_H
  10. #include <Common/Base/hkBase.h>
  11. #include <Common/Base/Config/hkConfigVersion.h>
  12. #include <Common/Base/DebugUtil/MultiThreadCheck/hkMultiThreadCheck.h>
  13. #include <Common/Base/Types/Physics/hkStepInfo.h>
  14. #include <Physics/ConstraintSolver/Solve/hkpSolverInfo.h>
  15. #include <Physics/Dynamics/World/hkpWorldCinfo.h>
  16. class hkpCollisionFilter;
  17. class hkpConvexListFilter;
  18. class hkpCollisionDispatcher;
  19. class hkpCollidable;
  20. struct hkpCollisionInput;
  21. struct hkpProcessCollisionInput;
  22. class hkpCollisionListener;
  23. class hkpTypedBroadPhaseDispatcher;
  24. struct hkpWorldRayCastInput;
  25. struct hkpWorldRayCastOutput;
  26. struct hkpLinearCastInput;
  27. class hkpRayHitCollector;
  28. class hkpCdPointCollector;
  29. class hkpCdBodyPairCollector;
  30. class hkpBroadPhase;
  31. class hkpBroadPhaseHandle;
  32. class hkAabb;
  33. class hkpWorldObject;
  34. class hkpEntity;
  35. class hkpEntityListener;
  36. class hkpRigidBody;
  37. class hkpPhantom;
  38. class hkpPhantomListener;
  39. class hkpPhantomBroadPhaseListener;
  40. class hkpEntityEntityBroadPhaseListener;
  41. class hkpBroadPhaseBorderListener;
  42. class hkpAction;
  43. class hkpActionListener;
  44. class hkpConstraintInstance;
  45. class hkpConstraintData;
  46. class hkpConstraintListener;
  47. class hkpPhysicsSystem;
  48. class hkpSimulationIsland;
  49. class hkpContactMgrFactory;
  50. struct hkpMtThreadStructure;
  51. class hkpWorldPostSimulationListener;
  52. class hkpWorldPostIntegrateListener;
  53. class hkpWorldPostCollideListener;
  54. class hkpWorldDeletionListener;
  55. class hkpIslandActivationListener;
  56. class hkpContactImpulseLimitBreachedListener;
  57. class hkpIslandPostIntegrateListener;
  58. class hkpIslandPostCollideListener;
  59. class hkStepInfo;
  60. class hkWorldPairwiseBackstepFilter;
  61. class hkpSimulation;
  62. class hkpWorldOperationQueue;
  63. struct hkpDebugInfoOnPendingOperationQueues;
  64. class hkpWorldMaintenanceMgr;
  65. class hkWorldMemoryAvailableWatchDog;
  66. class hkpBodyOperation;
  67. class hkJobQueue;
  68. class hkJobThreadPool;
  69. class hkdWorld;
  70. namespace hkWorldOperation { struct BaseOperation; class UserCallback; }
  71. struct hkOperationParameter;
  72. #if defined HK_DEBUG
  73. //# define HK_ENABLE_EXTENSIVE_WORLD_CHECKING
  74. #endif
  75. extern "C" void HK_CALL hkAgentNnMachine_AssertTrackValidity( struct hkpAgentNnTrack& track );
  76. //#define CHECK_TRACK(track) hkAgentNnMachine_AssertTrackValidity(track)
  77. #define CHECK_TRACK(track) 
  78. /// Allows you optimize the  hkpWorld::updateCollisionFilterOnWorld call
  79. enum hkpUpdateCollisionFilterOnWorldMode
  80. {
  81. /// Full filter filter
  82. HK_UPDATE_FILTER_ON_WORLD_FULL_CHECK,
  83. /// Recheck filter but only check for disabled entity-entity collisions
  84. /// which have been enabled before
  85. HK_UPDATE_FILTER_ON_WORLD_DISABLE_ENTITY_ENTITY_COLLISIONS_ONLY,
  86. };
  87. /// Allows you to optimize you hkpWorld::updateCollisionFilterOnEntity call
  88. enum hkpUpdateCollisionFilterOnEntityMode
  89. {
  90. /// Do a full check
  91. HK_UPDATE_FILTER_ON_ENTITY_FULL_CHECK,
  92. /// Recheck filter but only check for disabled entity-entity collisions
  93. /// which have been enabled before
  94. HK_UPDATE_FILTER_ON_ENTITY_DISABLE_ENTITY_ENTITY_COLLISIONS_ONLY
  95. };
  96. /// Activation hints when calling hkpWorld::addEntity
  97. enum hkpEntityActivation
  98. {
  99. /// Tries to add the body in an inactive state. However if the body overlaps with an
  100. /// active body, it gets activated
  101. HK_ENTITY_ACTIVATION_DO_NOT_ACTIVATE,
  102. /// Always activate this body and overlapping bodies
  103. HK_ENTITY_ACTIVATION_DO_ACTIVATE
  104. };
  105. /// The hkUpdateCollectionFilter specifies whether you want to reevaluate
  106. /// all the sub-shape collisions with the world's shape collection filter. Typical example of this is
  107. /// destructible terrain. So if you just disabled the collision of a bullet and a car, you do not
  108. /// need to recheck existing landscape collisions and can set
  109. /// updateShapeCollectionFilter to HK_UPDATE_COLLECTION_FILTER_IGNORE_SHAPE_COLLECTIONS
  110. enum hkpUpdateCollectionFilterMode
  111. {
  112. /// Assume that no single shapes in a shape collections changed their filter status
  113. HK_UPDATE_COLLECTION_FILTER_IGNORE_SHAPE_COLLECTIONS,
  114. /// Recheck all subshapes in a shape collection
  115. HK_UPDATE_COLLECTION_FILTER_PROCESS_SHAPE_COLLECTIONS
  116. };
  117. /// A structure used by the hkpWorld that groups together solver and step time information.
  118. struct hkpWorldDynamicsStepInfo
  119. {
  120. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, hkpWorldDynamicsStepInfo );
  121. hkStepInfo   m_stepInfo;
  122. hkpSolverInfo m_solverInfo;
  123. };
  124. /// This structure is currently only used for multi threaded simulations. It controls how the multi threading is run.
  125. struct hkpMultithreadConfig
  126. {
  127. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, hkpMultithreadConfig );
  128. hkpMultithreadConfig();
  129. /// This variable is used to control when the constraints of a simulation island are solved in
  130. /// single threaded or multithreaded mode. On PC and XBOX360 this value is 70, which means that
  131. /// an island must have more than 70 constraints to be solved in multithreaded mode. If it
  132. /// is set to 0 then the constraints of all simulation islands will be solved in multithreaded mode.
  133. /// The reason it is not set to 0 by default is because there is a small overhead in setting up
  134. /// multithreading constraints for a simulation island, which can be significant for small islands.
  135. /// On the PLAYSTATION(R)3 this variable defaults to 4.  SPU constraint setup only happens if the island
  136. /// has more constraints than are specified by this variable.
  137. hkUint32 m_maxNumConstraintsSolvedSingleThreaded;
  138. };
  139. /// See hkpWorld::stepDeltaTime for details
  140. enum hkpStepResult
  141. {
  142. /// The call to stepDelta time was a processed to the end
  143. HK_STEP_RESULT_SUCCESS,
  144. /// The engine predicted that it would run out of memory before doing any work
  145. HK_STEP_RESULT_MEMORY_FAILURE_BEFORE_INTEGRATION,
  146. /// The collide call failed as some collision agents were allocated too much memory
  147. HK_STEP_RESULT_MEMORY_FAILURE_DURING_COLLIDE,
  148. /// The advanceTime call failed during TOI solving
  149. HK_STEP_RESULT_MEMORY_FAILURE_DURING_TOI_SOLVE,
  150. };
  151. /// The hkpWorld is a container for the simulation's physical objects.  It also steps the simulation forward in time.
  152. /// You add elements (including rigid bodies, actions, constraints, and listeners) to the simulation by adding them to the hkpWorld.
  153. class hkpWorld : public hkReferencedObject
  154. {
  155. public:
  156. //+vtable(true)
  157. //+serializable(false)
  158. HK_DECLARE_CLASS_ALLOCATOR(HK_MEMORY_CLASS_WORLD);
  159.         HK_DECLARE_REFLECTION();
  160. /// Creates a world with the given construction information
  161. hkpWorld(const hkpWorldCinfo& info, unsigned int sdkversion = HAVOK_SDK_VERSION_NUMBER );
  162. /// Get construction info for this instance.
  163. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  164. void getCinfo(hkpWorldCinfo& info) const;
  165. //
  166. // hkpWorld Operations:
  167. //
  168. //  Adding/Removing Instances/BatchesOfInstances of Entities/Constraints/Actions/Phantoms
  169. //
  170. /// Adds the specified entity to the world and returns its pointer
  171. /// or returns HK_NULL if adding the body is delayed.
  172. /// Lets you specify the desired activation state.
  173. /// Usage info: Note that even if you add a body inactive, it may be immediately automatically activated
  174. ///             by the engine due to overlaps with other bodies.
  175. /// Note: When using HK_ENTITY_ACTIVATION_DO_ACTIVATE parameter, the entity is added in the active state,
  176. ///       however no activationCallbacks are called.
  177. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  178. hkpEntity* addEntity( hkpEntity* entity, hkpEntityActivation initialActivationState = HK_ENTITY_ACTIVATION_DO_ACTIVATE);
  179. /// Removes the specified entity from the world
  180. /// During a simulation step the removal of the entity is delayed until it is safe to do so.
  181. /// returns true if removed immediately false if delayed.
  182. hkBool removeEntity( hkpEntity* entity);
  183. /// Efficiently add a group of entities at the same time.  Will not be as efficient when
  184. /// adding a small number of entities, in that case use addEntity.
  185. /// Lets you specify the desired activation state.
  186. /// Warning: When adding entities inactive: all entities are added in the same island,
  187. ///          therefore any overlap with an active entity (already inserted into the world)
  188. ///          causes activation of the whole island.
  189. /// Note: When using HK_ENTITY_ACTIVATION_DO_ACTIVATE parameter, the entity is added in the active state,
  190. ///       however no activationCallbacks are called.
  191. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  192. void addEntityBatch( hkpEntity*const* entityBatch, int numEntities, hkpEntityActivation initialActivationState = HK_ENTITY_ACTIVATION_DO_ACTIVATE);
  193. /// Efficiently remove a group of entities at the same time.  Will not be as efficient when
  194. /// removing a small number of entities, in that case use removeEntity.
  195. void removeEntityBatch( hkpEntity*const* entityBatch, int numEntities );
  196. //
  197. // Constraint addition and removal
  198. //
  199. /// Adds the specified constraint to the world
  200. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  201. hkpConstraintInstance* addConstraint( hkpConstraintInstance* constraint);
  202. /// Removes the specified constraint from the world
  203. /// returns true if removed immediately false if delayed
  204. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  205. hkBool removeConstraint( hkpConstraintInstance* constraint);
  206. /// Utility function for creating and adding a specified constraint instance to the world
  207. hkpConstraintInstance* createAndAddConstraintInstance( hkpRigidBody* bodyA, hkpRigidBody* bodyB, hkpConstraintData* constraintData );
  208. //
  209. // Actions
  210. //
  211. /// Adds the specified action to the world. A reference to the action is added to every entity on the action's list
  212. /// of entities. All those entities must already by placed in an hkpWorld.
  213. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  214. hkpAction* addAction( hkpAction* action );
  215. /// Remove the specified action from the world and removes its reference from each entity that it was connected to.
  216. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  217. void removeAction( hkpAction* action );
  218. /// Remove the specified action from the world and removes its reference from each entity that it was connected to.
  219. /// It bypasses the operation delay framework, there fore you _MUST_BE_SURE_ that _IT_IS_SAFE_ to use it.
  220. /// Info: use this only in hkpAction::entityRemovedCallback
  221. /// Non-symmetric function. Only needed to be used explicitly when removing an entity causes removal of an action in a callback.
  222. /// addActionImmediately not needed.
  223. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  224. void removeActionImmediately( hkpAction* action );
  225. //
  226. // Phantoms
  227. //
  228. /// Add the phantom to the world
  229. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  230. hkpPhantom* addPhantom( hkpPhantom* phantom );
  231. /// Add multiple phantoms to the world
  232. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  233. void addPhantomBatch( hkpPhantom*const* phantomBatch, int numPhantoms );
  234. /// Remove the phantom from the world
  235. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  236. void removePhantom( hkpPhantom* phantom );
  237. /// Remove multiple phantoms from the world
  238. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  239. void removePhantomBatch( hkpPhantom*const* phantomBatch, int numPhantoms );
  240. /// Activates all entities whose aabb overlaps with the specified region
  241. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  242. void activateRegion( const hkAabb& aabb );
  243. //
  244. // Systems (bodies, actions and phantoms all together). For instance
  245. // a vehicle or a ragdoll.
  246. /// Add a hkpPhysicsSystem to the world. The world does not
  247. /// store or reference the system struct itself, just
  248. /// uses the data held to batch add to the world.
  249. void addPhysicsSystem( const hkpPhysicsSystem* sys );
  250. /// Remove a hkpPhysicsSystem from the world.
  251. /// The world will just look through the lists in the given system
  252. /// and remove all found. It does not alter the system struct itself.
  253. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  254. void removePhysicsSystem( const hkpPhysicsSystem* sys );
  255. //
  256. // Fixed rigid body
  257. //
  258. /// Gets the world's fixed rigid body. This is a fixed body that can be used to constrain an object to
  259. /// a position in world space without needing to create an additional fixed object. The world's fixed
  260. /// body differs from 'normal' rigid bodies in a number of ways, including but not limited to the
  261. /// following:<br>
  262. /// It doesn't have a shape/collision representation and so it never collides with anything.<br>
  263. /// It doesn't have a broadphase entry and so it cannot go outside the broadphase, resulting in a
  264. /// potential performance hit as 'normal' rigid bodies can.
  265. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  266. inline hkpRigidBody* getFixedRigidBody();
  267. /// Gets read access to the world's fixed rigid body.
  268. /// See the non-const version of this function for more information.
  269. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  270. inline const hkpRigidBody* getFixedRigidBody() const;
  271. //
  272. //  Collision filter update methods
  273. //
  274. /// This method should be called if you have altered the collision filtering information for this entity.
  275. /// Note: this does not activate the entity.
  276. /// The collisionFilterUpdateMode allows you to do an optimization: Only previously enabled entity entity collisions are
  277. /// checked. However entity-phantom or new entity-entity collision are ignored.
  278. /// The updateShapeCollectionFilter specifies whether you want to reevaluate
  279. /// all the sub-shape collisions with the world's shape collection filter. Typical example of this is
  280. /// destructible terrain. So if you just disabled the collision of a bullet and a car, you do not
  281. /// need to recheck existing landscape collisions and can set
  282. /// updateShapeCollectionFilter to HK_UPDATE_COLLECTION_FILTER_IGNORE_SHAPE_COLLECTIONS
  283. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] [entity,HK_ACCESS_RW] );
  284. void updateCollisionFilterOnEntity( hkpEntity* entity,
  285.                                 hkpUpdateCollisionFilterOnEntityMode updateMode,
  286. hkpUpdateCollectionFilterMode updateShapeCollectionFilter);
  287. /// This method should be called if you have altered the collision filtering information for this pair of entities
  288. void reenableCollisionBetweenEntityPair( hkpEntity* entityA, hkpEntity* entityB );
  289. /// This method should be called if you have altered the collision filtering information for this phantom. Read updateCollisionFilterOnEntity() for details
  290. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] [phantom,HK_ACCESS_RW] );
  291. void updateCollisionFilterOnPhantom( hkpPhantom* phantom,
  292.  hkpUpdateCollectionFilterMode updateShapeCollectionFilter );
  293. /// This method should be called if you have changed the collision filter for the world.
  294. ///
  295. /// WARNING: This method is very slow. It involves re-evaluating all the broadphase aabbs in the system.
  296. /// You should only ever call this at startup time.
  297. /// updateMode allows you to use a shortcut if you only want to disable previously enabled entity entity
  298. /// collisions.
  299. /// The updateShapeCollectionFilter specifies whether you want to reevaluate
  300. /// all the sub-shape collisions with the world's shape collection filter. Typical example of this is
  301. /// destructible terrain. So if you just disabled the collision of a bullet and a car, you do not
  302. /// need to recheck existing landscape collisions and can set
  303. /// updateShapeCollectionFilter to HK_UPDATE_COLLECTION_FILTER_IGNORE_SHAPE_COLLECTIONS
  304. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  305. void updateCollisionFilterOnWorld( hkpUpdateCollisionFilterOnWorldMode updateMode,
  306.    hkpUpdateCollectionFilterMode updateShapeCollectionFilter );
  307. enum ReintegrationRecollideMode
  308. {
  309. RR_MODE_REINTEGRATE = 1, // only reintegrates the motion in the middle of a physics step
  310. RR_MODE_RECOLLIDE_BROADPHASE = 2, // only reapplies the broadphase
  311. RR_MODE_RECOLLIDE_NARROWPHASE = 4, // only reapplies the narrowphase
  312. RR_MODE_ALL = 7
  313. };
  314. /// Reintegrates bodies immediately.
  315. /// This function allows for calling parts of the physics pipeline selectively
  316. /// in single rigid bodies. This is especially useful when you
  317. /// think the normal pipeline isn't good enough.
  318. /// Examples:
  319. /// - When physics and frame rate run at different rates (especially when the physics
  320. ///       is run at a much lower rate), setting velocity of a rigid body will have no effect
  321. ///       till the next physics step. This can lead to very small
  322. ///       delays between a player action and the expected reaction. With this function
  323. ///       you can force the reintegration of a set of entities at the current frame time (mode = RR_MODE_ALL)
  324. ///     - When you add an object to the world, it will pick up contact information only at the
  325. ///       end of the next physics step, so there are no contacts for the next frame. Calling this
  326. ///       function immediately after adding the object with mode = RR_MODE_RECOLLIDE_NARROWPHASE finds the initial set of contacts
  327. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  328. void reintegrateAndRecollideEntities( hkpEntity** entityBatch, int numEntities, ReintegrationRecollideMode mode = RR_MODE_ALL );
  329. //
  330. // Phantoms
  331. //
  332. /// Get a list of all the phantoms which have been added to the world
  333. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  334. inline const hkArray<hkpPhantom*>& getPhantoms() const;
  335. //
  336. // Gravity
  337. //
  338. /// Sets the gravity value for the world. This does not wake up objects
  339. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  340. void setGravity( const hkVector4& gravity );
  341. /// Gets the world's gravity value.
  342. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  343. inline const hkVector4& getGravity() const;
  344. //
  345. // Simulation Control
  346. //
  347. /// This utility function may be called to initialize the contact points for a set of entities added to the world.
  348. /// By default contact points are evaluated conservatively, for simulation efficiency.
  349. /// However this can lead to a slight initial jitter when objects are added.  The same applies for
  350. /// objects which have had their collision agents deleted upon deactivation when they reactivate. (See
  351. /// the helper class hkpSuspendInactiveAgentsUtil for details. ) This function helps to remove this jitter by
  352. /// trying to find all the initial relevant contact points for a set of entities.
  353. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  354. void findInitialContactPoints( hkpEntity** entities, int numEntities );
  355. /// This simply calls initializeContactPoints for all objects in the world. It is a utility function
  356. /// which can be called after the world has been initialized and all objects added to it.
  357. void findInitialContactPointsOfAllEntities( );
  358. /// Gets the memory usage required to complete the next integration step
  359. /// This function is called internally to prevent the memory usage breaching the critical memory limit in
  360. /// hkMemory.
  361. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  362. int getMemUsageForIntegration();
  363. /// Calculate the memory statistics for the world, and all objects owned by the world
  364. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  365.         void calcContentStatistics( hkStatisticsCollector* collector, const hkClass* cls ) const;
  366. /// checks the current state of the engine using the hkCheckDeterminismUtil
  367. /// ###ACCESS_CHECKS###( [island->m_world,HK_ACCESS_RO] [island,HK_ACCESS_RW] );
  368. void checkDeterminism();
  369. /// Get the memory "watch dog" used by the world. By default this is HK_NULL, i.e. the memory
  370. /// for the world is not checked. If this is set, hkpWorldMemoryWatchDog::watchMemory will be
  371. /// called every step, which gives the hkpWorldMemoryWatchDog a chance to prevent the memory
  372. /// exceeding a desired threshold.
  373. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  374. hkWorldMemoryAvailableWatchDog* getMemoryWatchDog( ) const;
  375. /// Set the memory "watch dog" used by the world. By default this is HK_NULL, i.e. the memory
  376. /// for the world is not checked. If this is set, hkpWorldMemoryWatchDog::watchMemory will be
  377. /// called every step, which gives the hkpWorldMemoryWatchDog a chance to prevent the memory
  378. /// exceeding a desired threshold.
  379. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  380. void setMemoryWatchDog( hkWorldMemoryAvailableWatchDog* watchDog );
  381. //
  382. // Multithreaded Access
  383. //
  384. /// Locks the world in a multithreaded environment.
  385. /// This can only be called outside any step function and should
  386. /// only be used for asynchronous queries like raycast, etc.
  387. /// lock() and unlock() acquire and release critical sections, so they are quite slow.
  388. /// For this reason it is best to lock the world and do many operations on the world when you have
  389. /// acquired the lock before unlocking it.
  390. /// If you use your own synchronization mechanisms you don't need to call our implementation of lock / unlock,
  391. /// but you must ensure multiple threads don't access the world simultaneously.
  392. /// When using your own synchronization mechanisms you should also call markForRead or markForWrite
  393. /// to let our debugging utilities know that the world has been locked appropriately.
  394. /// Read the multithreading user guide about details
  395. void lock();
  396. /// Locks the world as read-only in a multithreaded environment.
  397. /// Needed when executing collision query jobs.
  398. /// See also lock().
  399. void lockReadOnly();
  400. /// Unlocks the world. Opposite of lock()
  401. void unlock();
  402. /// Unlocks the world. Opposite of lockReadOnly()
  403. void unlockReadOnly();
  404. /// checks if the world is in an unmarked, unlocked state
  405. bool checkUnmarked();
  406. // Internal function: Locks all entities in this simulation island and in the fixed island for constraint updates
  407. void lockIslandForConstraintUpdate( hkpSimulationIsland* island );
  408. // Internal function: Locks all entities in this simluation island and in the fixed island for constraint updates
  409. void lockForIslandSplit( hkpSimulationIsland* island );
  410. // Internal function: opposite of lockIslandForConstraintUpdate
  411. void unlockIslandForConstraintUpdate( hkpSimulationIsland* island );
  412. // Internal function: opposite of lockForIslandSplit
  413. void unlockForIslandSplit( hkpSimulationIsland* island );
  414. //
  415. // Multithreaded Access checks
  416. //
  417. enum MtAccessChecking
  418. {
  419. MT_ACCESS_CHECKING_ENABLED = 0,
  420. MT_ACCESS_CHECKING_DISABLED
  421. };
  422. /// Enable or disable multithreaded access checking
  423. /// By default this is enabled if the world simulation type is SIMULATION_TYPE_MULTITHREADED
  424. /// and false is it is anything else.
  425. inline void setMultithreadedAccessChecking( MtAccessChecking accessCheckState );
  426. /// Get whether multithreaded access checking is enabled
  427. /// By default this is enabled if the world simulation type is SIMULATION_TYPE_MULTITHREADED
  428. /// and false is it is anything else.
  429. inline MtAccessChecking getMultithreadedAccessChecking() const;
  430. /// Mark this class and all child classes for read only access for this thread
  431. /// Note: This is only for debugging and does not wait to get exclusive access,
  432. /// but simply assert if another thread marked the hkpWorld. You must read the
  433. /// user guide about multithreading to use this.
  434. void markForRead( ) const;
  435. /// Mark this class and all child classes for read write access for this thread
  436. /// Note: This is only for debugging and does not wait to get exclusive access,
  437. /// but simply assert if another thread marked the hkpWorld. You must read the
  438. /// user guide about multithreading to use this.
  439. void markForWrite( );
  440. /// Undo lockForRead
  441. /// Note: This is only for debugging and does not wait to get exclusive access,
  442. /// but simply assert if another thread locked the hkpWorld. You must read the
  443. /// user guide about multithreading to use this.
  444. void unmarkForRead( ) const;
  445. /// Unlock For write
  446. /// Note: This is only for debugging and does not wait to get exclusive access,
  447. /// but simply assert if another thread locked the hkpWorld. You must read the
  448. /// user guide about multithreading to use this.
  449. void unmarkForWrite();
  450. //
  451. // Event Handling
  452. //
  453. /// Adds the specified listener to the world
  454. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  455. void addActionListener( hkpActionListener* worldListener );
  456. /// Removes the specified listener from the world
  457. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  458. void removeActionListener( hkpActionListener* worldListener );
  459. /// Adds the specified listener to the world
  460. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  461. void addConstraintListener( hkpConstraintListener* worldListener );
  462. /// Removes the specified listener from the world
  463. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  464. void removeConstraintListener( hkpConstraintListener* worldListener );
  465. /// Adds the specified listener to the world
  466. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  467. void addEntityListener( hkpEntityListener* worldListener );
  468. /// Removes the specified listener from the world
  469. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  470. void removeEntityListener( hkpEntityListener* worldListener );
  471. /// Adds the specified listener to the world
  472. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  473. void addPhantomListener( hkpPhantomListener* worldListener );
  474. /// Removes the specified listener from the world
  475. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  476. void removePhantomListener( hkpPhantomListener* worldListener );
  477. /// Adds a listener which listens to ALL entity activations.
  478. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  479. void addIslandActivationListener( hkpIslandActivationListener* worldListener );
  480. /// Removes the specified listener from the world
  481. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  482. void removeIslandActivationListener( hkpIslandActivationListener* worldListener );
  483. /// Adds the specified listener to the world
  484. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  485. void addWorldPostCollideListener( hkpWorldPostCollideListener* worldListener );
  486. /// Removes the specified listener from the world
  487. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  488. void removeWorldPostCollideListener( hkpWorldPostCollideListener* worldListener );
  489. /// Adds the specified listener to the world
  490. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  491. void addWorldPostSimulationListener( hkpWorldPostSimulationListener* worldListener );
  492. /// Removes the specified listener from the world
  493. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  494. void removeWorldPostSimulationListener( hkpWorldPostSimulationListener* worldListener );
  495. /// Adds the specified listener to the world
  496. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  497. void addWorldPostIntegrateListener( hkpWorldPostIntegrateListener* worldListener );
  498. /// Removes the specified listener from the world
  499. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  500. void removeWorldPostIntegrateListener( hkpWorldPostIntegrateListener* worldListener );
  501. /// Adds the specified listener to the world
  502. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  503. void addIslandPostCollideListener( hkpIslandPostCollideListener* islandListener );
  504. /// Removes the specified listener from the world
  505. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  506. void removeIslandPostCollideListener( hkpIslandPostCollideListener* islandListener );
  507. /// Adds the specified listener to the world
  508. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  509. void addIslandPostIntegrateListener( hkpIslandPostIntegrateListener* islandListener );
  510. /// Removes the specified listener from the world
  511. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  512. void removeIslandPostIntegrateListener( hkpIslandPostIntegrateListener* islandListener );
  513. /// Adds a listener which listens to ALL collisions.
  514. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  515. void addCollisionListener( hkpCollisionListener* worldListener );
  516. /// Removes a world collision listener.
  517. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  518. void removeCollisionListener( hkpCollisionListener* worldListener);
  519. /// Add a listener which receives events when the world is deleted
  520. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  521. void addWorldDeletionListener( hkpWorldDeletionListener* worldListener );
  522. /// Remove a listener which receives events when the world is deleted
  523. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  524. void removeWorldDeletionListener( hkpWorldDeletionListener* worldListener );
  525. /// Add a listener which receives events when contact impulses breach their limit
  526. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  527. void addContactImpulseLimitBreachedListener( hkpContactImpulseLimitBreachedListener* listener );
  528. /// Remove a listener which receives events when contact impulses breach their limit
  529. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  530. void removeContactImpulseLimitBreachedListener( hkpContactImpulseLimitBreachedListener* listener );
  531. //
  532. // Collision detection
  533. //
  534. /// Gets write access the broadphase owned by the world
  535. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  536. inline hkpBroadPhase* getBroadPhase();
  537. /// Gets read only access to the broadphase owned by the world
  538. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  539. inline const hkpBroadPhase* getBroadPhase() const;
  540. /// Get read access to the collision input. This is needed to manually query collision agents.
  541. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  542. inline const hkpProcessCollisionInput* getCollisionInput() const;
  543. /// Get read/write access to the collision input. You should only need this function if you really intent to modify its values persistently, otherwise make a local modifier copy.
  544. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  545. inline hkpProcessCollisionInput* getCollisionInputRw();
  546. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  547. inline hkpSolverInfo* getSolverInfo();
  548. /// Gets the collision dispatcher owned by the world.
  549. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  550. inline hkpCollisionDispatcher* getCollisionDispatcher() const;
  551. /// Gets the collision filter.
  552. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  553. inline const hkpCollisionFilter* getCollisionFilter() const;
  554. /// Set the collision filter. This is used by the world by default when it calls the collision detector.
  555. /// WARNING: This should only be done before any objects are added to this world.
  556. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  557. void setCollisionFilter( hkpCollisionFilter* filter,
  558.  hkBool             runUpdateCollisionFilterOnWorld = true,
  559.  hkpUpdateCollisionFilterOnWorldMode checkBroadPhaseMode = HK_UPDATE_FILTER_ON_WORLD_FULL_CHECK,
  560.  hkpUpdateCollectionFilterMode       updateShapeCollectionFilter = HK_UPDATE_COLLECTION_FILTER_PROCESS_SHAPE_COLLECTIONS );
  561. /// Cast a ray into the world and get the closest hit.
  562. /// Note: it uses the hkpWorld::getCollisionFilter() for filtering
  563. /// This function uses a ray-cast function for traversing the broadphase, so for
  564. /// long raycasts it is more applicable than hkpAabbPhantom::castRay
  565. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  566. void castRay(const hkpWorldRayCastInput& input, hkpWorldRayCastOutput& output ) const;
  567. /// Cast a ray into the world and do a callback for every hit.
  568. /// Note: it uses the hkpWorld::getCollisionFilter() for filtering
  569. /// This function uses a ray-cast function for traversing the broadphase, so for
  570. /// long raycasts it is more applicable than hkpAabbPhantom::castRay
  571. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  572. void castRay(const hkpWorldRayCastInput& input, hkpRayHitCollector& collector ) const;
  573. /// Cast a shape within the world.
  574. /// The castCollector collects all potential hits.<br>
  575. /// Note that the distance stored within the castCollector is a hitFraction (between 0 and 1.0) and
  576. /// not a distance.<br>
  577. /// This function uses an aabb-cast function for traversing the broadphase, so for
  578. /// long linear casts it will perform better than hkpShapePhantom::linearCast().
  579. /// The [optional] startPointCollector returns all the closest points
  580. /// at the start point of the linear cast. If you do not want this functionality, pass HK_NULL as the
  581. /// "startCollector".
  582. /// If you want to use this function using an hkpBroadPhaseAabbCache simply use the underlying hkpWorldLinearCaster
  583. /// (see implementation of hkpWorld::linearCast for details)
  584. /// Note that shape radius is considered - you may want to set the radius of the cast shape to zero.
  585. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  586. void linearCast( const hkpCollidable* collA, const hkpLinearCastInput& input, hkpCdPointCollector& castCollector, hkpCdPointCollector* startCollector = HK_NULL ) const;
  587. /// Get the closest points to a hkpCollidable (= [shape,transform,filterInfo] ).
  588. /// Note: If you have to call this function every step for a given object, use the hkpShapePhantom::getClosestPoints()
  589. /// By default, you should pass a pointer to world->getCollisionInput() via hkpCollisionInput* input. However you
  590. /// can use this parameter to pass in your own collision input
  591. /// structure, and change the shape collection collision filter, and the collision tolerance used.
  592. /// (Note: If using your own collision input, make sure you start by copying the world collision input, so that
  593. /// you use the default hkpCollisionDispatcher).
  594. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  595. void getClosestPoints( const hkpCollidable* collA, const hkpCollisionInput& input, hkpCdPointCollector& collector) const;
  596. /// Get all shapes which are penetrating the collidable.
  597. /// Note: If you have to call this function every step for a given object, use the hkpShapePhantom version
  598. /// By default, you should pass a pointer to world->getCollisionInput() via hkpCollisionInput* input. However you
  599. /// can use this parameter to pass in your own collision input
  600. /// structure, and change the shape collection collision filter, and the collision tolerance used.
  601. /// (Note: If using your own collision input, make sure you start by copying the world collision input, so that
  602. /// you use the default hkpCollisionDispatcher).
  603. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  604. void getPenetrations( const hkpCollidable* collA, const hkpCollisionInput& input, hkpCdBodyPairCollector& collector) const;
  605. /// Gets the current broadphase border, could be null.
  606. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  607. class hkpBroadPhaseBorder* getBroadPhaseBorder() const;
  608. /// Sets a custom broadphase border.
  609. /// By default the hkpWorld constructor checks the
  610. /// hkpWorldCinfo.m_broadPhaseBorderBehaviour field and will create a default
  611. /// broadphase border if needed. Real hkpWorldCinfo.m_broadPhaseBorderBehaviour for details
  612. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  613. void setBroadPhaseBorder( hkpBroadPhaseBorder* bpb );
  614. /// See hkpBroadPhase::shiftBroadPhase() for details.
  615. enum CachedAabbUpdate
  616. {
  617. SHIFT_BROADPHASE_UPDATE_ENTITY_AABBS,
  618. SHIFT_BROADPHASE_IGNORE_ENTITY_AABBS
  619. };
  620. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  621. void shiftBroadPhase( const hkVector4& shiftDistance, hkVector4& effectiveShiftDistanceOut, CachedAabbUpdate updateAabbs );
  622. //
  623. // Simulation Island access
  624. //
  625. /// Get the active simulation islands. You can use this function to access all the active entities, constraints and actions.
  626. /// NOTE: This should not be used during simulation, as it will generally result in sub-optimal performance.
  627. inline const hkArray<hkpSimulationIsland*>& getActiveSimulationIslands() const;
  628. /// Get the inactive simulation islands. You can use this function to access all the inactive entities, constraints and actions.
  629. /// NOTE: This should not be used during simulation, as it will generally result in sub-optimal performance.
  630. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  631. inline const hkArray<hkpSimulationIsland*>& getInactiveSimulationIslands() const;
  632. /// Get the fixed simulation island. You can use this function to access all the fixed entities.
  633. /// There is only one fixed island, and it contains no actions or constraints.
  634. /// NOTE: This should not be used during simulation, as it will generally result in sub-optimal performance.
  635. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  636. inline const hkpSimulationIsland* getFixedIsland() const;
  637. //
  638. // Stepping the world (Single threaded)
  639. //
  640. /// Advances the state of the simulation by the amount of time.
  641. /// This is a single threaded call.
  642. /// The interface to multi-threading simulation is below.
  643. hkpStepResult stepDeltaTime( hkReal physicsDeltaTime );
  644. //
  645. // "Half" stepping (Single threaded only)
  646. //
  647. /// Integrate and solve constraints between all bodies.
  648. /// Using this call instead of stepDeltaTime() allows you to distribute your
  649. /// physics computation for a single physics step between multiple game steps.
  650. /// Normally this returns HK_STEP_RESULT_SUCCES, but may return a failure code on memory failure.
  651. /// In this case memory should be freed (by removing objects from the world) and the function should be called again.
  652. /// Please consult the user guide for more details.
  653. hkpStepResult integrate( hkReal physicsDeltaTime );
  654. /// Perform collision detection.
  655. /// Using this call instead of stepDeltaTime() allows you to distribute your
  656. /// physics computation for a single physics step between multiple game steps.
  657. /// Normally this returns HK_STEP_RESULT_SUCCES, but may return a failure code on memory failure.
  658. /// In this case memory should be freed (by removing objects from the world) and the function should be called again.
  659. /// Please consult the user guide for more details.
  660. hkpStepResult collide();
  661. /// Advance the current time of the world.
  662. /// For discrete simulation, this simply advances the current time value,
  663. /// For continuous simulations, this will also perform the continuous physics calculations.
  664. /// Using this call instead of stepDeltaTime() allows you to distribute your
  665. /// physics computation for a single physics step between multiple game steps.
  666. /// This call is also used for asynchronous simulation:
  667. /// It will advance the time to the next PSI step, unless
  668. /// an earlier frame timer marker has been set (see setFrameTimeMarker).
  669. /// Normally this returns HK_STEP_RESULT_SUCCES, but may return a failure code on memory failure.
  670. /// In this case memory should be freed (by removing objects from the world) and the function should be called again.
  671. /// Please consult the user guide for more details.
  672. hkpStepResult advanceTime();
  673. //
  674. // Asynchronous Stepping
  675. //
  676. /// This call can be used to step the world asynchronously.  If you set a marker, then
  677. /// when advanceTime is called, it will advance either to this marker, or the current
  678. /// psi time, which ever is earlier.  This is illustrated by
  679. /// hkAsynchronousTimestepper::stepAsynchronously. It can also be used in conjunction with
  680. /// multithreading simulation.
  681. /// Once you start using setFrameTimeMarker, you must continue to use it for all subsequent
  682. /// stepping.
  683. /// Please consult the user guide for more details.
  684. void setFrameTimeMarker( hkReal frameDeltaTime );
  685. /// This call can be used to step the world asynchronously. It returns true if the simulation
  686. /// time is equal to the frame marker time. If the frameTimeMarker has not been set this returns
  687. /// false.
  688. /// Please consult the user guide for more details.
  689. bool isSimulationAtMarker() const;
  690. /// This call returns true if the simulation current time is equal to the simulation currentPsiTime.
  691. /// It can be used as a debug check when stepping the world asynchronously.
  692. /// Please consult the user guide for more details.
  693. bool isSimulationAtPsi() const;
  694. //
  695. // Multithreaded stepping
  696. //
  697. /// You must call this function prior to multi-threaded stepping. It registers internal
  698. /// functions to deal with physics jobs that will be placed on the job queue.
  699. static void HK_CALL registerWithJobQueue( hkJobQueue* jobQueue );
  700. /// Step the world multithreaded. You must pass in a jobQueue, and a threadPool. This
  701. /// will utilize the threads of the thread pool for all multi-threading parts of the
  702. /// step.
  703. void stepMultithreaded( hkJobQueue* jobQueue, hkJobThreadPool* threadPool, hkReal physicsDeltaTime );
  704. /// This function is called internally by stepMultiThreaded() and may be used instead, to
  705. /// get finer control over multithreading.
  706. /// It places the initial jobs on the job queue. 
  707. /// This function leaves the world in a markForRead() state, for stepProcesMt().  This state is
  708. /// reset in finishMtStep().
  709. void initMtStep( hkJobQueue* jobQueue, hkReal physicsDeltaTime );
  710. /// This function is called internally by stepMultiThreaded() and may be used instead, to
  711. /// get finer control over multithreading.
  712. /// This function performs continuous simulation, and performs any single threaded cleanup necessary.
  713. /// The parameters allow you to control whether collision detection is performed in parallel during continuous simulation.
  714. /// If you pass in a jobQueue, and a threadPool, they will be used for this.
  715. /// Leaving these values at their defaults will mean all continuous simulation is performed single threaded.
  716. /// Only one thread must call this function. It must be
  717. /// called when all threads have returned from calling stepProcessMt.
  718. void finishMtStep( hkJobQueue* jobQueue = HK_NULL, hkJobThreadPool* threadPool = HK_NULL );
  719. //
  720. // Time accessors
  721. //
  722. /// This returns current time of the simulation. Use it to calculate current transforms of rigid bodies
  723. /// in between PSI steps (with hkpRigidBody::approxTransformAt). Note that this is not absolute time; its value is reset every 30 seconds or so.
  724. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  725. hkTime getCurrentTime() const;
  726. /// This returns the current "PSI" time of the simulation.  The PSI time is always the same or greater than
  727. /// the current time.  See the user guide for details.
  728. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  729. hkTime getCurrentPsiTime() const;
  730. //
  731. // Multithreaded simulation details accessors
  732. //
  733. /// This function is only valid for multithreading simulation.  It allows you to access
  734. /// some settings used for PLAYSTATION(R)3 multithreading simulation.
  735. void getMultithreadConfig( hkpMultithreadConfig& config );
  736. /// This function is only valid for multithreading simulation. It allows you to control
  737. /// some settings used for PLAYSTATION(R)3 multithreading simulation.
  738. void setMultithreadConfig( const hkpMultithreadConfig& config, hkJobQueue* queue );
  739. hkMultiThreadCheck& getMultiThreadCheck() const { return m_multiThreadCheck; }
  740. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  741. void checkAccessGetActiveSimulationIslands() const;
  742. //
  743. // Serialization Utilities
  744. //
  745. /// Get a hkpPhysicsSystem that represents the whole system
  746. /// contained in this world. This can be used as a serialization utility
  747. /// for taking a snapshot of the world.
  748. /// Release the physics system when you are finished using it.
  749. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  750. hkpPhysicsSystem* getWorldAsOneSystem() const;
  751. /// Get an array of hkpPhysicsSystem(s) that represents the whole system
  752. /// contained in this world. This can be used as a serialization utility
  753. /// for taking a snapshot of the world.
  754. /// Release the physics systems when you are finished using it.
  755. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  756. void getWorldAsSystems(hkArray<hkpPhysicsSystem*>& systemsOut) const;
  757. /*
  758. ** Protected Functions
  759. */
  760. // you should use removeReference() instead, however we allow you to force destroy the world
  761. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  762. ~hkpWorld();
  763. /// Removes all entities, actions and phantoms from the world
  764. ///
  765. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  766. void removeAll();
  767. /*
  768. ** protected members: They are public so that people can get full control over the engine
  769. **  if they know what they are doing!!!
  770. */
  771. //
  772. // Extra action management
  773. //
  774. // Attaches an action to an entity -- this should be called for every entity being
  775. // attached to the action, when the action is already added to the world
  776. // Note: this does not manage the action's entity list.
  777. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  778. void attachActionToEntity(hkpAction* action, hkpEntity* entity);
  779. // Detaches an action from an entity -- this should be called for every entity being
  780. // detached from the action, when the action is already added to the world.
  781. // Note: this does not manage the action's entity list.
  782. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  783. void detachActionFromEntity(hkpAction* action, hkpEntity* entity);
  784. //
  785. // Locking and delaying of operations
  786. //
  787. public:
  788. // Locks the world, i.e. prevents all critical operations (like adding/removing entities or constraints) from being
  789. // executed immediately. The operations are put on an hkWorldOperationsQueue and should be executed at the earliest
  790. // safe time. See hkpWorldOperationQueue for the list of 'critical' operations which may be postponed by the system.
  791. // Subsequent lockCriticalOperations() calls accumulate.
  792. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  793. HK_FORCE_INLINE void lockCriticalOperations();
  794. // Allows critical operations to be executed immediately after unlockCriticalOperations() has been called or every corresponding lockCriticalOperations().
  795. // It is advised to call attemptToExecutePendingOperations right after unlockCriticalOperations() to keep the order of operations
  796. // the same as the order in which they were called.
  797. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  798. HK_FORCE_INLINE void unlockCriticalOperations();
  799. // Returns number of locks put on the hkpWorld. Critical operation will be postponed if areCriticalOperationsLocked() > 0
  800. // We assume that this function is called at a beginning of a critical operation.
  801. // So this function asserts if critical operations are not allowed at all
  802. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  803. HK_FORCE_INLINE int areCriticalOperationsLocked() const;
  804. // like areCriticalOperationsLocked without the extra check
  805. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  806. HK_FORCE_INLINE int areCriticalOperationsLockedUnchecked() const;
  807. // Concept: Locking of Phantoms is an add-on work-around.
  808. //          It lets you execute phantom-related critical functions even when hkpWorld::areCriticalOperationsLocked() is called.
  809. //          Note that recursive phantom operations will not be executed, and will be postponed just like other operations are.
  810. // Decreases lock count for phantom operations. The operations must query hkpWorld::areCriticalOperationsLockedForPhantoms()
  811. // instead of hkpWorld::areCriticalOperationsLocked().
  812. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  813. HK_FORCE_INLINE void unlockCriticalOperationsForPhantoms();
  814. // Increases lock count for phantom operations..
  815. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  816. HK_FORCE_INLINE void lockCriticalOperationsForPhantoms();
  817. // Queries lock count for phantom operations. hkpWorld::m_criticalOperationsLockCountForPhantoms is an offset value added to the primary hkpWorld::m_criticalOperationsLockCount.
  818. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RO] );
  819. HK_FORCE_INLINE int areCriticalOperationsLockedForPhantoms() const;
  820. // Concept: explained in hkpWorld.cpp. Search for: "concept: blocking of execution of pending operations"
  821. // Blocks or unblocks attempts of execution of pending operations.
  822. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  823. HK_FORCE_INLINE void blockExecutingPendingOperations(hkBool block);
  824. // See: hkpWorld::unlock + hkpWorld::attemptToExecutePendingOperations
  825. HK_FORCE_INLINE void unlockAndAttemptToExecutePendingOperations();
  826. // If the world is locked or execution of pending operations is blocked, then it does nothing.
  827. // Otherwise it processes the list of pending operations.
  828. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  829. HK_FORCE_INLINE void attemptToExecutePendingOperations( bool executeBodyOperations = true);
  830. // Appends information about an operation request onto the world's hkpWorldOperationQueue.
  831. void queueOperation(const hkWorldOperation::BaseOperation& operation);
  832. // Queues an user callback onto operation queue.
  833. // If the world is not locked, the callback is executed immediately.
  834. hkWorldOperation::UserCallback* queueCallback(hkWorldOperation::UserCallback* callback, hkUlong userData = 0);
  835. void addBodyOperation( hkpRigidBody* breakingBody, hkpBodyOperation* operation, int priority, /*hkpBodyOperation::ExecutionState*/int hint );
  836. // This invalidates the tree containing the object.
  837. void markKdTreeDirty();
  838. /// Rebuilds to the world's kd tree
  839. /// If m_autoUpdateKdTree is set to true, this is called at the end of the world step.
  840. /// Otherwise it should be called manually.
  841. void updateKdTree( hkJobQueue* jobQueue = HK_NULL, hkJobThreadPool* jobThreadPool = HK_NULL );
  842. private:
  843. // Passes execution call to hkpWorldOperationQueue::attemptToExecuteAllPending()
  844. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  845. void internal_executePendingOperations();
  846. // Passes execution call to hkpWorldOperationQueue::executeAllPendingBodyOperations()
  847. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  848. void internal_executePendingBodyOperations();
  849. public:
  850. // Debugging utility: see hkpWorld.cpp. Search for: "concept: allowing critical operations"
  851. /// ###ACCESS_CHECKS###( [this,HK_ACCESS_RW] );
  852. HK_FORCE_INLINE void allowCriticalOperations(hkBool allow);
  853. /// Finish constructor
  854. explicit hkpWorld( hkFinishLoadedObjectFlag flag );
  855. # ifdef HK_ENABLE_DETERMINISM_CHECKS
  856. static void HK_CALL checkDeterminismInAgentNnTracks(const class hkpWorld* world);
  857. static void HK_CALL checkDeterminismInAgentNnTracks(const class hkpSimulationIsland* island);
  858. # endif 
  859. public:
  860. // A class controlling the simulation
  861. hkpSimulation* m_simulation;
  862. hkVector4 m_gravity;
  863.         hkpSimulationIsland* m_fixedIsland;          // +nosave
  864. hkpRigidBody* m_fixedRigidBody;
  865.         hkArray<hkpSimulationIsland*> m_activeSimulationIslands; // +nosave
  866.         hkArray<hkpSimulationIsland*> m_inactiveSimulationIslands; // +nosave
  867. // Dirty islands are scheduled for cleanup, performed  by hkpWorldOperationUtil::cleanupDirtyIslands( )
  868.         hkArray<hkpSimulationIsland*> m_dirtySimulationIslands;  // +nosave
  869.         hkpWorldMaintenanceMgr* m_maintenanceMgr;    // +nosave
  870.         hkWorldMemoryAvailableWatchDog* m_memoryWatchDog; // +nosave
  871.         hkpBroadPhase* m_broadPhase; // +nosave
  872. class hkpKdTreeWorldManager* m_kdTreeManager; //+nosave
  873. /// Enables/disables automatic updating of the world's kd-tree after the world step.
  874. /// See comments in hkpWorldCinfo.h
  875. hkBool m_autoUpdateKdTree;
  876. // Broadphase handler - this is a class which links the broadphase to the simulation
  877.         hkpTypedBroadPhaseDispatcher*    m_broadPhaseDispatcher; // +nosave
  878.         hkpPhantomBroadPhaseListener*    m_phantomBroadPhaseListener; // +nosave
  879.         hkpEntityEntityBroadPhaseListener* m_entityEntityBroadPhaseListener; // +nosave
  880.         hkpBroadPhaseBorderListener* m_broadPhaseBorderListener; // +nosave
  881.         hkpMtThreadStructure* m_multithreadedSimulationJobData; // +nosave
  882.         hkpProcessCollisionInput* m_collisionInput; // +nosave
  883.             hkpCollisionFilter*       m_collisionFilter;  // +nosave
  884.             hkpCollisionDispatcher*   m_collisionDispatcher; // +nosave
  885.             hkpConvexListFilter*     m_convexListFilter; // +nosave
  886. /// For delayed operations. Operations get delayed if they cannot be performed as the world is hkpWorld::locked()
  887.         hkpWorldOperationQueue* m_pendingOperations; // +nosave
  888. int m_pendingOperationsCount;
  889. int m_pendingBodyOperationsCount; // +nosave
  890. int m_criticalOperationsLockCount;
  891. // It just holds a value offset which should be added to m_criticalOperationsLockCount when querying areCriticalOperationsLockedForPhantoms().
  892. int m_criticalOperationsLockCountForPhantoms;
  893. hkBool m_blockExecutingPendingOperations;
  894. hkBool m_criticalOperationsAllowed;
  895. // This points to structures used to debug operation postponing. Not used in release build.
  896.             hkpDebugInfoOnPendingOperationQueues* m_pendingOperationQueues; // +nosave
  897. // Holds the number of pending queues (equal to the number of recursive calls to executeAllPendingOperations).
  898. int m_pendingOperationQueueCount;
  899. /// The thread index of the locking thread
  900.         mutable class hkMultiThreadCheck m_multiThreadCheck; // +nosave
  901. /// Internal. Forces actions to be processed in a single thread.
  902. hkBool m_processActionsInSingleThread;
  903. // This allows to keep the islands size reasonable large. See hkpWorldCinfo::m_minDesiredIslandSize for details
  904. hkUint32 m_minDesiredIslandSize;
  905. // set if running a mt simulation
  906. // whenever a constraint is added, this critical section is used
  907.         class hkCriticalSection* m_modifyConstraintCriticalSection; // +nosave
  908. int m_isLocked; // debugging only: to avoid deleting the world in a locked state
  909. // a critical section which may guard the island dirty list
  910.         class hkCriticalSection* m_islandDirtyListCriticalSection;      // +nosave
  911.         class hkCriticalSection* m_propertyMasterLock; // +nosave
  912. hkBool m_wantSimulationIslands;
  913. // Welding parameters (just stored here for getCinfo())
  914. hkReal m_snapCollisionToConvexEdgeThreshold;
  915. hkReal m_snapCollisionToConcaveEdgeThreshold;
  916. hkBool m_enableToiWeldRejection;
  917. // Deactivation parameters
  918. hkBool m_wantDeactivation;
  919. hkBool m_shouldActivateOnRigidBodyTransformChange;
  920. // see hkpWorldCinfo::m_deactivationReferenceDistance
  921. hkReal m_deactivationReferenceDistance;
  922. hkReal m_toiCollisionResponseRotateNormal;
  923. int m_maxSectorsPerCollideTask;
  924. int m_maxEntriesPerToiCollideTask;
  925.         hkEnum<hkpWorldCinfo::SimulationType,hkInt32>  m_simulationType; //+nosave
  926. hkReal m_numToisTillAllowedPenetrationSimplifiedToi;
  927. hkReal m_numToisTillAllowedPenetrationToi;
  928. hkReal m_numToisTillAllowedPenetrationToiHigher;
  929. hkReal m_numToisTillAllowedPenetrationToiForced;
  930. // debug only and used by the havok demo framework
  931. static hkBool m_forceMultithreadedSimulation;
  932. // This helper class can be used by a demo's constructor to ignore m_forceMultithreadedSimulation. This is useful e.g. for demos
  933. // that won't work properly in forced-multithreaded mode. Creating a local instance at the constructor's beginning will backup
  934. // the original value, override it with 'false' and restore the original value when leaving the demo's constructor.
  935. // Make sure to 'delete' this instance before leaving the demo's constructor if you explicitly 'new' it!
  936. class IgnoreForceMultithreadedSimulation
  937. {
  938. public:
  939. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, hkpWorld::IgnoreForceMultithreadedSimulation );
  940.  IgnoreForceMultithreadedSimulation() { m_originalForceMultithreadedSimulationValue = hkpWorld::m_forceMultithreadedSimulation; hkpWorld::m_forceMultithreadedSimulation = false; }
  941. ~IgnoreForceMultithreadedSimulation() { hkpWorld::m_forceMultithreadedSimulation = m_originalForceMultithreadedSimulationValue; }
  942. public:
  943. hkBool m_originalForceMultithreadedSimulationValue;
  944. };
  945. protected:
  946. // World-unique ids are assigned to entities. They're used to sort constraints deterministically when using hkMultithreadedSimulation.
  947. hkUint32 m_lastEntityUid;
  948. public:
  949. friend class hkpWorldOperationUtil;
  950. friend class hkpWorldCallbackUtil;
  951. friend class hkpSimulation;
  952. friend class hkHalfstepSimulation;
  953. friend class hkpContinuousSimulation;
  954. friend class hkpMultiThreadedSimulation;
  955. friend class hkpSimpleConstraintContactMgr;
  956. hkArray<hkpPhantom*> m_phantoms;
  957.         hkArray<hkpActionListener*>              m_actionListeners;  // +nosave
  958.         hkArray<hkpEntityListener*>              m_entityListeners;  // +nosave
  959.         hkArray<hkpPhantomListener*>             m_phantomListeners; // +nosave
  960.         hkArray<hkpConstraintListener*>          m_constraintListeners;  // +nosave
  961.         hkArray<hkpWorldDeletionListener*>       m_worldDeletionListeners; // +nosave
  962.         hkArray<hkpIslandActivationListener*>    m_islandActivationListeners; // +nosave
  963.         hkArray<hkpWorldPostSimulationListener*> m_worldPostSimulationListeners; // +nosave
  964.         hkArray<hkpWorldPostIntegrateListener*>  m_worldPostIntegrateListeners; // +nosave
  965.         hkArray<hkpWorldPostCollideListener*>    m_worldPostCollideListeners; // +nosave
  966.         hkArray<hkpIslandPostIntegrateListener*> m_islandPostIntegrateListeners; // +nosave
  967.         hkArray<hkpIslandPostCollideListener*>   m_islandPostCollideListeners; // +nosave
  968.         hkArray<hkpCollisionListener*>           m_collisionListeners; // +nosave
  969.         hkArray<hkpContactImpulseLimitBreachedListener*> m_contactImpulseLimitBreachedListeners; //+nosave
  970.         class hkpBroadPhaseBorder*               m_broadPhaseBorder; // +nosave
  971. class hkdWorld* m_destructionWorld; // +nosave
  972. public:
  973. //
  974. // These members are for internal use only
  975. //
  976. struct hkpWorldDynamicsStepInfo m_dynamicsStepInfo; //+reflected(false)
  977. // Min and Max extents of broadphase
  978. // Needed for when construction info is retrieved
  979. hkVector4 m_broadPhaseExtents[2];
  980. int m_broadPhaseNumMarkers;
  981. int m_sizeOfToiEventQueue;
  982. hkInt32 m_broadPhaseQuerySize;
  983. hkInt32 m_broadPhaseUpdateSize;
  984.         hkEnum<hkpWorldCinfo::ContactPointGeneration, hkInt8> m_contactPointGeneration; // +nosave
  985. };
  986. #include <Physics/Dynamics/World/hkpWorld.inl>
  987. #endif // HK_DYNAMICS2_WORLD_H
  988. /*
  989. * Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20090216)
  990. * Confidential Information of Havok.  (C) Copyright 1999-2009
  991. * Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
  992. * Logo, and the Havok buzzsaw logo are trademarks of Havok.  Title, ownership
  993. * rights, and intellectual property rights in the Havok software remain in
  994. * Havok and/or its suppliers.
  995. * Use of this software for evaluation purposes is subject to and indicates
  996. * acceptance of the End User licence Agreement for this product. A copy of
  997. * the license is included with this software and is also available at www.havok.com/tryhavok.
  998. */