开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
hkpWorldOperationQueue.h
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：17k
源码类别：

其他游戏

开发平台：

Visual C++

hkpWorldOperationQueue.h：源码内容
  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.  */
  9. #ifndef HK_DYNAMICS2_WORLD_OPERATION_QUEUE_H
  10. #define HK_DYNAMICS2_WORLD_OPERATION_QUEUE_H
  12. #include <Physics/Dynamics/World/hkpWorld.h>
  13. #include <Physics/Dynamics/Motion/hkpMotion.h>
  15. #include <Physics/Dynamics/World/Util/hkpBodyOperation.h>
  17. class hkAabb;
  18. class hkpRigidBody;
  19. class hkpWorldObject;
  20. class hkpConstraintInstance;
  21. class hkpShape;
  22. class hkpConstraintCollisionFilter;
  24. namespace hkWorldOperation
  25. {
  26. enum Type
  27. {
  28. OPERATION_ID_ANY     = 0,
  29. OPERATION_ID_INVALID = 0,
  31. ENTITY_ADD,
  32. ENTITY_REMOVE,
  34. ENTITY_UPDATE_BROAD_PHASE,
  36. RIGIDBODY_SET_MOTION_TYPE,
  38. WORLD_OBJECT_SET_SHAPE,
  40. ENTITY_BATCH_ADD,
  41. ENTITY_BATCH_REMOVE,
  43. CONSTRAINT_ADD,
  44. CONSTRAINT_REMOVE,
  46. ACTION_ADD,
  47. ACTION_REMOVE,
  49. ISLAND_MERGE,       
  51. PHANTOM_ADD,
  52. PHANTOM_REMOVE,
  53. PHANTOM_BATCH_ADD,
  54. PHANTOM_BATCH_REMOVE,
  56. PHANTOM_UPDATE_BROAD_PHASE,
  58. UPDATE_FILTER_ENTITY,
  59. UPDATE_FILTER_ENTITY_PAIR,
  60. UPDATE_FILTER_PHANTOM,
  61. UPDATE_FILTER_WORLD,
  63. UPDATE_MOVED_BODY_INFO,
  65. ENTITY_BATCH_REINTEGRATE_AND_RECOLLIDE,
  67. RIGIDBODY_SET_POSITION_AND_ROTATION,
  68. RIGIDBODY_SET_LINEAR_VELOCITY,
  69. RIGIDBODY_SET_ANGULAR_VELOCITY,
  70. RIGIDBODY_APPLY_LINEAR_IMPULSE,
  71. RIGIDBODY_APPLY_POINT_IMPULSE,
  72. RIGIDBODY_APPLY_ANGULAR_IMPULSE,
  74. WORLD_OBJECT_ADD_REFERENCE,
  75. WORLD_OBJECT_REMOVE_REFERENCE,
  77. ACTIVATE_REGION,
  79. ACTIVATE_ENTITY,
  80. DEACTIVATE_ENTITY,
  82. CONSTRAINT_FILTER_BROKEN_EVENT,
  84. USER_CALLBACK
  86. };
  88. class UserCallback : public hkReferencedObject
  89. {
  90. public:
  91. virtual void worldOperationUserCallback(hkUlong userData) = 0;
  92. };
  95. // !! This is defined in hkpWorldObject.h
  96. // enum Result
  97. // {
  98. // DONE,
  99. // POSTPONED
  100. // };
  102. struct BaseOperation
  103. {
  104. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, BaseOperation );
  106. BaseOperation(Type type) : m_type(type) {}
  107. hkEnum<Type, hkUint8> m_type;
  109. private:
  110. BaseOperation();
  111. };
  113. struct AddEntity : public BaseOperation
  114. {
  115. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, AddEntity );
  117. AddEntity() : BaseOperation(ENTITY_ADD) {}
  118. hkpEntity* m_entity;
  119. hkpEntityActivation m_activation;
  120. };
  122. struct RemoveEntity : public BaseOperation
  123. {
  124. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, RemoveEntity );
  126. RemoveEntity() : BaseOperation(ENTITY_REMOVE) {}
  127. hkpEntity* m_entity;
  128. };
  130. struct SetRigidBodyMotionType : public BaseOperation
  131. {
  132. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, SetRigidBodyMotionType );
  134. SetRigidBodyMotionType() : BaseOperation(RIGIDBODY_SET_MOTION_TYPE) {}
  135. hkpRigidBody* m_rigidBody;
  136. hkEnum<hkpMotion::MotionType, hkUint8>       m_motionType;
  137. hkEnum<hkpEntityActivation, hkUint8>         m_activation;
  138. hkEnum<hkpUpdateCollisionFilterOnEntityMode, hkUint8> m_collisionFilterUpdateMode;
  139. hkEnum<hkpUpdateCollectionFilterMode, hkUint8> m_updateShapeCollections;
  140. };
  142. struct SetWorldObjectShape : public BaseOperation
  143. {
  144. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, SetWorldObjectShape );
  146. SetWorldObjectShape() : BaseOperation(WORLD_OBJECT_SET_SHAPE) {}
  147. hkpWorldObject* m_worldObject;
  148. const hkpShape* m_shape;
  149. };
  152. struct AddEntityBatch : public BaseOperation
  153. {
  154. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, AddEntityBatch );
  156. AddEntityBatch() : BaseOperation(ENTITY_BATCH_ADD) {}
  157. hkpEntity** m_entities;
  158. hkObjectIndex m_numEntities;
  159. hkEnum<hkpEntityActivation, hkUint8> m_activation;
  160. };
  162. struct RemoveEntityBatch : public BaseOperation
  163. {
  164. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, RemoveEntityBatch );
  166. RemoveEntityBatch() : BaseOperation(ENTITY_BATCH_REMOVE) {}
  167. hkpEntity** m_entities;
  168. hkObjectIndex m_numEntities;
  169. };
  171. struct AddConstraint : public BaseOperation
  172. {
  173. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, AddConstraint );
  175. AddConstraint() : BaseOperation(CONSTRAINT_ADD) {}
  176. hkpConstraintInstance* m_constraint;
  177. };
  179. struct RemoveConstraint : public BaseOperation
  180. {
  181. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, RemoveConstraint );
  183. RemoveConstraint() : BaseOperation(CONSTRAINT_REMOVE) {}
  184. hkpConstraintInstance* m_constraint;
  185. };
  187. struct AddAction : public BaseOperation
  188. {
  189. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, AddAction );
  191. AddAction() : BaseOperation(ACTION_ADD) {}
  192. hkpAction* m_action;
  193. };
  195. struct RemoveAction : public BaseOperation
  196. {
  197. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, RemoveAction );
  199. RemoveAction() : BaseOperation(ACTION_REMOVE) {}
  200. hkpAction* m_action;
  201. };
  204. struct MergeIslands : public BaseOperation
  205. {
  206. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, MergeIslands );
  208. MergeIslands() : BaseOperation(ISLAND_MERGE) {}
  209. hkpEntity* m_entities[2];
  210. };
  213. struct AddPhantom : public BaseOperation
  214. {
  215. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, AddPhantom );
  217. AddPhantom() : BaseOperation(PHANTOM_ADD) {}
  218. hkpPhantom* m_phantom;
  219. };
  221. struct RemovePhantom : public BaseOperation
  222. {
  223. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, RemovePhantom );
  225. RemovePhantom() : BaseOperation(PHANTOM_REMOVE) {}
  226. hkpPhantom* m_phantom;
  227. };
  229. struct AddPhantomBatch : public BaseOperation
  230. {
  231. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, AddPhantomBatch );
  233. AddPhantomBatch() : BaseOperation(PHANTOM_BATCH_ADD) {}
  234. hkpPhantom** m_phantoms;
  235. hkObjectIndex m_numPhantoms;
  236. };
  238. struct RemovePhantomBatch : public BaseOperation
  239. {
  240. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, RemovePhantomBatch );
  242. RemovePhantomBatch() : BaseOperation(PHANTOM_BATCH_REMOVE) {}
  243. hkpPhantom** m_phantoms;
  244. hkObjectIndex m_numPhantoms;
  245. };
  248. struct UpdateEntityBP : public BaseOperation
  249. {
  250. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, UpdateEntityBP );
  252. UpdateEntityBP() : BaseOperation(ENTITY_UPDATE_BROAD_PHASE) {}
  253. hkpEntity* m_entity;
  254. };
  256. struct UpdatePhantomBP : public BaseOperation
  257. {
  258. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, UpdatePhantomBP );
  260. UpdatePhantomBP() : BaseOperation(PHANTOM_UPDATE_BROAD_PHASE) {}
  261. hkpPhantom* m_phantom;
  262. hkAabb* m_aabb;
  263. };
  266. struct UpdateFilterOnEntity : public BaseOperation
  267. {
  268. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, UpdateFilterOnEntity );
  270. UpdateFilterOnEntity() : BaseOperation(UPDATE_FILTER_ENTITY) {}
  271. hkpEntity* m_entity;
  272. hkEnum<hkpUpdateCollisionFilterOnEntityMode, hkUint8> m_collisionFilterUpdateMode;
  273. hkEnum<hkpUpdateCollectionFilterMode, hkUint8>  m_updateShapeCollections;
  274. };
  276. struct UpdateFilterOnEntityPair : public BaseOperation
  277. {
  278. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, UpdateFilterOnEntityPair );
  280. UpdateFilterOnEntityPair() : BaseOperation(UPDATE_FILTER_ENTITY_PAIR) {}
  281. hkpEntity* m_entityA;
  282. hkpEntity* m_entityB;
  283. };
  285. struct UpdateFilterOnPhantom : public BaseOperation
  286. {
  287. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, UpdateFilterOnPhantom );
  289. UpdateFilterOnPhantom() : BaseOperation(UPDATE_FILTER_PHANTOM) {}
  290. hkpPhantom* m_phantom;
  291. hkEnum<hkpUpdateCollectionFilterMode, hkUint8>  m_updateShapeCollections;
  292. };
  293. struct UpdateFilterOnWorld : public BaseOperation
  294. {
  295. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, UpdateFilterOnWorld );
  297. UpdateFilterOnWorld() : BaseOperation(UPDATE_FILTER_WORLD) {}
  298. hkEnum<hkpUpdateCollisionFilterOnWorldMode, hkUint8>      m_collisionFilterUpdateMode;
  299. hkEnum<hkpUpdateCollectionFilterMode, hkUint8>  m_updateShapeCollections;
  300. };
  302. struct ReintegrateAndRecollideEntityBatch : public BaseOperation
  303. {
  304. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, ReintegrateAndRecollideEntityBatch );
  306. ReintegrateAndRecollideEntityBatch() : BaseOperation(ENTITY_BATCH_REINTEGRATE_AND_RECOLLIDE) {}
  307. hkpEntity**   m_entities;
  308. hkObjectIndex m_numEntities;
  309. hkUint8       m_mode;
  310. hkEnum<hkpEntityActivation, hkUint8> m_activation;
  311. };
  313. struct UpdateMovedBodyInfo : public BaseOperation
  314. {
  315. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, UpdateMovedBodyInfo );
  317. UpdateMovedBodyInfo() : BaseOperation(UPDATE_MOVED_BODY_INFO) {}
  318. hkpEntity* m_entity;
  319. };
  322. struct SetRigidBodyPositionAndRotation : public BaseOperation
  323. {
  324. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, SetRigidBodyPositionAndRotation );
  326. SetRigidBodyPositionAndRotation() : BaseOperation(RIGIDBODY_SET_POSITION_AND_ROTATION) {}
  327. hkpRigidBody* m_rigidBody;
  328. hkVector4* m_positionAndRotation; // performs and external allocation
  329. };
  330. struct SetRigidBodyLinearVelocity : public BaseOperation
  331. {
  332. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, SetRigidBodyLinearVelocity );
  334. SetRigidBodyLinearVelocity() : BaseOperation(RIGIDBODY_SET_LINEAR_VELOCITY) {}
  335. hkpRigidBody* m_rigidBody;
  336. hkReal m_linearVelocity[3];
  337. };
  338. struct SetRigidBodyAngularVelocity : public BaseOperation
  339. {
  340. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, SetRigidBodyAngularVelocity );
  342. SetRigidBodyAngularVelocity() : BaseOperation(RIGIDBODY_SET_ANGULAR_VELOCITY) {}
  343. hkpRigidBody* m_rigidBody;
  344. hkReal m_angularVelocity[3];
  345. };
  346. struct ApplyRigidBodyLinearImpulse : public BaseOperation
  347. {
  348. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, ApplyRigidBodyLinearImpulse );
  350. ApplyRigidBodyLinearImpulse() : BaseOperation(RIGIDBODY_APPLY_LINEAR_IMPULSE) {}
  351. hkpRigidBody* m_rigidBody;
  352. hkReal m_linearImpulse[3];
  353. };
  354. struct ApplyRigidBodyPointImpulse : public BaseOperation
  355. {
  356. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, ApplyRigidBodyPointImpulse );
  358. ApplyRigidBodyPointImpulse() : BaseOperation(RIGIDBODY_APPLY_POINT_IMPULSE) {}
  359. hkpRigidBody* m_rigidBody;
  360. hkVector4* m_pointAndImpulse; // performs and external allocation
  361. };
  362. struct ApplyRigidBodyAngularImpulse : public BaseOperation
  363. {
  364. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, ApplyRigidBodyAngularImpulse );
  366. ApplyRigidBodyAngularImpulse() : BaseOperation(RIGIDBODY_APPLY_ANGULAR_IMPULSE) {}
  367. hkpRigidBody* m_rigidBody;
  368. hkReal m_angularImpulse[3];
  369. };
  371. // This is a 'special' operation which actually is not postponed, but merely uses operationQueue's critical section to guarantee inter-thread safety.
  372. struct AddReference : public BaseOperation
  373. {
  374. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, AddReference );
  376. AddReference() : BaseOperation(WORLD_OBJECT_ADD_REFERENCE) {}
  377. hkpWorldObject* m_worldObject;
  378. };
  380. // This is a 'special' operation which actually is not postponed, but merely uses operationQueue's critical section to guarantee inter-thread safety.
  381. struct RemoveReference : public BaseOperation
  382. {
  383. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, RemoveReference );
  385. RemoveReference() : BaseOperation(WORLD_OBJECT_REMOVE_REFERENCE) {}
  386. hkpWorldObject* m_worldObject;
  387. };
  389. struct ActivateRegion : public BaseOperation
  390. {
  391. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, ActivateRegion );
  393. ActivateRegion() : BaseOperation(ACTIVATE_REGION) {}
  394. hkAabb* m_aabb;
  395. };
  397. struct ActivateEntity : public BaseOperation 
  398. {
  399. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, ActivateEntity );
  401. ActivateEntity() : BaseOperation(ACTIVATE_ENTITY) {}
  402. hkpEntity* m_entity;
  403. };
  405. struct DeactivateEntity : public BaseOperation 
  406. {
  407. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, DeactivateEntity );
  409. DeactivateEntity() : BaseOperation(DEACTIVATE_ENTITY) {}
  410. hkpEntity* m_entity;
  411. };
  413. struct ConstraintCollisionFilterConstraintBroken: public BaseOperation
  414. {
  415. ConstraintCollisionFilterConstraintBroken() : BaseOperation( CONSTRAINT_FILTER_BROKEN_EVENT ){}
  416. hkpConstraintCollisionFilter* m_filter;
  417. hkpConstraintInstance* m_constraintInstance;
  418. hkBool    m_constraintBroken;
  419. };
  423. struct UserCallbackOperation : public BaseOperation
  424. {
  425. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, UserCallbackOperation );
  427. UserCallbackOperation() : BaseOperation(USER_CALLBACK) {}
  428. UserCallback* m_userCallback;
  429. hkUlong m_userData; // +default(0)
  430. };
  432. struct BiggestOperation : public BaseOperation
  433. {
  434. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_DYNAMICS, BiggestOperation );
  436. BiggestOperation() : BaseOperation(OPERATION_ID_INVALID) {}
  437. hkUlong dummy[3 + 1];
  438. };
  439. }
  441. struct hkpBodyOperationEntry
  442. {
  443. hkpEntity*                       m_entity;
  444. hkpBodyOperation*                m_operation;
  445. int                              m_priority;
  446. hkpBodyOperation::ExecutionState m_hint;
  447. };
  449. class hkpWorldOperationQueue
  450. {
  451. public:
  452. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_WORLD, hkpWorldOperationQueue ); 
  454. hkpWorldOperationQueue(hkpWorld* world);
  456. ~hkpWorldOperationQueue();
  458. void queueOperation(const hkWorldOperation::BaseOperation& operation);
  459. void executeAllPending();
  461. HK_FORCE_INLINE void purgeAllPending() { m_pending.clear(); }
  463. void queueBodyOperation(hkpEntity* breakingBody, hkpBodyOperation* operation, int priority, hkpBodyOperation::ExecutionState hint);
  465. void executeAllPendingBodyOperations();
  467. public:
  468. hkArray<hkWorldOperation::BiggestOperation> m_pending;
  469. hkpWorld* m_world;
  471. hkArray<hkWorldOperation::BiggestOperation> m_islandMerges;
  473. hkArray<hkpBodyOperationEntry> m_pendingBodyOperations;
  475. private:
  477. hkpWorldOperationQueue(){}
  478. };
  482. struct hkpDebugInfoOnPendingOperationQueues
  483. {
  484. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_WORLD, hkpDebugInfoOnPendingOperationQueues ); 
  486. hkpDebugInfoOnPendingOperationQueues(hkArray<hkWorldOperation::BiggestOperation>* pending) : 
  487. m_pending(pending), 
  488. m_nextPendingOperationIndex(0),
  489. m_nextQueue(HK_NULL),
  490. m_prevQueue(HK_NULL)
  491. {
  492. }
  494. hkArray<hkWorldOperation::BiggestOperation>* m_pending;
  495. int m_nextPendingOperationIndex;
  496. hkpDebugInfoOnPendingOperationQueues* m_nextQueue;
  497. hkpDebugInfoOnPendingOperationQueues* m_prevQueue;
  499. // This struct is only used by the debug code.
  500. HK_ON_DEBUG 
  501. (
  502. static void HK_CALL init(hkpWorld* world);
  503. static void HK_CALL cleanup(hkpWorld* world);
  505. static void HK_CALL updateNextPendingOperationIndex(hkpWorld* world, int index);
  506. static void HK_CALL addNextPendingOperationQueue(hkpWorld* world, hkArray<hkWorldOperation::BiggestOperation>* tmpOldPending);
  507. static void HK_CALL removeLastPendingOperationQueue(hkpWorld* world, hkArray<hkWorldOperation::BiggestOperation>* tmpOldPending);
  508. static int  HK_CALL getNumPendingOperationQueues(hkpWorld* world);
  510. static hkpDebugInfoOnPendingOperationQueues*  HK_CALL getLastQueue(hkpDebugInfoOnPendingOperationQueues* queue)
  511. {
  512. while(queue->m_nextQueue)
  513. {
  514. queue = queue->m_nextQueue;
  515. }
  516. return queue;
  517. }
  519. // Searching through pending lists:
  520. //   gotoTheLastOne
  521. //   start from the nextPendingOperationIndex and process till end
  522. //     goto previousQueue and repeat
  523. //   while previousQueue != HK_NULL
  525. static const hkWorldOperation::BaseOperation* findFirstPendingIslandMerge(hkpWorld* world, hkpSimulationIsland* isleA, hkpSimulationIsland* isleB);
  527. static const hkBool areEmpty(hkpWorld* world);
  528. )
  529. };
  531. #include <Physics/Dynamics/World/Util/hkpWorldOperationQueue.inl>
  533. #endif // HK_DYNAMICS2_WORLD_OPERATION_QUEUE_H
  536. /*
  537. * Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20090216)
  538. * 
  539. * Confidential Information of Havok.  (C) Copyright 1999-2009
  540. * Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
  541. * Logo, and the Havok buzzsaw logo are trademarks of Havok.  Title, ownership
  542. * rights, and intellectual property rights in the Havok software remain in
  543. * Havok and/or its suppliers.
  544. * 
  545. * Use of this software for evaluation purposes is subject to and indicates
  546. * acceptance of the End User licence Agreement for this product. A copy of
  547. * the license is included with this software and is also available at www.havok.com/tryhavok.
  548. * 
  549. */