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

其他游戏

开发平台:

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. #ifdef HK_DEBUG
  9. #define CHECK_INVARIANT() checkPoseValidity();
  10. #define CHECK_INTERNAL_FLAG_IS_CLEAR(f) checkInternalFlagIsClear(F_BONE_INTERNAL_FLAG##f);
  11. #else
  12. #define CHECK_INVARIANT() ;
  13. #define CHECK_INTERNAL_FLAG_IS_CLEAR(f) ;
  14. #endif
  15. const hkaSkeleton* hkaPose::getSkeleton() const
  16. {
  17. return m_skeleton;
  18. }
  19. void hkaPose::syncAll() const
  20. {
  21. syncLocalSpace();
  22. syncModelSpace();
  23. }
  24. int hkaPose::isFlagOn (int boneIdx, hkaPoseFlag enumToCheck) const
  25. {
  26. return m_boneFlags[boneIdx] & enumToCheck;
  27. }
  28. void hkaPose::setFlag (int boneIdx, hkaPoseFlag enumToCheck) const
  29. {
  30. m_boneFlags[boneIdx] |= enumToCheck;
  31. }
  32. void hkaPose::clearFlag (int boneIdx, hkaPoseFlag enumToCheck) const
  33. {
  34. m_boneFlags[boneIdx] &= static_cast<hkaPoseFlag>(~enumToCheck);
  35. }
  36. // Explicit versions of the above where we pass the flag to be modified/axmines
  37. int hkaPose::isFlagOnExplicit (hkaPoseFlag flag, hkaPoseFlag enumToCheck) const
  38. {
  39. return flag & enumToCheck;
  40. }
  41. void hkaPose::setFlagExplicit (hkaPoseFlag& flag, hkaPoseFlag enumToCheck) const
  42. {
  43. flag |= enumToCheck;
  44. }
  45. void hkaPose::clearFlagExplicit (hkaPoseFlag& flag, hkaPoseFlag enumToCheck) const
  46. {
  47. flag &= static_cast<hkaPoseFlag>(~enumToCheck);
  48. }
  49. void hkaPose::clearInternalFlags() const
  50. {
  51. const int numBones = m_boneFlags.getSize();
  52. for (int i=0; i<numBones; ++i)
  53. {
  54. m_boneFlags[i] &= (~M_BONE_INTERNAL_FLAGS);
  55. }
  56. }
  57. hkaPose& hkaPose::operator= ( const hkaPose& other )
  58. {
  59. m_skeleton = other.m_skeleton;
  60. m_localPose = other.m_localPose;
  61. m_modelPose = other.m_modelPose;
  62. m_boneFlags = other.m_boneFlags;
  63. m_modelInSync = other.m_modelInSync;
  64. m_localInSync = other.m_localInSync;
  65. m_floatSlotValues = other.m_floatSlotValues;
  66. return *this;
  67. }
  68. const hkQsTransform& hkaPose::getBoneModelSpace (int boneIdx) const
  69. {
  70. if (!isFlagOn (boneIdx, F_BONE_MODEL_DIRTY))
  71. {
  72. return m_modelPose[boneIdx];
  73. }
  74. else
  75. {
  76. return calculateBoneModelSpace(boneIdx);
  77. }
  78. }
  79. const hkQsTransform& hkaPose::getBoneLocalSpace (int boneIdx) const
  80. {
  81. if (! isFlagOn (boneIdx, F_BONE_LOCAL_DIRTY))
  82. {
  83. return m_localPose[boneIdx];
  84. }
  85. else
  86. {
  87. const hkQsTransform& modelFromBone = m_modelPose[boneIdx];
  88. HK_ASSERT2(0x5a3281f6, ! isFlagOn (boneIdx, F_BONE_MODEL_DIRTY), "Trying to access uninitialized bone in pose" );
  89. const hkInt16 parentIdx = m_skeleton->m_parentIndices[boneIdx];
  90. if (parentIdx != -1)
  91. {
  92. // ask for parent model (may be dirty)
  93. const hkQsTransform& modelFromParent = getBoneModelSpace(parentIdx);
  94. // parentfrombone = inv(modelfromparent) * modelfrombone
  95. m_localPose[boneIdx].setMulInverseMul(modelFromParent, modelFromBone);
  96. }
  97. else
  98. {
  99. m_localPose[boneIdx] = modelFromBone;
  100. }
  101. clearFlag (boneIdx, F_BONE_LOCAL_DIRTY);
  102. CHECK_INVARIANT();
  103. return m_localPose[boneIdx];
  104. }
  105. }
  106. void hkaPose::makeAllChildrenLocalSpace(int boneIdx) const
  107. {
  108. CHECK_INTERNAL_FLAG_IS_CLEAR(1);
  109. const int numBones = m_skeleton->m_numBones;
  110. setFlag(boneIdx, F_BONE_INTERNAL_FLAG1);
  111. // Synchronize all descendants local representation
  112. {
  113. for (int i= boneIdx+1; i<numBones; ++i)
  114. {
  115. const hkInt16 parentId = m_skeleton->m_parentIndices[i];
  116. if (parentId != -1 && isFlagOn(parentId, F_BONE_INTERNAL_FLAG1))
  117. {
  118. getBoneLocalSpace( i ); // sync local
  119. setFlag( i, F_BONE_INTERNAL_FLAG1);
  120. m_modelInSync = false;
  121. }
  122. }
  123. // Dirty all descendants model representation
  124. {
  125. for (int i= boneIdx+1; i < numBones; ++i)
  126. {
  127. hkaPoseFlag f = m_boneFlags[i];
  128. if (isFlagOnExplicit( f, F_BONE_INTERNAL_FLAG1))
  129. {
  130. setFlagExplicit( f, F_BONE_MODEL_DIRTY);
  131. clearFlagExplicit( f, F_BONE_INTERNAL_FLAG1);
  132. m_boneFlags[i] = f;
  133. }
  134. }
  135. }
  136. }
  137. void hkaPose::makeFirstChildrenModelSpace(int boneIdx) const
  138. {
  139. const int numBones = m_skeleton->m_numBones;
  140. for (int i= boneIdx+1; i<numBones; ++i)
  141. {
  142. const hkInt16 parentId = m_skeleton->m_parentIndices[i];
  143. if (parentId == boneIdx)
  144. {
  145. getBoneModelSpace( i ); // sync model
  146. m_boneFlags[i] = F_BONE_LOCAL_DIRTY;
  147. m_localInSync = false;
  148. }
  149. }
  150. }
  151. void hkaPose::setBoneLocalSpace (int boneIdx, const hkQsTransform& boneLocal)
  152. {
  153. // The model transform will be invalidated for all descendants
  154. // Make also sure the local transform for those is in sync
  155. makeAllChildrenLocalSpace(boneIdx);
  156. m_localPose[boneIdx] = boneLocal;
  157. m_boneFlags[boneIdx] = F_BONE_MODEL_DIRTY;
  158. m_modelInSync = false;
  159. CHECK_INVARIANT();
  160. }
  161. void hkaPose::setBoneModelSpace (int boneIdx, const hkQsTransform& boneModel, PropagateOrNot propagateOrNot)
  162. {
  163. if (! propagateOrNot )
  164. {
  165. // The local transform will be invalidated for the first generation of descendants
  166. // Make also sure the model transform for those is in sync
  167. makeFirstChildrenModelSpace(boneIdx);
  168. }
  169. else
  170. {
  171. // Act as if were actually setting the transform in local space
  172. makeAllChildrenLocalSpace(boneIdx);
  173. }
  174. m_modelPose[boneIdx] = boneModel;
  175. m_boneFlags[boneIdx] = F_BONE_LOCAL_DIRTY;
  176. m_localInSync = false;
  177. CHECK_INVARIANT();
  178. }
  179. hkaPose::hkaPose (const hkaSkeleton* skeleton)
  180. : m_skeleton(skeleton), m_modelInSync(false), m_localInSync (false)
  181. {
  182. const int numBones = m_skeleton->m_numBones;
  183. m_modelPose.setSize(numBones);
  184. m_localPose.setSize(numBones);
  185. m_boneFlags.setSize(numBones);
  186. const int sizeRoundedUp = HK_NEXT_MULTIPLE_OF( 4, m_skeleton->m_numFloatSlots);
  187. m_floatSlotValues.reserveExactly(sizeRoundedUp);
  188. m_floatSlotValues.setSize(m_skeleton->m_numFloatSlots, 0.0f);
  189. #ifdef HK_DEBUG
  190. setNonInitializedFlags();
  191. #endif
  192. }
  193. int hkaPose::getRequiredMemorySize (const hkaSkeleton* skeleton)
  194. {
  195. const int numBones = skeleton->m_numBones;
  196. const int floatSizeRoundedUp = HK_NEXT_MULTIPLE_OF( 4, skeleton->m_numFloatSlots);
  197. const int totalSize =  numBones * ( 2 * hkSizeOf(hkQsTransform) + hkSizeOf(hkaPoseFlag) )
  198. + floatSizeRoundedUp * hkSizeOf(hkReal);
  199. return totalSize;
  200. }
  201. hkaPose::hkaPose(const hkaSkeleton* skeleton, void* preallocatedMemory)
  202. : m_skeleton  (skeleton), 
  203. m_localPose (reinterpret_cast<hkQsTransform*> (preallocatedMemory), skeleton->m_numBones, skeleton->m_numBones),
  204. m_modelPose (m_localPose.begin() + skeleton->m_numBones, skeleton->m_numBones, skeleton->m_numBones),
  205. m_boneFlags (reinterpret_cast<hkaPoseFlag*> (m_modelPose.begin() + skeleton->m_numBones), skeleton->m_numBones, skeleton->m_numBones),
  206. m_modelInSync (false),
  207. m_localInSync (false),
  208. m_floatSlotValues (reinterpret_cast<hkReal*> (m_boneFlags.begin() + skeleton->m_numBones), skeleton->m_numFloatSlots, HK_NEXT_MULTIPLE_OF( 4, skeleton->m_numFloatSlots))
  209. {
  210. HK_ASSERT2 (0x4643f989, (reinterpret_cast<hkUlong> (preallocatedMemory) & 0xf) == 0, "Preallocated memory must be 16-byte aligned");
  211. #ifdef HK_DEBUG
  212. setNonInitializedFlags();
  213. #endif
  214. }
  215. const hkArray<hkReal>& hkaPose::getFloatSlotValues() const
  216. {
  217. return m_floatSlotValues;
  218. }
  219. void hkaPose::setFloatSlotValues(const hkArray<hkReal>& floatSlotValues)
  220. {
  221. m_floatSlotValues = floatSlotValues;
  222. }
  223. hkReal hkaPose::getFloatSlotValue(int floatSlotIdx) const
  224. {
  225. return m_floatSlotValues[ floatSlotIdx ];
  226. }
  227. void hkaPose::setFloatSlotValue(int floatSlotIdx, hkReal value)
  228. {
  229. m_floatSlotValues[ floatSlotIdx ] = value;
  230. }
  231. hkArray<hkReal>& hkaPose::getFloatSlotValues()
  232. {
  233. return m_floatSlotValues;
  234. }
  235. /*
  236. * Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20090216)
  237. * Confidential Information of Havok.  (C) Copyright 1999-2009
  238. * Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
  239. * Logo, and the Havok buzzsaw logo are trademarks of Havok.  Title, ownership
  240. * rights, and intellectual property rights in the Havok software remain in
  241. * Havok and/or its suppliers.
  242. * Use of this software for evaluation purposes is subject to and indicates
  243. * acceptance of the End User licence Agreement for this product. A copy of
  244. * the license is included with this software and is also available at www.havok.com/tryhavok.
  245. */