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

其他游戏

开发平台:

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_MESH_BODY_H
  9. #define HK_MESH_BODY_H
  10. class hkTransformSet;
  11. class hkMeshShape;
  12. class hkMeshVertexBuffer;
  13. extern const hkClass hkMeshBodyClass;
  14. /// The mesh body is a transformed instance of a mesh shape
  15. ///
  16. /// This interface is implemented to allow Havok libraries such as destruction to communicate with a graphics implementation.
  17. ///
  18. /// Generally speaking mesh bodies are constructed using the 'createBody' factory method on an hkMeshSystem instance.
  19. /// A mesh body created on a hkMeshSystem in general can only be used on the instance it was constructed on.
  20. ///
  21. /// The hkMeshBody is just a renderable instantiation of a hkMeshShape. The only additional data the body has over the shape
  22. /// is where to draw the mesh shape. Each hkMeshBody has a transform which locates the body in the scene.
  23. /// If the mesh shape associated with the mesh body has skinning information or per mesh section transform indices, additional
  24. /// position information comes in the form of the indexed transform. Each transform is controls a bone and/or a mesh section
  25. /// transform index.
  26. ///
  27. /// To update the position of a hkMeshBody - the methods setTransform() and setIndexedTransforms() can be used. In and of
  28. /// themselves they do not necessarily change the rendering position, as the application has to call 'completeUpdate' to
  29. /// commit the updates. This allows an implementation to potentially optimize how the positional information of the moved
  30. /// body is calculated. Thus correct usage if updating both the main transform and indexed transforms is to call both methods
  31. /// and then finally call 'completeUpdate' so both changes can be processed in one go. If transform updates are made, and
  32. /// 'completeUpdate' is not called behavior is undefined.
  33. ///
  34. /// When implementing the hkMeshBody the implementation should honor how the vertex elements are shared. The most simple way to
  35. /// do this for the hkMeshBody to clone the unique hkVertexBuffers specified in the hkMeshSections of the associated hkMeshShape.
  36. /// If the hkVertexBuffer has been implemented correctly the clone should correctly create deep copies of the unshared members.
  37. /// The hkMeshBody provides a way to gain access to body specific vertex buffers through the 'getVertexBuffer' method. This
  38. /// provides per body access to per body vertex data (ie FLAG_NOT_SHARED elements).
  39. ///
  40. /// If all of the elements vertex buffer are shared an implementation can return HK_NULL to the getVertexBuffer
  41. /// method - in this situation there is no per body vertex information. Also note that an implementation is free to return a
  42. /// vertex buffer with only the non-shared elements as necessary. Having the hkMeshBody return per instance vertex buffers
  43. /// allows the application to modify vertex attributes on a per body level. For example if color was specified to be not
  44. /// shared, on the vertex buffer, then each mesh body could have different colors by modifying their vertex buffers.
  45. ///
  46. /// There are two implementations of hkMeshBody in the standard SDK distribution - firstly the hkgMeshBody, which
  47. /// implements the interface for Havok demos p hkg graphics library. Secondly there is hkMemoryMeshBody - which is an implementation used by
  48. /// the hkMemoryMeshSystem, and isn't designed for rendering but for allowing processing of hkMesh based classes in
  49. /// memory.
  50. ///
  51. /// sa hkMeshShape
  52. class hkMeshBody: public hkReferencedObject
  53. {
  54. public:
  55. HK_DECLARE_CLASS_ALLOCATOR(HK_MEMORY_CLASS_SCENE_DATA);
  56. /// Helper enum to specify what type of pointer is used for mouse picking in the Havok demos
  57.         enum PickDataIdentifier
  58.         {
  59.             PICK_BREAKABLE_BODY = 1,            ///
  60.             PICK_USER = 0x1000,                 ///
  61.         };
  62. /// Get the mesh shape
  63. virtual const hkMeshShape* getMeshShape() const = 0;
  64. /// Get the currently set model to world transform
  65. virtual void getTransform( hkMatrix4& transform ) const = 0;
  66. /// Set the current model to world transform
  67. virtual void setTransform(const hkMatrix4& matrix) = 0;
  68. /// Get the per body per mesh section vertex buffer/s - one per section (note they can be shared)
  69. /// If there is no per body vertex data, this method can return HK_NULL.
  70.             /// The format of this buffer must minimally contain the elements specified as instancable (FLAG_NOT_SHARED elements) in the
  71. /// shapes vertex buffer. It may or may not contained the shared members - reading or writing to non instance
  72. /// members produces undefined results.
  73. virtual hkMeshVertexBuffer* getVertexBuffer(int sectionIndex) = 0;
  74.             /// Get the number of indexed transforms
  75.         virtual int getNumIndexedTransforms() = 0;
  76.             /// Set the indexed transforms - when all changes are made, make a call to 'completeUpdate' to complete the update
  77.         virtual void setIndexedTransforms(int startIndex, const hkMatrix4* matrices, int numMatrices) = 0;
  78.             /// Get the indexed transforms
  79.         virtual void getIndexedTransforms(int startIndex, hkMatrix4* matrices, int numMatrices) = 0;
  80.             /// Get the indexed inverse transforms
  81.         virtual void getIndexedInverseTransforms(int startIndex, hkMatrix4* matrices, int numMatrices) = 0;
  82. /// Set data that is used for picking. Id is used to identify the type of data
  83. virtual hkResult setPickingData(int id, void* data) { return HK_SUCCESS; }
  84. /// If changes are made to the transform set, or the transform, this method
  85.             /// must be called to ensure correct updating of the graphics representation.
  86. virtual void completeUpdate() = 0;
  87. virtual const char* getName() const { return HK_NULL; }
  88. virtual void setName(const char* n) const { }
  89. };
  90. #endif // HK_MESH_BODY_H
  91. /*
  92. * Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20090216)
  93. * Confidential Information of Havok.  (C) Copyright 1999-2009
  94. * Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
  95. * Logo, and the Havok buzzsaw logo are trademarks of Havok.  Title, ownership
  96. * rights, and intellectual property rights in the Havok software remain in
  97. * Havok and/or its suppliers.
  98. * Use of this software for evaluation purposes is subject to and indicates
  99. * acceptance of the End User licence Agreement for this product. A copy of
  100. * the license is included with this software and is also available at www.havok.com/tryhavok.
  101. */