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

其他游戏

开发平台:

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_ANIMATED_SKELETON_H
  9. #define HK_ANIMATED_SKELETON_H
  10. #include <Common/Base/hkBase.h>
  11. #include <Animation/Animation/Playback/Control/hkaAnimationControlListener.h>
  12. #include <Animation/Animation/Animation/hkaAnnotationTrack.h>
  13. #include <Animation/Animation/Animation/hkaAnimation.h>
  14. class hkaSkeleton;
  15. class hkaChunkCache;
  16. class hkaAnimationControl;
  17. class hkaPose;
  18. /// This class manages the runtime instance of each skeleton.
  19. /// It is responsible for maintaining the currently active animation controls.
  20. /// It also performs animation blending and mixing.
  21. ///  In general controls are sampled and blended by adding their contributions and renormalizing.
  22. ///  If an animation binding has a blend hint of additive then this is layered on after other controls
  23. ///  have been accumulated and renormalized.
  24. class hkaAnimatedSkeleton : public hkReferencedObject, protected hkaAnimationControlListener
  25. {
  26. public:
  27. HK_DECLARE_CLASS_ALLOCATOR(HK_MEMORY_CLASS_ANIM_RUNTIME);
  28. /// The skeleton below is not reference counted and must persist for the lifetime of this hkaAnimatedSkeleton instance
  29. hkaAnimatedSkeleton( const hkaSkeleton* skeleton );
  30. ~hkaAnimatedSkeleton();
  31. /// Iterates through all controls and advances each of their local clocks
  32. virtual void stepDeltaTime( hkReal time );
  33. /// This method is the core of the blending and binding.
  34. /// It queries all active controls and samples their animations by
  35. /// iterating over the skeleton extracting bound animation track info.
  36. /// It then accumulates or blends this data across tracks into a single local
  37. /// pose. An optional cache can be passed to improve decompression performance.
  38. virtual void sampleAndCombineAnimations( hkQsTransform* poseLocalSpaceOut, hkReal* floatSlotsOut, hkaChunkCache* cache = HK_NULL ) const;
  39. /// This method is the core of the blending and binding.
  40. /// It queries all active controls and samples their animations by
  41. /// iterating over the skeleton extracting bound animation track info.
  42. /// It then accumulates or blends this data across tracks into a single local
  43. /// pose. An optional cache can be passed to improve decompression performance.
  44. /// This method will sample only the first maxBones bones and the first maxFloatSlots slots
  45. /// in the skeleton, to assist in LODing animations.
  46. virtual void sampleAndCombinePartialAnimations( hkQsTransform* poseLocalSpaceOut, hkUint32 maxBones, hkReal* floatSlotsOut, hkUint32 maxFloatSlots, hkaChunkCache* cache = HK_NULL ) const;
  47. /// This method allows the user to sample the local space transform of a single bone
  48. /// param localSpaceOut Output transform to store the local transform of the bone in
  49. /// param bone Index of the requested bone (must be valid for the associated skeleton)
  50. /// param cache Cache provided (if any)
  51. virtual void sampleAndCombineSingleBone( hkQsTransform* localSpaceOut, hkInt16 bone, hkaChunkCache* cache = HK_NULL ) const;
  52. /// This method allows the user to sample the value of a single float slot
  53. /// param floatOut Output value to store the current value of the slot in
  54. /// param slot Index of the requested slot (must be valid for the associated skeleton)
  55. /// param cache Cache provided (if any)
  56. virtual void sampleAndCombineSingleSlot( hkReal* floatOut, hkInt16 slot, hkaChunkCache* cache = HK_NULL ) const;
  57. /// This method allows the user to sample the local space transforms of a series of bones
  58. /// param localSpaceOut Output transform array to store the local transforms of the bone in (must be numBones in size)
  59. /// param bones Array of indicies of the requested bones (must be numBones in size)
  60. /// param numBones Number of bones to sample
  61. /// param cache Cache provided (if any)
  62. virtual void sampleAndCombineIndividualBones( hkQsTransform* localSpaceOut, hkInt16* bones, hkUint32 numBones, hkaChunkCache* cache = HK_NULL ) const;
  63. /// This method allows the user to sample the values of a series of float slots
  64. /// param floatOut Output value array to store the values of the requested slots in (must be numSlots in size)
  65. /// param slots Array of indicies of the requested slots (must be numSlots in size)
  66. /// param numSlots Number of float slots to sample
  67. /// param cache Cache provided (if any)
  68. virtual void sampleAndCombineIndividualSlots( hkReal* floatOut, hkInt16* slots, hkUint32 numSlots, hkaChunkCache* cache = HK_NULL ) const;
  69. /// Access to the original skeleton 
  70. inline const hkaSkeleton* getSkeleton() const;
  71. /// If the total weight on any bone falls below the reference pose weight threshold
  72. /// we begin to blend in the reference pose.
  73. inline hkReal getReferencePoseWeightThreshold() const;
  74. /// If the total weight on any bone falls below the reference pose threshold
  75. /// we begin to blend in the reference pose.
  76. void setReferencePoseWeightThreshold( hkReal val );
  77. /// Calculates the change in root position and orientation for a given timestep.
  78. /// This combines the weighted contributions from each of then playing animations.
  79. void getDeltaReferenceFrame(hkReal deltaTimestep, hkQsTransform& deltaMotionOut) const;
  80. /*
  81.  * Animation controls
  82.  */
  83. /// Add an animation control.
  84. /// If the weight on this control is > 0 then the associated animation
  85. /// will be blended and combined.
  86. void addAnimationControl( hkaAnimationControl*  animation );
  87. /// Remove an animation control
  88. void removeAnimationControl( hkaAnimationControl* animation );
  89. /// Return the number of added controls
  90. inline int getNumAnimationControls() const;
  91. /// Access to an animation control.
  92. inline hkaAnimationControl* getAnimationControl( int i ) const ;
  93. /*
  94.  * Annotation support
  95.  */
  96. /// A structure to hold annotation results
  97. /// The ID is remaped from an animation track ID to a skelton bone ID
  98. /// This class MUST have the same declaration as hkaAnimation::TrackAnnotation
  99. struct BoneAnnotation
  100. {
  101. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_ANIM_RUNTIME, hkaAnimatedSkeleton::BoneAnnotation );
  102. /// The bone which is annotated
  103. hkUint16 m_boneID;
  104. /// Annotation data
  105. hkaAnnotationTrack::Annotation m_annotation;
  106. };
  107. /// Examine all animation controls and counts the annotations that occur
  108. /// in the timestep. Usually you query this in advance of stepping the controls
  109. hkUint32 getNumAnnotations( hkReal deltaTime ) const;
  110. /// Fill annotationsOut with annotations which reside in the current timestep for all animations
  111. /// annotationsOut must be pre-allocated.  Up to the first maxNumAnnotations are returned (see getNumAnnotations)
  112. /// return The number of annotations found
  113. hkUint32 getAnnotations(hkReal deltaTime, BoneAnnotation* annotationsOut, hkUint32 maxNumAnnotations = HK_INT32_MAX ) const;
  114. protected:
  115. /// Array of controls.
  116. HK_ALIGN16( hkArray<hkaAnimationControl*> m_animationControls );
  117. /// The skeleton associated with all animations/controls.
  118. const hkaSkeleton* m_skeleton;
  119. /// The fill threshold below which the reference pose will be blending in when the sum of the control weights is small.
  120. hkReal m_referencePoseWeightThreshold;
  121. /// Animation Control listener interface
  122. virtual void controlDeletedCallback(hkaAnimationControl* control);
  123. void sampleAndCombineInternal( hkQsTransform* poseLocalSpaceOut, hkUint32 maxBones, hkReal* floatSlotsOut, hkUint32 maxFloatSlots, hkaChunkCache* cache, bool partial ) const;
  124. void sampleAndCombineIndividual( hkUint32 numBones, const hkInt16* individualBones, hkQsTransform* poseLocalSpaceOut, hkUint32 numFloatSlots, const hkInt16* individualSlots, hkReal* floatSlotsOut, hkaChunkCache* cache ) const;
  125. };
  126. #include <Animation/Animation/Playback/hkaAnimatedSkeleton.inl>
  127. #endif // HK_ANIMATED_SKELETON_H
  128. /*
  129. * Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20090216)
  130. * Confidential Information of Havok.  (C) Copyright 1999-2009
  131. * Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
  132. * Logo, and the Havok buzzsaw logo are trademarks of Havok.  Title, ownership
  133. * rights, and intellectual property rights in the Havok software remain in
  134. * Havok and/or its suppliers.
  135. * Use of this software for evaluation purposes is subject to and indicates
  136. * acceptance of the End User licence Agreement for this product. A copy of
  137. * the license is included with this software and is also available at www.havok.com/tryhavok.
  138. */