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

其他游戏

开发平台:

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_COLLIDE2_MESH_SHAPE_H
  9. #define HK_COLLIDE2_MESH_SHAPE_H
  10. #include <Physics/Collide/Shape/Compound/Collection/hkpShapeCollection.h>
  11. #include <Physics/Collide/Shape/Convex/Triangle/hkpTriangleShape.h>
  12. extern hkReal hkConvexShapeDefaultRadius;
  13. extern const hkClass hkpMeshShapeClass;
  14. class hkpMeshMaterial;
  15. class hkpSimpleMeshShape;
  16. class hkpMoppBvTreeShape;
  17. /// DEPRECATED. This shape will be removed in future releases of Havok Physics.
  18. ///
  19. /// A class for wrapping geometric collision detection information.  It can directly reference
  20. /// sets of triangle strips with vertex striding, and either 16 or 32 bit indices to vertices.
  21. /// It can also directly reference triangle soups, using three indices per triangle rather than one.
  22. /// It also handles degenerate triangles internally, so no extra checking is required by the user.
  23. /// The mesh shape creates hkTriangleShapes in the ShapeBuffer passed in to the getChildShape function.
  24. /// It gives these shapes a radius (see hkpConvexShape::getRadius())  as specified by the hkpMeshShape::getRadius() function.
  25. class hkpMeshShape: public hkpShapeCollection
  26. {
  27. public:
  28. HK_DECLARE_REFLECTION();
  29. HK_DECLARE_CLASS_ALLOCATOR(HK_MEMORY_CLASS_CDINFO);
  30. /// Constructs a new hkpMeshShape.
  31. /// "numBitsForSubpart" is the number of bits used (in the 32 bit shape key) for the subpart index.
  32. /// The remaining bits from the 32 bit shape key are used for the triangle index. By
  33. /// default numBitsForSubpartIndex is 12, which means the mesh shape can have 2^12 - 1
  34. /// subparts (0xffffffff is the "invalid" shape key) = 4095, and each subpart can have 2^20 triangles = 1048576.
  35. /// The subpart is stored in the high bits, so you can extract subpart/triangle indices like this:<br>
  36. /// int subPart = key >> ( 32 - mymesh->getNumBitsForSubpartIndex() );<br>
  37. /// int triIndex = key & ( 0xffffffff >> mymesh->getNumBitsForSubpartIndex() );
  38. hkpMeshShape( hkReal radius = hkConvexShapeDefaultRadius, int numBitsForSubpartIndex = 12 );
  39. /// Compute welding info. In order to weld collisions between triangles in this mesh, welding info must be created.
  40. /// You must call this after all subparts have been added to the mesh.
  41. /// The hkpMoppBvTreeShape you pass in must be built referencing this hkpMeshShape.
  42. /// This adds an additional 2 bytes per triangle storage overhead.
  43. /// This is an expensive call, and should be done off line, and the resultant hkpMeshShape
  44. /// serialized, to save the runtime overhead of computing the welding info.
  45. void computeWeldingInfo( const hkpMoppBvTreeShape* mopp, hkpWeldingUtility::WeldingType weldingType );
  46. //
  47. // Subpart access
  48. //
  49. struct Subpart;
  50. /// Adds a subpart. To modify this subpart later on, call getSubpartAt(int ).xxxx = xxxx.
  51. /// If the a part added has no material stored, an empty (all zero) material is created and stored with the part.
  52. virtual void addSubpart( const Subpart& part );
  53. /// Returns the number of subparts.
  54. inline int getNumSubparts() const;
  55. /// Gets read/write access to a subpart.
  56. inline Subpart& getSubpartAt( int i );
  57. /// Gets const access to a subpart.
  58. inline const Subpart& getSubpartAt( int i ) const;
  59. /// Gets the subpart that a shape key belongs to.
  60. inline const Subpart& getSubPart( hkpShapeKey shapeKey ) const;
  61. /// Gets the number of bits of a shape key used to encode the subpart.
  62. inline hkInt32 getNumBitsForSubpartIndex() const;
  63. //
  64. // Scaling and radius access
  65. //
  66. /// Set the scaling of the mesh shape
  67. void setScaling( const hkVector4& scaling );
  68. /// Get the scaling of the mesh shape
  69. inline const hkVector4& getScaling() const;
  70. /// Gets the extra radius for every triangle.
  71. inline hkReal getRadius() const;
  72. /// Sets the extra radius for every triangle.
  73. inline void setRadius(hkReal r );
  74. //
  75. // hkpShape Collection interface
  76. //
  77. /// Get the first child shape key.
  78. virtual hkpShapeKey getFirstKey() const;
  79. /// This function implements hkpShapeCollection::getNextKey
  80. /// NOTE: This function calls hkpTriangleUtil::isDegenerate to make sure no keys for degenerate triangles are returned
  81. /// If you are implementing your own mesh shape, your getNextKey function must make sure that it similarly does
  82. /// not return keys for degenerate triangles. You can use the hkpTriangleUtil::isDegenerate utility function to check whether
  83. /// triangles are valid.
  84. virtual hkpShapeKey getNextKey( hkpShapeKey oldKey ) const;
  85. /// Because the hkpMeshShape references into client data,
  86. /// it must create a new hkpTriangleShape to return to the caller when this function is called.
  87. /// This triangle is stored in the char* buffer.
  88. /// Degenerate triangles in the client data are handled gracefully through this method.
  89. const hkpShape* getChildShape( hkpShapeKey key, ShapeBuffer& buffer ) const;
  90. /// Gets the mesh material by shape key or -1 if there is no material indices.
  91. inline int getMaterialIndex( hkpShapeKey key ) const;
  92. /// Gets the mesh material by shape key, or returns HK_NULL if m_materialIndexBase isn't defined.
  93. /// Note that addSubpart() might have created an empty (all zero) material.
  94. inline const hkpMeshMaterial* getMeshMaterial( hkpShapeKey key ) const;
  95. /// Returns getMeshMaterial(key)->m_filterInfo or zero if there is no material for the key.
  96. virtual hkUint32 getCollisionFilterInfo( hkpShapeKey key ) const;
  97. //
  98. // hkpShape interface
  99. //
  100. /// A precise but not very fast implementation of getting an AABB.
  101.   void getAabbImpl( const hkTransform& localToWorld, hkReal tolerance, hkAabb& out  ) const;
  102.         virtual void calcContentStatistics( hkStatisticsCollector* collector, const hkClass* cls) const;
  103. public:
  104. /// This member variable to determine the maximum triangle size allowed.
  105. /// This defaults to 1e-7 (and is used to check against the triangle area squared). If you have algorithms
  106. /// that fail with triangles passed by this value, you can increase it to make the culling more aggressive.
  107. static hkReal m_triangleDengeneracyTolerance;
  108. public:
  109. /// The striding of mesh indices
  110. enum MeshShapeIndexStridingType
  111. {
  112. INDICES_INVALID, // default, will raise assert.
  113. /// 16 bit "short" striding
  114. INDICES_INT16,
  115. /// 32 bit "int" striding
  116. INDICES_INT32,
  117. INDICES_MAX_ID
  118. };
  119. enum MeshShapeMaterialIndexStridingType
  120. {
  121. MATERIAL_INDICES_INVALID,
  122. MATERIAL_INDICES_INT8,
  123. MATERIAL_INDICES_INT16,
  124. MATERIAL_INDICES_MAX_ID
  125. };
  126. /// A subpart defines a triangle, a triangle list or a triangle strip.
  127. struct Subpart
  128. {
  129. HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_COLLIDE, hkpMeshShape::Subpart );
  130. HK_DECLARE_REFLECTION();
  131. /// A partial initializing constructor. It will only set values in Debug
  132. /// apart from a default material that gets set in Release too.
  133. inline Subpart();
  134. //
  135. // Vertex information
  136. //
  137. /// A pointer to the first vertex, defined by three floats.
  138. const float*  m_vertexBase; //+nosave
  139. /// The byte offset between two consecutive vertices (usually 12, 16 or more).
  140. int m_vertexStriding;
  141. /// The number of vertices.
  142. int m_numVertices;
  143. //
  144. // Triangle Index Information
  145. //
  146. /// A pointer to triples of vertex indices.
  147. /// Used to be a union type, but to make
  148. /// auto serialization possible, we leave it as
  149. /// a void* here.
  150. const void* m_indexBase; //+nosave
  151. /// A type defining whether 16 or 32 bits are used to index vertices.
  152. hkEnum<MeshShapeIndexStridingType,hkInt8> m_stridingType;
  153. /// A type defining whether 8 or 16 bits are used to index material.
  154. hkEnum<MeshShapeMaterialIndexStridingType,hkInt8> m_materialIndexStridingType;
  155. /// The byteoffset between two indices triples.
  156. ///  - Eg. (Usually sizeof(hkUint16) if you use triangle strips
  157. ///  - or 3 * sizeof(hkUint16) if you use independent triangles
  158. int m_indexStriding;
  159. /// A flag used to specify whether triangles should be returned wound the same way
  160. /// or alternate ways.  It must be set to 0 or 1, and defaults to 0.
  161. /// If Triangle strips are used, each subsequent triangle in a list
  162. /// will be wound the alternate way. However for one sided welding, we require that
  163. /// all triangles have a consistent winding. This flag should be set to 1 in this case.  This
  164. /// means the first triangle will be returned with vertices set to (0, 1, 2) and the second
  165. /// triangle will be returned with vertices set to (1, 3, 2). If this flag is set to 0 the
  166. /// second triangle will be returned with vertices set to (1, 2, 3). If independent triangles
  167. /// are used this flag should be set to 0 to maintain winding.
  168. int m_flipAlternateTriangles;
  169. /// The number of index triples, which is equal to the number of triangles.
  170. int m_numTriangles;
  171. //
  172. // Per triangle material Id info
  173. //
  174. /// Pointer to a strided array of material index (hkUint8 or hkUint16), one index for each triangle.
  175. ///  - You are limited to a maximum of 256 or 65535 materials per subpart.
  176. ///  - The indices may be stored in an interleaved array by setting m_materialIndexStriding appropriately.
  177. ///  - If you do not want to use materials, simply set this element to HK_NULL
  178. const void* m_materialIndexBase; //+nosave
  179. /// The byte offset between two material indices
  180. /// This will be sizeof(hkUint8) or sizeof(hkUint16) for non-interleaved arrays.
  181. int m_materialIndexStriding;
  182. /// The base for the material table, the byte offset between two hkMeshMaterials is defined by
  183. /// m_materialStriding. If you are storing your materials externally and not using per-triangle filtering
  184. /// set this element to HK_NULL. The material array may be shared between meshes.
  185. const hkpMeshMaterial* m_materialBase; //+nosave
  186. /// The byte offset between two hkMeshMaterials
  187. int m_materialStriding;
  188. /// The number of materials, only used for debug checking
  189. int m_numMaterials;
  190. /// This information is set automatically when a subpart is added to a mesh and should be left at -1.
  191. /// It is the offset in a global array for all triangles in the mesh of the first triangle of this sub piece
  192. /// This info is used for "welding" collisions between triangles.
  193. int m_triangleOffset; //+default(-1)
  194. };
  195. public:
  196. hkVector4 m_scaling;
  197. hkInt32 m_numBitsForSubpartIndex;
  198. hkArray<struct Subpart> m_subparts;
  199. hkArray<hkUint16> m_weldingInfo;
  200. hkEnum<hkpWeldingUtility::WeldingType, hkUint8> m_weldingType; // +default(hkpWeldingUtility::WELDING_TYPE_NONE)
  201. public:
  202. hkpMeshShape( hkFinishLoadedObjectFlag flag );
  203. protected:
  204. friend class hkpExtendedMeshShape;
  205. /// The radius can only be set on construction.
  206. hkReal m_radius;
  207. int m_pad[3]; // pad so same layout on 4x[10]x
  208. void assertSubpartValidity( const Subpart& part );
  209. };
  210. #include <Physics/Collide/Shape/Deprecated/Mesh/hkpMeshShape.inl>
  211. #endif // HK_COLLIDE2_MESH_SHAPE_H
  212. /*
  213. * Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20090216)
  214. * Confidential Information of Havok.  (C) Copyright 1999-2009
  215. * Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
  216. * Logo, and the Havok buzzsaw logo are trademarks of Havok.  Title, ownership
  217. * rights, and intellectual property rights in the Havok software remain in
  218. * Havok and/or its suppliers.
  219. * Use of this software for evaluation purposes is subject to and indicates
  220. * acceptance of the End User licence Agreement for this product. A copy of
  221. * the license is included with this software and is also available at www.havok.com/tryhavok.
  222. */