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

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

其他游戏

开发平台：

Visual C++

hkpRayCastQueryJobs.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.  */
  9. hkpRayCastQueryJob::hkpRayCastQueryJob( JobSubType subType,  hkUint16 size )
  10. : hkJob( HK_JOB_TYPE_RAYCAST_QUERY, subType, size, HK_JOB_SPU_TYPE_DISABLED ),
  11. m_semaphore(HK_NULL), m_jobDoneFlag(HK_NULL)
  12. {
  13. m_jobSpuType = HK_JOB_SPU_TYPE_ENABLED; // all kd tree jobs run on the SPU
  14. m_sharedJobHeaderOnPpu = HK_NULL;
  15. }
  17. inline void hkpRayCastQueryJob::atomicIncrementAndReleaseSemaphore() const
  18. {
  19. if (m_jobDoneFlag)
  20. {
  21. hkCriticalSection::atomicExchangeAdd(m_jobDoneFlag, 1);
  22. }
  24. if (m_semaphore)
  25. {
  26. hkSemaphoreBusyWait::release(m_semaphore);
  27. }
  28. }
  30. // ===============================================================================================================================================================================================
  31. //  SHAPE RAYCAST
  32. // ===============================================================================================================================================================================================
  34. hkpShapeRayCastJob::hkpShapeRayCastJob( const hkpProcessCollisionInput* input, hkpCollisionQueryJobHeader* jobHeader, const hkpShapeRayCastCommand* commandArray, int numCommands, hkSemaphoreBusyWait* semaphore, int numCommandsPerTask) 
  35. : hkpRayCastQueryJob(RAYCAST_QUERY_SHAPE_RAYCAST, sizeof(hkpShapeRayCastJob))
  36. {
  37. HK_ASSERT2( 0xaf236153, jobHeader, "jobHeader has to be set." );
  38. HK_ASSERT2( 0xaf3647f2, numCommands > 0, "numCommands has to be > 0." );
  39. HK_ASSERT2( 0xaf3647e3, commandArray, "commandArray has to be set." );
  41. HK_ASSERT2( 0xaf236158, ((hkUlong)jobHeader & 0xf) == 0, "jobHeader has to be 16 byte aligned." );
  42. HK_ASSERT2( 0xaf3647e9, ((hkUlong)commandArray & 0xf) == 0, "commandArray has to be 16 byte aligned." );
  44. HK_ASSERT2( 0xaf3647ff, numCommandsPerTask > 0 && numCommandsPerTask <= MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK, "numCommandsPerTask has to be > 0 and <= " << MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK << "." );
  46. #if defined(HK_DEBUG)
  47. {
  48. for (int i=0; i<numCommands; i++)
  49. {
  50. const hkpShapeRayCastCommand* command = &commandArray[i];
  52. HK_ASSERT2( 0xaf3647e4, command->m_collidables, "command[ " << i << " ]->m_collidables has to be set." );
  53. HK_ASSERT2( 0xaf3647e5, command->m_results, "command[ " << i << " ]->m_results has to be set." );
  55. HK_ASSERT2( 0xaf3647e6, ((hkUlong)command->m_collidables & 0xf) == 0, "command[ " << i << " ]->m_collidables (address 0x" << command->m_collidables << " has to be 16 byte aligned." );
  56. HK_ASSERT2( 0xaf3647e7, ((hkUlong)command->m_results     & 0xf) == 0, "command[ " << i << " ]->m_results (address 0x" << command->m_results << " has to be 16 byte aligned." );
  58. HK_ASSERT2( 0xaf3648e0, command->m_numCollidables > 0 && command->m_numCollidables <= hkpShapeRayCastCommand::MAXIMUM_NUM_COLLIDABLES, "hkpShapeRayCastCommand::m_numCollidables has to be > 0 and <= " << hkpShapeRayCastCommand::MAXIMUM_NUM_COLLIDABLES << "." );
  59. HK_ASSERT2( 0xaf3648e2, command->m_resultsCapacity > 0 && command->m_resultsCapacity <= hkpShapeRayCastCommand::MAXIMUM_RESULTS_CAPACITY, "hkpShapeRayCastCommand::m_resultsCapacity has to be > 0 and <= " << hkpShapeRayCastCommand::MAXIMUM_RESULTS_CAPACITY << "." );
  60. }
  61. }
  63. // This is a very simple and crude attempt to try to catch a common mistake where the user might
  64. // forget to actually advance the pointer to the results. Doing so could cause incorrect query results.
  65. // This check though will NOT catch trickier situations like e.g. partially overlapping results.
  66. if ( numCommands > 1 )
  67. {
  68. HK_ASSERT2(0xaf253411, commandArray[0].m_results != commandArray[1].m_results, "You are not allowed to re-use the same results buffer for two different query commands.");
  69. }
  70. #endif
  72. m_collisionInput = input;
  73. m_sharedJobHeaderOnPpu = jobHeader;
  74. m_numCommandsPerTask = numCommandsPerTask;
  75. m_semaphore = semaphore;
  76. m_commandArray = commandArray;
  77. m_numCommands = numCommands;
  79. // precalculate the total number of jobs that will be spawned from the original job (incl. the original)
  80. m_sharedJobHeaderOnPpu->m_openJobs = ((numCommands-1)/numCommandsPerTask) + 1;
  81. }
  84. hkJobQueue::JobPopFuncResult hkpShapeRayCastJob::popJobTask( hkpShapeRayCastJob& out )
  85. {
  86. //
  87. // split off a fully filled child job if there are more commands left than one job can handle
  88. //
  89. if ( m_numCommands > m_numCommandsPerTask )
  90. {
  91. out.m_numCommands  = m_numCommandsPerTask;
  92. m_numCommands -= m_numCommandsPerTask;
  93. m_commandArray  = hkAddByteOffsetConst(m_commandArray, m_numCommandsPerTask * sizeof(hkpShapeRayCastCommand));
  95. return hkJobQueue::DO_NOT_POP_QUEUE_ENTRY;
  96. }
  98. return hkJobQueue::POP_QUEUE_ENTRY;
  99. }
  102. // ===============================================================================================================================================================================================
  103. //  WORLD RAYCAST
  104. // ===============================================================================================================================================================================================
  106. hkpWorldRayCastJob::hkpWorldRayCastJob( const hkpProcessCollisionInput* input, hkpCollisionQueryJobHeader* jobHeader, const hkpWorldRayCastCommand* commandArray, int numCommands, const hkpBroadPhase* broadphase, hkSemaphoreBusyWait* semaphore, int numCommandsPerTask)
  107. : hkpRayCastQueryJob( RAYCAST_QUERY_WORLD_RAYCAST, sizeof(hkpWorldRayCastJob) )
  108. {
  109. HK_ASSERT2( 0xaf236152, jobHeader && ((hkUlong)jobHeader & 0xf) == 0, "jobHeader has to be set and be 16 byte aligned." );
  110. HK_ASSERT2( 0xaf3647f6, numCommands > 0, "numCommands has to be > 0." );
  111. HK_ASSERT2( 0xaf3647f7, commandArray && ((hkUlong)commandArray & 0xf) == 0, "commandArray has to be set and 16 byte aligned." );
  112. HK_ASSERT2( 0xaf3647fd, numCommandsPerTask > 0 && numCommandsPerTask <= MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK, "numCommandsPerTask has to be > 0 and <= " << MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK << "." );
  114. #if defined(HK_DEBUG)
  115. {
  116. for (int i=0; i<numCommands; i++)
  117. {
  118. const hkpWorldRayCastCommand* command = &commandArray[i];
  119. HK_ASSERT2( 0xaf3647fe, command->m_results && ((hkUlong)command->m_results & 0xf) == 0, "hkpWorldRayCastCommand::m_results has to be set and 16 byte aligned." );
  121. HK_ASSERT2( 0xaf3638e2, command->m_resultsCapacity > 0 && command->m_resultsCapacity <= hkpWorldRayCastCommand::MAXIMUM_RESULTS_CAPACITY, "hkpWorldRayCastCommand::m_resultsCapacity has to be > 0 and <= " << hkpWorldRayCastCommand::MAXIMUM_RESULTS_CAPACITY << "." );
  122. }
  123. }
  125. // This is a very simple and crude attempt to try to catch a common mistake where the user might
  126. // forget to actually advance the pointer to the results. Doing so could cause incorrect query results.
  127. // This check though will NOT catch trickier situations like e.g. partially overlapping results.
  128. if ( numCommands > 1 )
  129. {
  130. HK_ASSERT2(0xaf253412, commandArray[0].m_results != commandArray[1].m_results, "You are not allowed to re-use the same results buffer for two different query commands.");
  131. }
  132. #endif
  134. m_collisionInput = input;
  136. m_sharedJobHeaderOnPpu = jobHeader;
  138. m_numCommandsPerTask = numCommandsPerTask;
  139. m_semaphore = semaphore;
  140. m_commandArray = commandArray;
  141. m_numCommands = numCommands;
  143. m_broadphase = broadphase;
  145. // precalculate the total number of jobs that will be spawned from the original job (incl. the original)
  146. m_sharedJobHeaderOnPpu->m_openJobs = ((numCommands-1)/numCommandsPerTask) + 1;
  147. }
  150. hkJobQueue::JobPopFuncResult hkpWorldRayCastJob::popJobTask( hkpWorldRayCastJob& out )
  151. {
  152. //
  153. // split off a fully filled child job if there are more commands left than one job can handle
  154. //
  155. if ( m_numCommands > m_numCommandsPerTask )
  156. {
  157. out.m_numCommands  = m_numCommandsPerTask;
  158. m_numCommands -= m_numCommandsPerTask;
  159. m_commandArray  = hkAddByteOffsetConst(m_commandArray, m_numCommandsPerTask * sizeof(hkpWorldRayCastCommand));
  161. return hkJobQueue::DO_NOT_POP_QUEUE_ENTRY;
  162. }
  164. return hkJobQueue::POP_QUEUE_ENTRY;
  165. }
  167. // ===============================================================================================================================================================================================
  168. //  KD-TREE WORLD RAYCAST
  169. // ===============================================================================================================================================================================================
  171. hkpKdTreeRayCastJob::hkpKdTreeRayCastJob(hkpRayCastQueryJobHeader* jobHeader, const hkKdTreeRayCastCommand* commandArray, int numCommands, hkSemaphoreBusyWait* semaphore, int numCommandsPerTask) 
  172. :  hkpRayCastQueryJob(RAYCAST_QUERY_KD_TREE_RAYCAST, sizeof(hkpKdTreeRayCastJob) )
  173. {
  174. HK_ASSERT2( 0xaf236152, jobHeader && ((hkUlong)jobHeader & 0xf) == 0, "jobHeader has to be set and be 16 byte aligned." );
  175. HK_ASSERT2( 0xaf3647f6, numCommands > 0, "numCommands has to be > 0." );
  176. HK_ASSERT2( 0xaf3647f7, commandArray && ((hkUlong)commandArray & 0xf) == 0, "commandArray has to be set and 16 byte aligned." );
  177. HK_ASSERT2( 0xaf3647fd, numCommandsPerTask > 0 && numCommandsPerTask <= MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK, "numCommandsPerTask has to be > 0 and <= " << MAXIMUM_NUMBER_OF_COMMANDS_PER_TASK << "." );
  179. #if defined(HK_DEBUG)
  180. {
  181. hkKdTreeCheckCommandPointers<hkKdTreeRayCastCommand>(commandArray, numCommands);
  182. hkKdTreeCheckCommandCapacity<hkKdTreeRayCastCommand>(commandArray, numCommands);
  183. }
  184. #endif
  186. m_sharedJobHeaderOnPpu = jobHeader;
  188. m_numCommandsPerTask = numCommandsPerTask;
  189. m_semaphore = semaphore;
  190. m_rayCastCommandArray = commandArray;
  191. m_numRayCastCommands = numCommands;
  193. m_rayCastBundleCommandArray = 0;
  194. m_numRayCastBundleCommands = HK_NULL;
  196. m_filter = HK_NULL;
  198. m_numTrees = 0;
  199. m_trees[0] = HK_NULL;
  201. // precalculate the total number of jobs that will be spawned from the original job (incl. the original)
  202. m_sharedJobHeaderOnPpu->m_openJobs = ((numCommands-1)/numCommandsPerTask) + 1;
  203. }
  206. hkJobQueue::JobPopFuncResult hkpKdTreeRayCastJob::popJobTask( hkpKdTreeRayCastJob& out )
  207. {
  208. //
  209. // split off a fully filled child job if there are more commands left than one job can handle
  210. //
  212. hkJobQueue::JobPopFuncResult retVal =  hkJobQueue::POP_QUEUE_ENTRY;
  213. if ( m_numRayCastCommands > m_numCommandsPerTask )
  214. {
  215. out.m_numRayCastCommands  = m_numCommandsPerTask;
  216. m_numRayCastCommands -= m_numCommandsPerTask;
  217. m_rayCastCommandArray  = hkAddByteOffsetConst( m_rayCastCommandArray, m_numCommandsPerTask * sizeof(hkKdTreeRayCastCommand) );
  219. retVal = hkJobQueue::DO_NOT_POP_QUEUE_ENTRY;
  220. }
  222. const int numBundleCommandsPerTask = m_numCommandsPerTask/4;
  223. if ( m_numRayCastBundleCommands > numBundleCommandsPerTask )
  224. {
  225. out.m_numRayCastBundleCommands  = numBundleCommandsPerTask;
  226. m_numRayCastBundleCommands -=  numBundleCommandsPerTask;
  227. m_rayCastBundleCommandArray  = hkAddByteOffsetConst( m_rayCastBundleCommandArray, numBundleCommandsPerTask * sizeof(hkKdTreeRayCastBundleCommand) );
  229. retVal = hkJobQueue::DO_NOT_POP_QUEUE_ENTRY;
  230. }
  232. return retVal;
  233. }
  236. hkpKdTreeBuildJobFast::hkpKdTreeBuildJobFast()
  237. : hkpRayCastQueryJob( RAYCAST_QUERY_KD_TREE_BUILD_FAST, sizeof(hkpKdTreeBuildJobFast) ), 
  238. m_treeDepthOut(HK_NULL)
  239. {
  240. }
  242. hkpKdTreeBuildJobFast::hkpKdTreeBuildJobFast(hkKdTree *tree)
  243. : hkpRayCastQueryJob( RAYCAST_QUERY_KD_TREE_BUILD_FAST, sizeof(hkpKdTreeBuildJobFast) )
  244. {
  245. m_numCollidables = tree->getNumPrimitives();
  246. m_treeOut = tree->getRoot();
  247. m_nodeArraySize = tree->getTotalNumNodes();
  248. m_projEntOut = tree->getProjectedEntries();
  249. m_numAvailableEmptyNodes = tree->getNumReservedEmptyNodes();
  250. m_treeDepthOut = &tree->m_maxDepth;
  252. }
  254. hkpKdTreeBuildDistributedJob::hkpKdTreeBuildDistributedJob(hkpRayCastQueryJobHeader* jobHeader)
  255. : hkpRayCastQueryJob(RAYCAST_QUERY_KD_TREE_BUILD_FAST_DISTRIBUTED_JOB, sizeof(hkpKdTreeBuildDistributedJob) ),
  256. m_branchDepthsOut(HK_NULL)
  257. {
  258. m_sharedJobHeaderOnPpu = jobHeader;
  259. }
  261. hkpKdTreeBuildDistributedJob::hkpKdTreeBuildDistributedJob(hkpRayCastQueryJobHeader* jobHeader, hkKdTree* tree)
  262. : hkpRayCastQueryJob(RAYCAST_QUERY_KD_TREE_BUILD_FAST_DISTRIBUTED_JOB, sizeof(hkpKdTreeBuildDistributedJob) ),
  263. m_branchDepthsOut(HK_NULL)
  264. {
  265. m_sharedJobHeaderOnPpu = jobHeader;
  266. m_numPrimitives = tree->getNumPrimitives();
  267. m_treeOut = tree->getRoot();
  268. m_nodeArraySize = tree->getTotalNumNodes();
  269. m_projEntOut = tree->getProjectedEntries();
  270. m_numAvailableEmptyNodes = tree->getNumReservedEmptyNodes();
  271. }
  273. hkpKdTreeBuildDistributedSubJob::hkpKdTreeBuildDistributedSubJob()
  274. : hkpRayCastQueryJob(RAYCAST_QUERY_KD_TREE_BUILD_FAST_DISTRIBUTED_SUBJOB, sizeof(hkpKdTreeBuildDistributedSubJob) ),
  275. m_branchDepthOut(HK_NULL)
  276. {
  277. }
  279. hkpKdTreeBuildCoordinatorJob::hkpKdTreeBuildCoordinatorJob(hkpRayCastQueryJobHeader* jobHeader, const class hkpWorld* world)
  280. : hkpKdTreeBuildDistributedJob(jobHeader) 
  281. {
  282. m_jobSubType = RAYCAST_QUERY_KD_TREE_BUILD_COORDINATOR_JOB;
  283. m_size = sizeof(hkpKdTreeBuildCoordinatorJob);
  284. m_collisionInput = world->getCollisionInput();
  285. }
  287. hkpKdTreeBuildSetupJob::hkpKdTreeBuildSetupJob()
  288. : hkpKdTreeBuildDistributedJob(HK_NULL), 
  289. m_spawnBuildDistributedJob(false)
  290. {
  291. m_jobSubType = RAYCAST_QUERY_KD_TREE_BUILD_SETUP_JOB;
  292. m_size = sizeof(hkpKdTreeBuildSetupJob);
  293. }
  296. /*
  297. * Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20090216)
  298. * 
  299. * Confidential Information of Havok.  (C) Copyright 1999-2009
  300. * Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
  301. * Logo, and the Havok buzzsaw logo are trademarks of Havok.  Title, ownership
  302. * rights, and intellectual property rights in the Havok software remain in
  303. * Havok and/or its suppliers.
  304. * 
  305. * Use of this software for evaluation purposes is subject to and indicates
  306. * acceptance of the End User licence Agreement for this product. A copy of
  307. * the license is included with this software and is also available at www.havok.com/tryhavok.
  308. * 
  309. */