Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btTriangleInfoMap.h @ 9849

Last change on this file since 9849 was 8393, checked in by rgrieder, 14 years ago

Updated Bullet from v2.77 to v2.78.
(I'm not going to make a branch for that since the update from 2.74 to 2.77 hasn't been tested that much either).

You will HAVE to do a complete RECOMPILE! I tested with MSVC and MinGW and they both threw linker errors at me.

  • Property svn:eol-style set to native
File size: 8.1 KB
Line 
1/*
2Bullet Continuous Collision Detection and Physics Library
3Copyright (c) 2010 Erwin Coumans  http://bulletphysics.org
4
5This software is provided 'as-is', without any express or implied warranty.
6In no event will the authors be held liable for any damages arising from the use of this software.
7Permission is granted to anyone to use this software for any purpose,
8including commercial applications, and to alter it and redistribute it freely,
9subject to the following restrictions:
10
111. 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.
122. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
133. This notice may not be removed or altered from any source distribution.
14*/
15
16#ifndef _BT_TRIANGLE_INFO_MAP_H
17#define _BT_TRIANGLE_INFO_MAP_H
18
19
20#include "LinearMath/btHashMap.h"
21#include "LinearMath/btSerializer.h"
22
23
24///for btTriangleInfo m_flags
25#define TRI_INFO_V0V1_CONVEX 1
26#define TRI_INFO_V1V2_CONVEX 2
27#define TRI_INFO_V2V0_CONVEX 4
28
29#define TRI_INFO_V0V1_SWAP_NORMALB 8
30#define TRI_INFO_V1V2_SWAP_NORMALB 16
31#define TRI_INFO_V2V0_SWAP_NORMALB 32
32
33
34///The btTriangleInfo structure stores information to adjust collision normals to avoid collisions against internal edges
35///it can be generated using
36struct  btTriangleInfo
37{
38        btTriangleInfo()
39        {
40                m_edgeV0V1Angle = SIMD_2_PI;
41                m_edgeV1V2Angle = SIMD_2_PI;
42                m_edgeV2V0Angle = SIMD_2_PI;
43                m_flags=0;
44        }
45
46        int                     m_flags;
47
48        btScalar        m_edgeV0V1Angle;
49        btScalar        m_edgeV1V2Angle;
50        btScalar        m_edgeV2V0Angle;
51
52};
53
54typedef btHashMap<btHashInt,btTriangleInfo> btInternalTriangleInfoMap;
55
56
57///The btTriangleInfoMap stores edge angle information for some triangles. You can compute this information yourself or using btGenerateInternalEdgeInfo.
58struct  btTriangleInfoMap : public btInternalTriangleInfoMap
59{
60        btScalar        m_convexEpsilon;///used to determine if an edge or contact normal is convex, using the dot product
61        btScalar        m_planarEpsilon; ///used to determine if a triangle edge is planar with zero angle
62        btScalar        m_equalVertexThreshold; ///used to compute connectivity: if the distance between two vertices is smaller than m_equalVertexThreshold, they are considered to be 'shared'
63        btScalar        m_edgeDistanceThreshold; ///used to determine edge contacts: if the closest distance between a contact point and an edge is smaller than this distance threshold it is considered to "hit the edge"
64        btScalar        m_maxEdgeAngleThreshold; //ignore edges that connect triangles at an angle larger than this m_maxEdgeAngleThreshold
65        btScalar        m_zeroAreaThreshold; ///used to determine if a triangle is degenerate (length squared of cross product of 2 triangle edges < threshold)
66       
67       
68        btTriangleInfoMap()
69        {
70                m_convexEpsilon = 0.00f;
71                m_planarEpsilon = 0.0001f;
72                m_equalVertexThreshold = btScalar(0.0001)*btScalar(0.0001);
73                m_edgeDistanceThreshold = btScalar(0.1);
74                m_zeroAreaThreshold = btScalar(0.0001)*btScalar(0.0001);
75                m_maxEdgeAngleThreshold = SIMD_2_PI;
76        }
77        virtual ~btTriangleInfoMap() {}
78
79        virtual int     calculateSerializeBufferSize() const;
80
81        ///fills the dataBuffer and returns the struct name (and 0 on failure)
82        virtual const char*     serialize(void* dataBuffer, btSerializer* serializer) const;
83
84        void    deSerialize(struct btTriangleInfoMapData& data);
85
86};
87
88struct  btTriangleInfoData
89{
90        int                     m_flags;
91        float   m_edgeV0V1Angle;
92        float   m_edgeV1V2Angle;
93        float   m_edgeV2V0Angle;
94};
95
96struct  btTriangleInfoMapData
97{
98        int                                     *m_hashTablePtr;
99        int                                     *m_nextPtr;
100        btTriangleInfoData      *m_valueArrayPtr;
101        int                                     *m_keyArrayPtr;
102
103        float   m_convexEpsilon;
104        float   m_planarEpsilon;
105        float   m_equalVertexThreshold; 
106        float   m_edgeDistanceThreshold;
107        float   m_zeroAreaThreshold;
108
109        int             m_nextSize;
110        int             m_hashTableSize;
111        int             m_numValues;
112        int             m_numKeys;
113        char    m_padding[4];
114};
115
116SIMD_FORCE_INLINE       int     btTriangleInfoMap::calculateSerializeBufferSize() const
117{
118        return sizeof(btTriangleInfoMapData);
119}
120
121///fills the dataBuffer and returns the struct name (and 0 on failure)
122SIMD_FORCE_INLINE       const char*     btTriangleInfoMap::serialize(void* dataBuffer, btSerializer* serializer) const
123{
124        btTriangleInfoMapData* tmapData = (btTriangleInfoMapData*) dataBuffer;
125        tmapData->m_convexEpsilon = m_convexEpsilon;
126        tmapData->m_planarEpsilon = m_planarEpsilon;
127        tmapData->m_equalVertexThreshold = m_equalVertexThreshold;
128        tmapData->m_edgeDistanceThreshold = m_edgeDistanceThreshold;
129        tmapData->m_zeroAreaThreshold = m_zeroAreaThreshold;
130       
131        tmapData->m_hashTableSize = m_hashTable.size();
132
133        tmapData->m_hashTablePtr = tmapData->m_hashTableSize ? (int*)serializer->getUniquePointer((void*)&m_hashTable[0]) : 0;
134        if (tmapData->m_hashTablePtr)
135        { 
136                //serialize an int buffer
137                int sz = sizeof(int);
138                int numElem = tmapData->m_hashTableSize;
139                btChunk* chunk = serializer->allocate(sz,numElem);
140                int* memPtr = (int*)chunk->m_oldPtr;
141                for (int i=0;i<numElem;i++,memPtr++)
142                {
143                        *memPtr = m_hashTable[i];
144                }
145                serializer->finalizeChunk(chunk,"int",BT_ARRAY_CODE,(void*)&m_hashTable[0]);
146
147        }
148
149        tmapData->m_nextSize = m_next.size();
150        tmapData->m_nextPtr = tmapData->m_nextSize? (int*)serializer->getUniquePointer((void*)&m_next[0]): 0;
151        if (tmapData->m_nextPtr)
152        {
153                int sz = sizeof(int);
154                int numElem = tmapData->m_nextSize;
155                btChunk* chunk = serializer->allocate(sz,numElem);
156                int* memPtr = (int*)chunk->m_oldPtr;
157                for (int i=0;i<numElem;i++,memPtr++)
158                {
159                        *memPtr = m_next[i];
160                }
161                serializer->finalizeChunk(chunk,"int",BT_ARRAY_CODE,(void*)&m_next[0]);
162        }
163       
164        tmapData->m_numValues = m_valueArray.size();
165        tmapData->m_valueArrayPtr = tmapData->m_numValues ? (btTriangleInfoData*)serializer->getUniquePointer((void*)&m_valueArray[0]): 0;
166        if (tmapData->m_valueArrayPtr)
167        {
168                int sz = sizeof(btTriangleInfoData);
169                int numElem = tmapData->m_numValues;
170                btChunk* chunk = serializer->allocate(sz,numElem);
171                btTriangleInfoData* memPtr = (btTriangleInfoData*)chunk->m_oldPtr;
172                for (int i=0;i<numElem;i++,memPtr++)
173                {
174                        memPtr->m_edgeV0V1Angle = m_valueArray[i].m_edgeV0V1Angle;
175                        memPtr->m_edgeV1V2Angle = m_valueArray[i].m_edgeV1V2Angle;
176                        memPtr->m_edgeV2V0Angle = m_valueArray[i].m_edgeV2V0Angle;
177                        memPtr->m_flags = m_valueArray[i].m_flags;
178                }
179                serializer->finalizeChunk(chunk,"btTriangleInfoData",BT_ARRAY_CODE,(void*) &m_valueArray[0]);
180        }
181       
182        tmapData->m_numKeys = m_keyArray.size();
183        tmapData->m_keyArrayPtr = tmapData->m_numKeys ? (int*)serializer->getUniquePointer((void*)&m_keyArray[0]) : 0;
184        if (tmapData->m_keyArrayPtr)
185        {
186                int sz = sizeof(int);
187                int numElem = tmapData->m_numValues;
188                btChunk* chunk = serializer->allocate(sz,numElem);
189                int* memPtr = (int*)chunk->m_oldPtr;
190                for (int i=0;i<numElem;i++,memPtr++)
191                {
192                        *memPtr = m_keyArray[i].getUid1();
193                }
194                serializer->finalizeChunk(chunk,"int",BT_ARRAY_CODE,(void*) &m_keyArray[0]);
195
196        }
197        return "btTriangleInfoMapData";
198}
199
200
201
202///fills the dataBuffer and returns the struct name (and 0 on failure)
203SIMD_FORCE_INLINE       void    btTriangleInfoMap::deSerialize(btTriangleInfoMapData& tmapData )
204{
205
206
207        m_convexEpsilon = tmapData.m_convexEpsilon;
208        m_planarEpsilon = tmapData.m_planarEpsilon;
209        m_equalVertexThreshold = tmapData.m_equalVertexThreshold;
210        m_edgeDistanceThreshold = tmapData.m_edgeDistanceThreshold;
211        m_zeroAreaThreshold = tmapData.m_zeroAreaThreshold;
212        m_hashTable.resize(tmapData.m_hashTableSize);
213        int i =0;
214        for (i=0;i<tmapData.m_hashTableSize;i++)
215        {
216                m_hashTable[i] = tmapData.m_hashTablePtr[i];
217        }
218        m_next.resize(tmapData.m_nextSize);
219        for (i=0;i<tmapData.m_nextSize;i++)
220        {
221                m_next[i] = tmapData.m_nextPtr[i];
222        }
223        m_valueArray.resize(tmapData.m_numValues);
224        for (i=0;i<tmapData.m_numValues;i++)
225        {
226                m_valueArray[i].m_edgeV0V1Angle = tmapData.m_valueArrayPtr[i].m_edgeV0V1Angle;
227                m_valueArray[i].m_edgeV1V2Angle = tmapData.m_valueArrayPtr[i].m_edgeV1V2Angle;
228                m_valueArray[i].m_edgeV2V0Angle = tmapData.m_valueArrayPtr[i].m_edgeV2V0Angle;
229                m_valueArray[i].m_flags = tmapData.m_valueArrayPtr[i].m_flags;
230        }
231       
232        m_keyArray.resize(tmapData.m_numKeys,btHashInt(0));
233        for (i=0;i<tmapData.m_numKeys;i++)
234        {
235                m_keyArray[i].setUid1(tmapData.m_keyArrayPtr[i]);
236        }
237}
238
239
240#endif //_BT_TRIANGLE_INFO_MAP_H
Note: See TracBrowser for help on using the repository browser.