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

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

其他游戏

开发平台：

Visual C++

hkpCollisionQueryJobs.inl：源码内容
  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.  */
  11. template<typename T>
  12. static void hkKdTreeCheckCommandPointers (const T* commandPtr, int numCommands)
  13. {
  14. for (int i=0; i<numCommands; i++)
  15. {
  16. const T* command = &commandPtr[i];
  17. HK_ASSERT2( 0xaf3647fe, command->m_results && ((hkUlong)command->m_results & 0xf) == 0, "Command's m_results has to be set and 16 byte aligned." );
  18. }
  19. }
  21. template<typename T>
  22. static void hkKdTreeCheckCommandCapacity (const T* commandPtr, int numCommands)
  23. {
  24. for (int i=0; i<numCommands; i++)
  25. {
  26. const T* command = &commandPtr[i];
  27. HK_ASSERT2( 0xaf3638e2, command->m_resultsCapacity > 0 && command->m_resultsCapacity <= T::MAXIMUM_RESULTS_CAPACITY, "Command's m_resultsCapacity has to be > 0 and <= " << T::MAXIMUM_RESULTS_CAPACITY << "." );
  28. }
  29. }
  34. hkpCollisionQueryJob::hkpCollisionQueryJob( JobSubType subType, hkUint16 size )
  35. : hkJob( HK_JOB_TYPE_COLLISION_QUERY, subType, size, HK_JOB_SPU_TYPE_DISABLED ),
  36. m_semaphore(HK_NULL), m_jobDoneFlag(HK_NULL)
  37. {
  38. m_sharedJobHeaderOnPpu = HK_NULL;
  39. m_collisionInput = HK_NULL;
  40. }
  42. inline void hkpCollisionQueryJob::atomicIncrementAndReleaseSemaphore() const
  43. {
  44. if (m_jobDoneFlag)
  45. {
  46. hkCriticalSection::atomicExchangeAdd(m_jobDoneFlag, 1);
  47. }
  49. if (m_semaphore)
  50. {
  51. hkSemaphoreBusyWait::release(m_semaphore);
  52. }
  53. }
  55. // ===============================================================================================================================================================================================
  56. // PAIR LINEAR CAST
  57. // ===============================================================================================================================================================================================
  59. hkpPairLinearCastJob::hkpPairLinearCastJob( const hkpProcessCollisionInput* input, hkpCollisionQueryJobHeader* jobHeader, const hkpPairLinearCastCommand* commandArray, int numCommands, const hkpShapeCollectionFilter* filter, hkReal tolerance, hkSemaphoreBusyWait* semaphore, int numCommandsPerTask) 
  60. : hkpCollisionQueryJob(COLLISION_QUERY_PAIR_LINEAR_CAST, sizeof(hkpPairLinearCastJob))
  61. {
  62. HK_ASSERT2( 0xaf136151, jobHeader && ((hkUlong)jobHeader & 0xf) == 0, "jobHeader has to be set and be 16 byte aligned." );
  63. HK_ASSERT2( 0xaf1647f5, numCommands > 0, "numCommands has to be > 0." );
  64. HK_ASSERT2( 0xaf1647e0, commandArray && ((hkUlong)commandArray & 0xf) == 0, "commandArray has to be set and 16 byte aligned." );
  65. HK_ASSERT2( 0xaf1647b4, numCommandsPerTask > 0 && numCommandsPerTask <= MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK, "numCommandsPerTask has to be > 0 and <= " << MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK << "." );
  67. #if defined(HK_DEBUG)
  68. // check memory allocated on commands
  69. {
  70. for (int i = 0; i < numCommands; i++)
  71. {
  72. hkpPairLinearCastCommand* command = const_cast<hkpPairLinearCastCommand*>( &commandArray[i] );
  74. HK_ASSERT2( 0xaf2647fe, command->m_results && ((hkUlong)command->m_results & 0xf) == 0, "hkpPairLinearCastCommand::m_results has to be set and 16 byte aligned." );
  75. HK_ASSERT2( 0xaf2638e2, command->m_resultsCapacity > 0 && command->m_resultsCapacity <= hkpPairLinearCastCommand::MAXIMUM_RESULTS_CAPACITY, "hkpPairLinearCastCommand::m_resultsCapacity has to be > 0 and <= " << hkpPairGetClosestPointsCommand::MAXIMUM_RESULTS_CAPACITY << "." );
  77. // m_startPointResults aren't required. These should still catch uninitialized memory, though.
  78. HK_ASSERT2( 0xaf2647fe, ((hkUlong)command->m_startPointResults & 0xf) == 0, "hkpPairLinearCastCommand::m_startPointResults has to be 16 byte aligned." );
  79. HK_ASSERT2( 0xaf2638e2, command->m_startPointResultsCapacity >= 0 && command->m_startPointResultsCapacity <= hkpPairLinearCastCommand::MAXIMUM_RESULTS_CAPACITY, "hkpPairLinearCastCommand::m_startPointResultsCapacity has to be >= 0 and <= " << hkpPairGetClosestPointsCommand::MAXIMUM_RESULTS_CAPACITY << "." );
  80. }
  81. }
  83. // This is a very simple and crude attempt to try to catch a common mistake where the user might
  84. // forget to actually advance the pointer to the results. Doing so could cause incorrect query results.
  85. // This check though will NOT catch trickier situations like e.g. partially overlapping results.
  86. if ( numCommands > 1 )
  87. {
  88. HK_ASSERT2(0xaf253413, commandArray[0].m_results != commandArray[1].m_results, "You are not allowed to re-use the same results buffer for two different query commands.");
  89. }
  90. #endif
  92. m_collisionInput = input;
  94. m_sharedJobHeaderOnPpu = jobHeader;
  96. m_tolerance = tolerance;
  98. m_numCommandsPerTask = numCommandsPerTask;
  99. m_semaphore = semaphore;
  100. m_commandArray = commandArray;
  101. m_numCommands = numCommands;
  103. m_filter = filter;
  106. m_maxExtraPenetration = HK_REAL_EPSILON;
  107. m_iterativeLinearCastEarlyOutDistance = 0.01f;
  108. m_iterativeLinearCastMaxIterations = 10;
  110. // precalculate the total number of jobs that will be spawned from the original job (incl. the original)
  111. m_sharedJobHeaderOnPpu->m_openJobs = ((numCommands-1)/numCommandsPerTask) + 1;
  112. }
  115. hkpPairLinearCastJob::hkpPairLinearCastJob() : hkpCollisionQueryJob(COLLISION_QUERY_PAIR_LINEAR_CAST, sizeof(hkpPairLinearCastJob))
  116. {
  117. }
  120. hkJobQueue::JobPopFuncResult hkpPairLinearCastJob::popJobTask( hkpPairLinearCastJob& out )
  121. {
  122. //
  123. // split off a fully filled child job if there are more tasks left than one job can handle
  124. //
  125. if ( m_numCommands > m_numCommandsPerTask )
  126. {
  127. out.m_numCommands  = m_numCommandsPerTask;
  128. m_numCommands -= m_numCommandsPerTask;
  129. m_commandArray  = hkAddByteOffsetConst(m_commandArray, m_numCommandsPerTask * sizeof(hkpPairLinearCastCommand));
  131. return hkJobQueue::DO_NOT_POP_QUEUE_ENTRY;
  132. }
  134. return hkJobQueue::POP_QUEUE_ENTRY;
  135. }
  138. // ===============================================================================================================================================================================================
  139. //  WORLD LINEAR CAST
  140. // ===============================================================================================================================================================================================
  142. hkpWorldLinearCastJob::hkpWorldLinearCastJob( const hkpProcessCollisionInput* input, hkpCollisionQueryJobHeader* jobHeader, const hkpWorldLinearCastCommand* commandArray, int numCommands, const hkpBroadPhase* broadphase, hkSemaphoreBusyWait* semaphore, int numCommandsPerTask) 
  143. : hkpCollisionQueryJob(COLLISION_QUERY_WORLD_LINEAR_CAST, sizeof(hkpWorldLinearCastJob))
  144. {
  145. HK_ASSERT2( 0xaf736152, jobHeader && ((hkUlong)jobHeader & 0xf) == 0, "jobHeader has to be set and be 16 byte aligned." );
  146. HK_ASSERT2( 0xaf7647f6, numCommands > 0, "numCommands has to be > 0." );
  147. HK_ASSERT2( 0xaf7647f7, commandArray && ((hkUlong)commandArray & 0xf) == 0, "commandArray has to be set and 16 byte aligned." );
  148. HK_ASSERT2( 0xaf7647f8, numCommandsPerTask > 0 && numCommandsPerTask <= MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK, "numCommandsPerTask has to be > 0 and <= " << MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK << "." );
  150. #if defined(HK_DEBUG)
  151. {
  152. for (int i=0; i<numCommands; i++)
  153. {
  154. const hkpWorldLinearCastCommand* command = &commandArray[i];
  155. HK_ASSERT2( 0xaf7647f9, command->m_results && ((hkUlong)command->m_results & 0xf) == 0, "hkpWorldLinearCastCommand::m_results has to be set and 16 byte aligned." );
  157. HK_ASSERT2( 0xaf7647fb, command->m_resultsCapacity > 0 && command->m_resultsCapacity <= hkpWorldLinearCastCommand::MAXIMUM_RESULTS_CAPACITY, "hkpWorldLinearCastCommand::m_resultsCapacity has to be > 0 and <= " << hkpWorldLinearCastCommand::MAXIMUM_RESULTS_CAPACITY << "." );
  159. #ifdef HK_PLATFORM_PS3_PPU
  160. const hkpShape* shape = command->m_collidable->getShape();
  161. if ( shape->getType() == HK_SHAPE_LIST )
  162. {
  163. const hkpListShape* list = static_cast<const hkpListShape*>(shape);
  164. {
  165. for (int childIdx = 0; childIdx < list->m_childInfo.getSize(); childIdx++)
  166. {
  167. const hkpListShape::ChildInfo& info = list->m_childInfo[childIdx];
  168. HK_ASSERT2(0xaf321fe3, info.m_shapeSize != 0, "You have to either add the entity using this hkpListShape to the world or manually call hkpEntity::setShapeSizeForSpu().");
  169. }
  170. }
  171. }
  172. #endif
  173. }
  174. }
  176. // This is a very simple and crude attempt to try to catch a common mistake where the user might
  177. // forget to actually advance the pointer to the results. Doing so could cause incorrect query results.
  178. // This check though will NOT catch trickier situations like e.g. partially overlapping results.
  179. if ( numCommands > 1 )
  180. {
  181. HK_ASSERT2(0xaf253414, commandArray[0].m_results != commandArray[1].m_results, "You are not allowed to re-use the same results buffer for two different query commands.");
  182. }
  183. #endif
  185. m_collisionInput = input;
  186. m_sharedJobHeaderOnPpu = jobHeader;
  188. m_numCommandsPerTask = numCommandsPerTask;
  189. m_semaphore = semaphore;
  190. m_commandArray = commandArray;
  191. m_numCommands = numCommands;
  193. m_broadphase = broadphase;
  195. // precalculate the total number of jobs that will be spawned from the original job (incl. the original)
  196. m_sharedJobHeaderOnPpu->m_openJobs = ((numCommands-1)/numCommandsPerTask) + 1;
  197. }
  200. hkJobQueue::JobPopFuncResult hkpWorldLinearCastJob::popJobTask( hkpWorldLinearCastJob& out )
  201. {
  202. //
  203. // split off a fully filled child job if there are more commands left than one job can handle
  204. //
  205. if ( m_numCommands > m_numCommandsPerTask )
  206. {
  207. out.m_numCommands  = m_numCommandsPerTask;
  208. m_numCommands -= m_numCommandsPerTask;
  209. m_commandArray  = hkAddByteOffsetConst(m_commandArray, m_numCommandsPerTask * sizeof(hkpWorldLinearCastCommand));
  211. return hkJobQueue::DO_NOT_POP_QUEUE_ENTRY;
  212. }
  214. return hkJobQueue::POP_QUEUE_ENTRY;
  215. }
  218. // ===============================================================================================================================================================================================
  219. //  MOPP AABB
  220. // ===============================================================================================================================================================================================
  222. hkpMoppAabbJob::hkpMoppAabbJob( const hkpProcessCollisionInput* input, hkpCollisionQueryJobHeader* jobHeader, const hkpMoppAabbCommand* commandArray, int numCommands, const hkUint8* moppCodeData, const hkpMoppCode::CodeInfo& moppCodeInfo, hkSemaphoreBusyWait* semaphore, int numCommandsPerTask) 
  223. : hkpCollisionQueryJob(COLLISION_QUERY_MOPP_AABB, sizeof(hkpMoppAabbJob))
  224. {
  225. m_jobSpuType = HK_JOB_SPU_TYPE_ENABLED;
  227. HK_ASSERT2( 0xaf236154, jobHeader && ((hkUlong)jobHeader & 0xf) == 0, "jobHeader has to be set and be 16 byte aligned.");
  228. HK_ASSERT2( 0xaf3647d2, numCommands > 0, "numCommands has to be > 0." );
  229. HK_ASSERT2( 0xaf3647d3, commandArray && ((hkUlong)commandArray & 0xf) == 0, "commandArray has to be set and 16 byte aligned." );
  230. HK_ASSERT2( 0xaf3647df, numCommandsPerTask > 0 && numCommandsPerTask <= MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK, "numCommandsPerTask has to be > 0 and <= " << MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK << "." );
  232. #if defined(HK_DEBUG)
  233. {
  234. for (int i=0; i<numCommands; i++)
  235. {
  236. const hkpMoppAabbCommand* command = &commandArray[i];
  237. HK_ASSERT2( 0xaf3647d5, command->m_results && ((hkUlong)command->m_results & 0xf) == 0, "hkpMoppAabbCommand::m_results has to be set and 16 byte aligned." );
  238. }
  239. }
  241. // This is a very simple and crude attempt to try to catch a common mistake where the user might
  242. // forget to actually advance the pointer to the results. Doing so could cause incorrect query results.
  243. // This check though will NOT catch trickier situations like e.g. partially overlapping results.
  244. if ( numCommands > 1 )
  245. {
  246. HK_ASSERT2(0xaf253415, commandArray[0].m_results != commandArray[1].m_results, "You are not allowed to re-use the same results buffer for two different query commands.");
  247. }
  248. #endif
  250. m_collisionInput = input;
  251. m_sharedJobHeaderOnPpu = jobHeader;
  253. m_moppCodeInfo = moppCodeInfo;
  254. m_moppCodeData = moppCodeData;
  256. m_numCommandsPerTask = numCommandsPerTask;
  257. m_semaphore = semaphore;
  258. m_commandArray = commandArray;
  259. m_numCommands = numCommands;
  261. // precalculate the total number of jobs that will be spawned from the original job (incl. the original)
  262. m_sharedJobHeaderOnPpu->m_openJobs = ((numCommands-1)/numCommandsPerTask) + 1;
  263. }
  266. hkJobQueue::JobPopFuncResult hkpMoppAabbJob::popJobTask( hkpMoppAabbJob& out )
  267. {
  268. //
  269. // split off a fully filled child job if there are more commands left than one job can handle
  270. //
  271. if ( m_numCommands > m_numCommandsPerTask )
  272. {
  273. out.m_numCommands  = m_numCommandsPerTask;
  274. m_numCommands -= m_numCommandsPerTask;
  275. m_commandArray  = hkAddByteOffsetConst(m_commandArray, m_numCommandsPerTask * sizeof(hkpMoppAabbCommand));
  277. return hkJobQueue::DO_NOT_POP_QUEUE_ENTRY;
  278. }
  280. return hkJobQueue::POP_QUEUE_ENTRY;
  281. }
  284. // ===============================================================================================================================================================================================
  285. //  PAIR GET CLOSEST POINTS
  286. // ===============================================================================================================================================================================================
  288. hkpPairGetClosestPointsJob::hkpPairGetClosestPointsJob( const hkpProcessCollisionInput* input, hkpCollisionQueryJobHeader* jobHeader, const hkpPairGetClosestPointsCommand* commandArray, int numCommands, hkReal tolerance, hkSemaphoreBusyWait* semaphore, int numCommandsPerTask) 
  289. : hkpCollisionQueryJob(COLLISION_QUERY_PAIR_GET_CLOSEST_POINTS,  sizeof(hkpPairGetClosestPointsJob))
  290. {
  291. HK_ASSERT2( 0xaf236151, jobHeader && ((hkUlong)jobHeader & 0xf) == 0, "jobHeader has to be set and be 16 byte aligned." );
  292. HK_ASSERT2( 0xaf3647f5, numCommands > 0, "numCommands has to be > 0." );
  293. HK_ASSERT2( 0xaf3647e0, commandArray && ((hkUlong)commandArray & 0xf) == 0, "commandArray has to be set and 16 byte aligned." );
  294. HK_ASSERT2( 0xaf3647b4, numCommandsPerTask > 0 && numCommandsPerTask <= MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK, "numCommandsPerTask has to be > 0 and <= " << MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK << "." );
  296. {
  297. for (int i = 0; i < numCommands; i++)
  298. {
  299. hkpPairGetClosestPointsCommand* command = const_cast<hkpPairGetClosestPointsCommand*>( &commandArray[i] );
  301. #if defined(HK_DEBUG)
  302. HK_ASSERT2( 0xaf1647fe, command->m_results && ((hkUlong)command->m_results & 0xf) == 0, "hkpPairGetClosestPointsCommand::m_results has to be set and 16 byte aligned." );
  303. HK_ASSERT2( 0xaf1638e2, command->m_resultsCapacity > 0 && command->m_resultsCapacity <= hkpPairGetClosestPointsCommand::MAXIMUM_RESULTS_CAPACITY, "hkpPairGetClosestPointsCommand::m_resultsCapacity has to be > 0 and <= " << hkpPairGetClosestPointsCommand::MAXIMUM_RESULTS_CAPACITY << "." );
  304. #endif
  306. command->m_indexIntoSharedResults = HK_NULL;
  307. }
  308. }
  310. #if defined(HK_DEBUG)
  311. // This is a very simple and crude attempt to try to catch a common mistake where the user might
  312. // forget to actually advance the pointer to the results. Doing so could cause incorrect query results.
  313. // This check though will NOT catch trickier situations like e.g. partially overlapping results.
  314. if ( numCommands > 1 )
  315. {
  316. HK_ASSERT2(0xaf253416, commandArray[0].m_results != commandArray[1].m_results, "You are not allowed to re-use the same results buffer for two different query commands.");
  317. }
  318. #endif
  320. m_collisionInput = input;
  322. m_sharedJobHeaderOnPpu = jobHeader;
  324. m_tolerance = tolerance;
  326. m_numCommandsPerTask = numCommandsPerTask;
  327. m_semaphore = semaphore;
  328. m_commandArray = commandArray;
  329. m_numCommands = numCommands;
  331. // precalculate the total number of jobs that will be spawned from the original job (incl. the original)
  332. m_sharedJobHeaderOnPpu->m_openJobs = ((numCommands-1)/numCommandsPerTask) + 1;
  333. }
  336. hkpPairGetClosestPointsJob::hkpPairGetClosestPointsJob()
  337. : hkpCollisionQueryJob(COLLISION_QUERY_PAIR_GET_CLOSEST_POINTS, sizeof(hkpPairGetClosestPointsJob))
  338. {
  339. }
  342. hkJobQueue::JobPopFuncResult hkpPairGetClosestPointsJob::popJobTask( hkpPairGetClosestPointsJob& out )
  343. {
  344. //
  345. // split off a fully filled child job if there are more tasks left than one job can handle
  346. //
  347. if ( m_numCommands > m_numCommandsPerTask )
  348. {
  349. out.m_numCommands  = m_numCommandsPerTask;
  350. m_numCommands -= m_numCommandsPerTask;
  351. m_commandArray  = hkAddByteOffsetConst(m_commandArray, m_numCommandsPerTask * sizeof(hkpPairGetClosestPointsCommand));
  353. return hkJobQueue::DO_NOT_POP_QUEUE_ENTRY;
  354. }
  356. return hkJobQueue::POP_QUEUE_ENTRY;
  357. }
  360. // ===============================================================================================================================================================================================
  361. //  WORLD GET CLOSEST POINTS
  362. // ===============================================================================================================================================================================================
  364. hkpWorldGetClosestPointsJob::hkpWorldGetClosestPointsJob( const hkpProcessCollisionInput* input, hkpCollisionQueryJobHeader* jobHeader, const hkpWorldGetClosestPointsCommand* commandArray, int numCommands, hkpPairGetClosestPointsCommand* pairGetClosestPointsCommandBuffer, int pairGetClosestPointsCommandBufferCapacity, const hkpBroadPhase* broadphase, hkReal tolerance, hkSemaphoreBusyWait* semaphore) 
  365. : hkpCollisionQueryJob(COLLISION_QUERY_WORLD_GET_CLOSEST_POINTS, sizeof(hkpWorldGetClosestPointsJob))
  366. {
  367. HK_ASSERT2( 0xaf236152, jobHeader && ((hkUlong)jobHeader & 0xf) == 0, "jobHeader has to be set and be 16 byte aligned." );
  368. HK_ASSERT2( 0xaf3647f6, numCommands > 0 && numCommands <= MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK, "numCommands has to be > 0 and <= " << MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK << "." );
  369. HK_ASSERT2( 0xaf3647f7, commandArray && ((hkUlong)commandArray & 0xf) == 0, "commandArray has to be set and 16 byte aligned." );
  370. HK_ASSERT2( 0xaf3647f8, ((hkUlong)pairGetClosestPointsCommandBuffer & 0xf) == 0, "pairGetClosestPointsCommandBuffer has to be either HK_NULL or 16 byte aligned." );
  372. {
  373. for (int i=0; i<numCommands; i++)
  374. {
  375. hkpWorldGetClosestPointsCommand* command = const_cast<hkpWorldGetClosestPointsCommand*>( &commandArray[i] );
  377. #if defined(HK_DEBUG)
  378. HK_ASSERT2( 0xaf3647f9, command->m_resultsCapacity > 0, "hkpWorldGetClosestPointsCommand::m_resultsCapacity has to be > 0." );
  379. HK_ASSERT2( 0xaf3647fb, command->m_results && ((hkUlong)command->m_results & 0xf) == 0, "hkpWorldGetClosestPointsCommand::m_results has to be set and 16 byte aligned." );
  380. #endif
  382. command->m_numResultsOut = 0;
  383. }
  384. }
  386. #if defined(HK_DEBUG)
  387. // This is a very simple and crude attempt to try to catch a common mistake where the user might
  388. // forget to actually advance the pointer to the results. Doing so could cause incorrect query results.
  389. // This check though will NOT catch trickier situations like e.g. partially overlapping results.
  390. if ( numCommands > 1 )
  391. {
  392. HK_ASSERT2(0xaf253417, commandArray[0].m_results != commandArray[1].m_results, "You are not allowed to re-use the same results buffer for two different query commands.");
  393. }
  394. #endif
  396. m_collisionInput = input;
  397. m_sharedJobHeaderOnPpu = jobHeader;
  399. m_broadphase = broadphase;
  400. m_tolerance = tolerance;
  402. m_semaphore = semaphore;
  403. m_commandArray = commandArray;
  404. m_numCommands = numCommands;
  406. m_pairGetClosestPointsCommandBuffer = pairGetClosestPointsCommandBuffer;
  407. m_pairGetClosestPointsCommandBufferCapacity = pairGetClosestPointsCommandBufferCapacity;
  409. m_sharedJobHeaderOnPpu->m_openJobs = OPEN_JOBS_PRESET;
  410. }
  412. // ===============================================================================================================================================================================================
  413. //  KD-TREE AABB QUERY
  414. // ===============================================================================================================================================================================================
  416. hkpKdTreeAabbJob::hkpKdTreeAabbJob(hkpCollisionQueryJobHeader* jobHeader, hkpKdTreeAabbCommand* commandArray, int numCommands, hkSemaphoreBusyWait* semaphore, int numCommandsPerTask) 
  417. :  hkpCollisionQueryJob(COLLISION_QUERY_KD_TREE_AABB_QUERY_JOB, sizeof(hkpKdTreeAabbJob) )
  418. {
  419. HK_ASSERT2( 0xaf236152, jobHeader && ((hkUlong)jobHeader & 0xf) == 0, "jobHeader has to be set and be 16 byte aligned." );
  420. HK_ASSERT2( 0xaf3647f6, numCommands > 0, "numCommands has to be > 0." );
  421. HK_ASSERT2( 0xaf3647f7, commandArray && ((hkUlong)commandArray & 0xf) == 0, "commandArray has to be set and 16 byte aligned." );
  422. HK_ASSERT2( 0xaf3647fd, numCommandsPerTask > 0 && numCommandsPerTask <= MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK, "numCommandsPerTask has to be > 0 and <= " << MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK << "." );
  424. #if defined(HK_DEBUG)
  425. {
  426. hkKdTreeCheckCommandPointers<hkpKdTreeAabbCommand>(commandArray, numCommands);
  427. }
  428. #endif
  430. m_sharedJobHeaderOnPpu = jobHeader;
  432. m_numCommandsPerTask = numCommandsPerTask;
  433. m_semaphore = semaphore;
  434. m_aabbCommandArray = commandArray;
  435. m_numAabbCommands = numCommands;
  437. m_numTrees = 0;
  438. m_trees[0] = HK_NULL;
  440. // precalculate the total number of jobs that will be spawned from the original job (incl. the original)
  441. m_sharedJobHeaderOnPpu->m_openJobs = ((numCommands-1)/numCommandsPerTask) + 1;
  443. m_jobSpuType = HK_JOB_SPU_TYPE_ENABLED; // all kd tree jobs run on the SPU
  444. }
  446. // ===============================================================================================================================================================================================
  447. //  KD-TREE LINEAR CAST
  448. // ===============================================================================================================================================================================================
  450. hkpKdTreeLinearCastJob::hkpKdTreeLinearCastJob( const hkpProcessCollisionInput* input, hkpCollisionQueryJobHeader* jobHeader, hkpWorldLinearCastCommand* commandArray, int numCommands, hkSemaphoreBusyWait* semaphore, int numCommandsPerTask) 
  451. :  hkpCollisionQueryJob(COLLISION_QUERY_KD_TREE_LINEAR_CAST_JOB, sizeof(hkpKdTreeLinearCastJob) )
  452. {
  453. HK_ASSERT2( 0xaf236152, jobHeader && ((hkUlong)jobHeader & 0xf) == 0, "jobHeader has to be set and be 16 byte aligned." );
  454. HK_ASSERT2( 0xaf3647f6, numCommands > 0, "numCommands has to be > 0." );
  455. HK_ASSERT2( 0xaf3647f7, commandArray && ((hkUlong)commandArray & 0xf) == 0, "commandArray has to be set and 16 byte aligned." );
  456. HK_ASSERT2( 0xaf3647fd, numCommandsPerTask > 0 && numCommandsPerTask <= MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK, "numCommandsPerTask has to be > 0 and <= " << MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK << "." );
  458. #if defined(HK_DEBUG)
  459. {
  460. hkKdTreeCheckCommandPointers<hkpWorldLinearCastCommand>(commandArray, numCommands);
  461. hkKdTreeCheckCommandCapacity<hkpWorldLinearCastCommand>(commandArray, numCommands);
  462. }
  463. #endif
  465. m_sharedJobHeaderOnPpu = jobHeader;
  466. m_collisionInput = input;
  467. m_filter = HK_NULL;
  469. m_numCommandsPerTask = numCommandsPerTask;
  470. m_semaphore = semaphore;
  471. m_commandArray = commandArray;
  472. m_numCommands = numCommands;
  474. m_numTrees = 0;
  475. m_trees[0] = HK_NULL;
  477. // precalculate the total number of jobs that will be spawned from the original job (incl. the original)
  478. m_sharedJobHeaderOnPpu->m_openJobs = ((numCommands-1)/numCommandsPerTask) + 1;
  480. }
  483. /*
  484. * Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20090216)
  485. * 
  486. * Confidential Information of Havok.  (C) Copyright 1999-2009
  487. * Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
  488. * Logo, and the Havok buzzsaw logo are trademarks of Havok.  Title, ownership
  489. * rights, and intellectual property rights in the Havok software remain in
  490. * Havok and/or its suppliers.
  491. * 
  492. * Use of this software for evaluation purposes is subject to and indicates
  493. * acceptance of the End User licence Agreement for this product. A copy of
  494. * the license is included with this software and is also available at www.havok.com/tryhavok.
  495. * 
  496. */