Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016 #ifndef _BT_TRIANGLE_INFO_MAP_H
00017 #define _BT_TRIANGLE_INFO_MAP_H
00018
00019
00020 #include "LinearMath/btHashMap.h"
00021 #include "LinearMath/btSerializer.h"
00022
00023
00025 #define TRI_INFO_V0V1_CONVEX 1
00026 #define TRI_INFO_V1V2_CONVEX 2
00027 #define TRI_INFO_V2V0_CONVEX 4
00028
00029 #define TRI_INFO_V0V1_SWAP_NORMALB 8
00030 #define TRI_INFO_V1V2_SWAP_NORMALB 16
00031 #define TRI_INFO_V2V0_SWAP_NORMALB 32
00032
00033
00036 struct btTriangleInfo
00037 {
00038 btTriangleInfo()
00039 {
00040 m_edgeV0V1Angle = SIMD_2_PI;
00041 m_edgeV1V2Angle = SIMD_2_PI;
00042 m_edgeV2V0Angle = SIMD_2_PI;
00043 m_flags=0;
00044 }
00045
00046 int m_flags;
00047
00048 btScalar m_edgeV0V1Angle;
00049 btScalar m_edgeV1V2Angle;
00050 btScalar m_edgeV2V0Angle;
00051
00052 };
00053
00054 typedef btHashMap<btHashInt,btTriangleInfo> btInternalTriangleInfoMap;
00055
00056
00058 struct btTriangleInfoMap : public btInternalTriangleInfoMap
00059 {
00060 btScalar m_convexEpsilon;
00061 btScalar m_planarEpsilon;
00062 btScalar m_equalVertexThreshold;
00063 btScalar m_edgeDistanceThreshold;
00064 btScalar m_maxEdgeAngleThreshold;
00065 btScalar m_zeroAreaThreshold;
00066
00067
00068 btTriangleInfoMap()
00069 {
00070 m_convexEpsilon = 0.00f;
00071 m_planarEpsilon = 0.0001f;
00072 m_equalVertexThreshold = btScalar(0.0001)*btScalar(0.0001);
00073 m_edgeDistanceThreshold = btScalar(0.1);
00074 m_zeroAreaThreshold = btScalar(0.0001)*btScalar(0.0001);
00075 m_maxEdgeAngleThreshold = SIMD_2_PI;
00076 }
00077 virtual ~btTriangleInfoMap() {}
00078
00079 virtual int calculateSerializeBufferSize() const;
00080
00082 virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
00083
00084 void deSerialize(struct btTriangleInfoMapData& data);
00085
00086 };
00087
00089 struct btTriangleInfoData
00090 {
00091 int m_flags;
00092 float m_edgeV0V1Angle;
00093 float m_edgeV1V2Angle;
00094 float m_edgeV2V0Angle;
00095 };
00096
00097 struct btTriangleInfoMapData
00098 {
00099 int *m_hashTablePtr;
00100 int *m_nextPtr;
00101 btTriangleInfoData *m_valueArrayPtr;
00102 int *m_keyArrayPtr;
00103
00104 float m_convexEpsilon;
00105 float m_planarEpsilon;
00106 float m_equalVertexThreshold;
00107 float m_edgeDistanceThreshold;
00108 float m_zeroAreaThreshold;
00109
00110 int m_nextSize;
00111 int m_hashTableSize;
00112 int m_numValues;
00113 int m_numKeys;
00114 char m_padding[4];
00115 };
00116
00117 SIMD_FORCE_INLINE int btTriangleInfoMap::calculateSerializeBufferSize() const
00118 {
00119 return sizeof(btTriangleInfoMapData);
00120 }
00121
00123 SIMD_FORCE_INLINE const char* btTriangleInfoMap::serialize(void* dataBuffer, btSerializer* serializer) const
00124 {
00125 btTriangleInfoMapData* tmapData = (btTriangleInfoMapData*) dataBuffer;
00126 tmapData->m_convexEpsilon = (float)m_convexEpsilon;
00127 tmapData->m_planarEpsilon = (float)m_planarEpsilon;
00128 tmapData->m_equalVertexThreshold =(float) m_equalVertexThreshold;
00129 tmapData->m_edgeDistanceThreshold = (float)m_edgeDistanceThreshold;
00130 tmapData->m_zeroAreaThreshold = (float)m_zeroAreaThreshold;
00131
00132 tmapData->m_hashTableSize = m_hashTable.size();
00133
00134 tmapData->m_hashTablePtr = tmapData->m_hashTableSize ? (int*)serializer->getUniquePointer((void*)&m_hashTable[0]) : 0;
00135 if (tmapData->m_hashTablePtr)
00136 {
00137
00138 int sz = sizeof(int);
00139 int numElem = tmapData->m_hashTableSize;
00140 btChunk* chunk = serializer->allocate(sz,numElem);
00141 int* memPtr = (int*)chunk->m_oldPtr;
00142 for (int i=0;i<numElem;i++,memPtr++)
00143 {
00144 *memPtr = m_hashTable[i];
00145 }
00146 serializer->finalizeChunk(chunk,"int",BT_ARRAY_CODE,(void*)&m_hashTable[0]);
00147
00148 }
00149
00150 tmapData->m_nextSize = m_next.size();
00151 tmapData->m_nextPtr = tmapData->m_nextSize? (int*)serializer->getUniquePointer((void*)&m_next[0]): 0;
00152 if (tmapData->m_nextPtr)
00153 {
00154 int sz = sizeof(int);
00155 int numElem = tmapData->m_nextSize;
00156 btChunk* chunk = serializer->allocate(sz,numElem);
00157 int* memPtr = (int*)chunk->m_oldPtr;
00158 for (int i=0;i<numElem;i++,memPtr++)
00159 {
00160 *memPtr = m_next[i];
00161 }
00162 serializer->finalizeChunk(chunk,"int",BT_ARRAY_CODE,(void*)&m_next[0]);
00163 }
00164
00165 tmapData->m_numValues = m_valueArray.size();
00166 tmapData->m_valueArrayPtr = tmapData->m_numValues ? (btTriangleInfoData*)serializer->getUniquePointer((void*)&m_valueArray[0]): 0;
00167 if (tmapData->m_valueArrayPtr)
00168 {
00169 int sz = sizeof(btTriangleInfoData);
00170 int numElem = tmapData->m_numValues;
00171 btChunk* chunk = serializer->allocate(sz,numElem);
00172 btTriangleInfoData* memPtr = (btTriangleInfoData*)chunk->m_oldPtr;
00173 for (int i=0;i<numElem;i++,memPtr++)
00174 {
00175 memPtr->m_edgeV0V1Angle = (float)m_valueArray[i].m_edgeV0V1Angle;
00176 memPtr->m_edgeV1V2Angle = (float)m_valueArray[i].m_edgeV1V2Angle;
00177 memPtr->m_edgeV2V0Angle = (float)m_valueArray[i].m_edgeV2V0Angle;
00178 memPtr->m_flags = m_valueArray[i].m_flags;
00179 }
00180 serializer->finalizeChunk(chunk,"btTriangleInfoData",BT_ARRAY_CODE,(void*) &m_valueArray[0]);
00181 }
00182
00183 tmapData->m_numKeys = m_keyArray.size();
00184 tmapData->m_keyArrayPtr = tmapData->m_numKeys ? (int*)serializer->getUniquePointer((void*)&m_keyArray[0]) : 0;
00185 if (tmapData->m_keyArrayPtr)
00186 {
00187 int sz = sizeof(int);
00188 int numElem = tmapData->m_numValues;
00189 btChunk* chunk = serializer->allocate(sz,numElem);
00190 int* memPtr = (int*)chunk->m_oldPtr;
00191 for (int i=0;i<numElem;i++,memPtr++)
00192 {
00193 *memPtr = m_keyArray[i].getUid1();
00194 }
00195 serializer->finalizeChunk(chunk,"int",BT_ARRAY_CODE,(void*) &m_keyArray[0]);
00196
00197 }
00198 return "btTriangleInfoMapData";
00199 }
00200
00201
00202
00204 SIMD_FORCE_INLINE void btTriangleInfoMap::deSerialize(btTriangleInfoMapData& tmapData )
00205 {
00206
00207
00208 m_convexEpsilon = tmapData.m_convexEpsilon;
00209 m_planarEpsilon = tmapData.m_planarEpsilon;
00210 m_equalVertexThreshold = tmapData.m_equalVertexThreshold;
00211 m_edgeDistanceThreshold = tmapData.m_edgeDistanceThreshold;
00212 m_zeroAreaThreshold = tmapData.m_zeroAreaThreshold;
00213 m_hashTable.resize(tmapData.m_hashTableSize);
00214 int i =0;
00215 for (i=0;i<tmapData.m_hashTableSize;i++)
00216 {
00217 m_hashTable[i] = tmapData.m_hashTablePtr[i];
00218 }
00219 m_next.resize(tmapData.m_nextSize);
00220 for (i=0;i<tmapData.m_nextSize;i++)
00221 {
00222 m_next[i] = tmapData.m_nextPtr[i];
00223 }
00224 m_valueArray.resize(tmapData.m_numValues);
00225 for (i=0;i<tmapData.m_numValues;i++)
00226 {
00227 m_valueArray[i].m_edgeV0V1Angle = tmapData.m_valueArrayPtr[i].m_edgeV0V1Angle;
00228 m_valueArray[i].m_edgeV1V2Angle = tmapData.m_valueArrayPtr[i].m_edgeV1V2Angle;
00229 m_valueArray[i].m_edgeV2V0Angle = tmapData.m_valueArrayPtr[i].m_edgeV2V0Angle;
00230 m_valueArray[i].m_flags = tmapData.m_valueArrayPtr[i].m_flags;
00231 }
00232
00233 m_keyArray.resize(tmapData.m_numKeys,btHashInt(0));
00234 for (i=0;i<tmapData.m_numKeys;i++)
00235 {
00236 m_keyArray[i].setUid1(tmapData.m_keyArrayPtr[i]);
00237 }
00238 }
00239
00240
00241 #endif //_BT_TRIANGLE_INFO_MAP_H