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

其他游戏

开发平台:

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_VERTEX_SHARING_UTIL_H
  9. #define HK_VERTEX_SHARING_UTIL_H
  10. #include <Common/GeometryUtilities/Mesh/hkMeshVertexBuffer.h>
  11. /// Small utility which helps to share vertices which have the same attributes (like uv/normals/tangents ...).
  12. ///
  13. /// The utility is designed to be able to share vertices of any format. It works out if a vertex is that same
  14. /// by comparing the elements. It does not use a memory compare - but goes though each element type using a
  15. /// suitable comparison for the type and taking into account a threshold for equality. The threshold value
  16. /// is a public member that can be altered.
  17. ///
  18. /// Not using a memory comparison allows the sharing to compare vertices that are very similar in value and equate them
  19. /// to being the same value. The work required to the comparison this way is greater - but gives more flexibility. In particular
  20. /// when converting vertices from hkdGeometry - using barycentric coordinates, vertices can be produced with slightly different
  21. /// values. This utility is used to share the vertices in this situation.
  22. ///
  23. /// Internally the vertices are held in a contiguous chunk of memory - in the same layout as vertices held in the
  24. /// hkMemoryVertexBuffer.
  25. ///
  26. /// To use the tool, a hkVertexSharing object should be instantiated. 'Begin' should be called to start sharing
  27. /// vertices - the parameter determines the format of the vertices to be added.
  28. ///
  29. /// The data for the vertex you want to add should be stored in the 'work vertex' which is a chunk of memory large enough
  30. /// to hold a complete vertex. The size of a vertex in bytes - can always be determined by the getVertexStride method.
  31. /// To actually add the vertex held in the 'work vertex' the addVertex method is used. It takes as a parameter a
  32. /// hash that can be rapidly be used to determine vertices which could be shared. For example - there could be multiple
  33. /// vertices produced for a single vertex index (say with different normals) - the index could be used as hash in this
  34. /// case. Or if the position can uniquely be used to identify a vertex position to share - a hash of the position could be used.
  35. ///
  36. /// Once all of the vertices have been added calling the 'end' method will produce a LockedVertices structure holding
  37. /// all of the unique vertices.
  38. ///
  39. /// sa hkMeshVertexBuffer
  40. class hkVertexSharingUtil
  41. {
  42.     public:
  43.         HK_DECLARE_NONVIRTUAL_CLASS_ALLOCATOR( HK_MEMORY_CLASS_SCENE_DATA, hkVertexSharingUtil );
  44.             /// Ctor
  45.         hkVertexSharingUtil();
  46.             /// Get the vertex format
  47.         HK_FORCE_INLINE const hkVertexFormat& getVertexFormat() const { return m_format; }
  48.             /// Must be called before any other operation
  49.         void begin(const hkVertexFormat& format);
  50.             /// Get the work vertex
  51.         HK_FORCE_INLINE hkUint8* getWorkVertex() { return m_workVertex.begin(); }
  52.             /// Get the work vertex layout
  53.         HK_FORCE_INLINE const hkMeshVertexBuffer::LockedVertices& getLockedWorkVertex() const { return m_lockedWorkVertex; }
  54. /// Get the vertex stride
  55. HK_FORCE_INLINE int getVertexStride() const { return m_vertexStride; }
  56.             /// Read only access to vertex data
  57.         HK_FORCE_INLINE const hkUint8* getVertexData() const { return m_vertices.begin(); }
  58.             /// Read access to vertex data
  59.         HK_FORCE_INLINE hkUint8* getVertexData() { return m_vertices.begin(); }
  60.             /// Add a vertex. The vertex data must be stored in the workVertex. Returns the output vertex buffer index. The hash
  61.             /// must not be zero. If the vertices are different the hash has to be different.
  62.         int addVertex(hkUint32 hash);
  63.             /// Finds the vertex index. Returns -1 if not found
  64.         int findVertexIndex(hkUint32 hash, const void* vertex) const;
  65.             /// Add a vertex. The data for the vertex is held in data pointed to by vertex. The data must be
  66.             /// dword aligned, and be in exactly the same layout (memorywise) as the work vertex.
  67.             /// Any padding in the vertex must be zero'd for correct comparison with threshold of 0
  68.         int addVertex(hkUint32 hash, const void* vertex);
  69.             /// The total amount of vertices
  70.         int getNumVertices() const { return m_numVertices; }
  71.             /// Returns total number of unique vertices, and layout pointing to them
  72.         int end(hkMeshVertexBuffer::LockedVertices& lockedVertices);
  73. public:
  74. //
  75.         // public members
  76. //
  77.         hkReal m_threshold;             ///
  78.     protected:
  79.         bool isVertexEqual(const hkUint8* a, const hkUint8* b) const;
  80.         bool isVertexExactlyEqual(const hkUint8* a, const hkUint8* b) const;
  81.         // Maps a hash to the entry index
  82.         hkPointerMap<hkUint32, int> m_hashMap;
  83.         struct Entry
  84.         {
  85.             int m_vertexIndex;
  86.             int m_nextEntryIndex;
  87.         };
  88.         hkArray<Entry> m_entries;
  89.         hkVertexFormat m_format; ///
  90.         int m_vertexStride;             ///
  91.         hkArray<hkUint8> m_vertices;    ///
  92.         int m_numVertices;              ///
  93.         hkArray<hkUint8> m_workVertex;  ///
  94.         hkMeshVertexBuffer::LockedVertices m_lockedWorkVertex;
  95.         // The layout of the vertices
  96.         int m_elementOffsets[hkVertexFormat::MAX_ELEMENTS];    ///
  97. };
  98. #endif // HK_VERTEX_SHARING_UTIL_H
  99. /*
  100. * Havok SDK - NO SOURCE PC DOWNLOAD, BUILD(#20090216)
  101. * Confidential Information of Havok.  (C) Copyright 1999-2009
  102. * Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
  103. * Logo, and the Havok buzzsaw logo are trademarks of Havok.  Title, ownership
  104. * rights, and intellectual property rights in the Havok software remain in
  105. * Havok and/or its suppliers.
  106. * Use of this software for evaluation purposes is subject to and indicates
  107. * acceptance of the End User licence Agreement for this product. A copy of
  108. * the license is included with this software and is also available at www.havok.com/tryhavok.
  109. */