btTriangleInfoMap.h

Go to the documentation of this file.
00001 /*
00002 Bullet Continuous Collision Detection and Physics Library
00003 Copyright (c) 2010 Erwin Coumans  http://bulletphysics.org
00004 
00005 This software is provided 'as-is', without any express or implied warranty.
00006 In no event will the authors be held liable for any damages arising from the use of this software.
00007 Permission is granted to anyone to use this software for any purpose, 
00008 including commercial applications, and to alter it and redistribute it freely, 
00009 subject to the following restrictions:
00010 
00011 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
00012 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
00013 3. This notice may not be removed or altered from any source distribution.
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; //ignore edges that connect triangles at an angle larger than this 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                 //serialize an int buffer
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