Bullet Collision Detection & Physics Library
btConvexHullShape.cpp
Go to the documentation of this file.
1 /*
2 Bullet Continuous Collision Detection and Physics Library
3 Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org
4 
5 This software is provided 'as-is', without any express or implied warranty.
6 In no event will the authors be held liable for any damages arising from the use of this software.
7 Permission is granted to anyone to use this software for any purpose,
8 including commercial applications, and to alter it and redistribute it freely,
9 subject to the following restrictions:
10 
11 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.
12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
13 3. This notice may not be removed or altered from any source distribution.
14 */
15 
16 #if defined (_WIN32) || defined (__i386__)
17 #define BT_USE_SSE_IN_API
18 #endif
19 
20 #include "btConvexHullShape.h"
22 
25 
27 {
29  m_unscaledPoints.resize(numPoints);
30 
31  unsigned char* pointsAddress = (unsigned char*)points;
32 
33  for (int i=0;i<numPoints;i++)
34  {
35  btScalar* point = (btScalar*)pointsAddress;
36  m_unscaledPoints[i] = btVector3(point[0], point[1], point[2]);
37  pointsAddress += stride;
38  }
39 
41 
42 }
43 
44 
45 
47 {
48  m_localScaling = scaling;
50 }
51 
52 void btConvexHullShape::addPoint(const btVector3& point, bool recalculateLocalAabb)
53 {
55  if (recalculateLocalAabb)
57 
58 }
59 
61 {
62  btVector3 supVec(btScalar(0.),btScalar(0.),btScalar(0.));
63  btScalar maxDot = btScalar(-BT_LARGE_FLOAT);
64 
65  // Here we take advantage of dot(a, b*c) = dot(a*b, c). Note: This is true mathematically, but not numerically.
66  if( 0 < m_unscaledPoints.size() )
67  {
68  btVector3 scaled = vec * m_localScaling;
69  int index = (int) scaled.maxDot( &m_unscaledPoints[0], m_unscaledPoints.size(), maxDot); // FIXME: may violate encapsulation of m_unscaledPoints
70  return m_unscaledPoints[index] * m_localScaling;
71  }
72 
73  return supVec;
74 }
75 
76 void btConvexHullShape::batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3* vectors,btVector3* supportVerticesOut,int numVectors) const
77 {
78  btScalar newDot;
79  //use 'w' component of supportVerticesOut?
80  {
81  for (int i=0;i<numVectors;i++)
82  {
83  supportVerticesOut[i][3] = btScalar(-BT_LARGE_FLOAT);
84  }
85  }
86 
87  for (int j=0;j<numVectors;j++)
88  {
89  btVector3 vec = vectors[j] * m_localScaling; // dot(a*b,c) = dot(a,b*c)
90  if( 0 < m_unscaledPoints.size() )
91  {
92  int i = (int) vec.maxDot( &m_unscaledPoints[0], m_unscaledPoints.size(), newDot);
93  supportVerticesOut[j] = getScaledPoint(i);
94  supportVerticesOut[j][3] = newDot;
95  }
96  else
97  supportVerticesOut[j][3] = -BT_LARGE_FLOAT;
98  }
99 
100 
101 
102 }
103 
104 
105 
107 {
109 
110  if ( getMargin()!=btScalar(0.) )
111  {
112  btVector3 vecnorm = vec;
113  if (vecnorm .length2() < (SIMD_EPSILON*SIMD_EPSILON))
114  {
115  vecnorm.setValue(btScalar(-1.),btScalar(-1.),btScalar(-1.));
116  }
117  vecnorm.normalize();
118  supVertex+= getMargin() * vecnorm;
119  }
120  return supVertex;
121 }
122 
123 
124 
125 
126 
127 
128 
129 
130 
131 //currently just for debugging (drawing), perhaps future support for algebraic continuous collision detection
132 //Please note that you can debug-draw btConvexHullShape with the Raytracer Demo
134 {
135  return m_unscaledPoints.size();
136 }
137 
139 {
140  return m_unscaledPoints.size();
141 }
142 
144 {
145 
146  int index0 = i%m_unscaledPoints.size();
147  int index1 = (i+1)%m_unscaledPoints.size();
148  pa = getScaledPoint(index0);
149  pb = getScaledPoint(index1);
150 }
151 
153 {
154  vtx = getScaledPoint(i);
155 }
156 
158 {
159  return 0;
160 }
161 
163 {
164 
165  btAssert(0);
166 }
167 
168 //not yet
170 {
171  btAssert(0);
172  return false;
173 }
174 
176 const char* btConvexHullShape::serialize(void* dataBuffer, btSerializer* serializer) const
177 {
178  //int szc = sizeof(btConvexHullShapeData);
179  btConvexHullShapeData* shapeData = (btConvexHullShapeData*) dataBuffer;
181 
182  int numElem = m_unscaledPoints.size();
183  shapeData->m_numUnscaledPoints = numElem;
184 #ifdef BT_USE_DOUBLE_PRECISION
185  shapeData->m_unscaledPointsFloatPtr = 0;
186  shapeData->m_unscaledPointsDoublePtr = numElem ? (btVector3Data*)serializer->getUniquePointer((void*)&m_unscaledPoints[0]): 0;
187 #else
188  shapeData->m_unscaledPointsFloatPtr = numElem ? (btVector3Data*)serializer->getUniquePointer((void*)&m_unscaledPoints[0]): 0;
189  shapeData->m_unscaledPointsDoublePtr = 0;
190 #endif
191 
192  if (numElem)
193  {
194  int sz = sizeof(btVector3Data);
195  // int sz2 = sizeof(btVector3DoubleData);
196  // int sz3 = sizeof(btVector3FloatData);
197  btChunk* chunk = serializer->allocate(sz,numElem);
198  btVector3Data* memPtr = (btVector3Data*)chunk->m_oldPtr;
199  for (int i=0;i<numElem;i++,memPtr++)
200  {
201  m_unscaledPoints[i].serialize(*memPtr);
202  }
203  serializer->finalizeChunk(chunk,btVector3DataName,BT_ARRAY_CODE,(void*)&m_unscaledPoints[0]);
204  }
205 
206  return "btConvexHullShapeData";
207 }
208 
209 void btConvexHullShape::project(const btTransform& trans, const btVector3& dir, btScalar& minProj, btScalar& maxProj, btVector3& witnesPtMin,btVector3& witnesPtMax) const
210 {
211 #if 1
212  minProj = FLT_MAX;
213  maxProj = -FLT_MAX;
214 
215  int numVerts = m_unscaledPoints.size();
216  for(int i=0;i<numVerts;i++)
217  {
219  btVector3 pt = trans * vtx;
220  btScalar dp = pt.dot(dir);
221  if(dp < minProj)
222  {
223  minProj = dp;
224  witnesPtMin = pt;
225  }
226  if(dp > maxProj)
227  {
228  maxProj = dp;
229  witnesPtMax=pt;
230  }
231  }
232 #else
233  btVector3 localAxis = dir*trans.getBasis();
234  witnesPtMin = trans(localGetSupportingVertex(localAxis));
235  witnesPtMax = trans(localGetSupportingVertex(-localAxis));
236 
237  minProj = witnesPtMin.dot(dir);
238  maxProj = witnesPtMax.dot(dir);
239 #endif
240 
241  if(minProj>maxProj)
242  {
243  btSwap(minProj,maxProj);
244  btSwap(witnesPtMin,witnesPtMax);
245  }
246 
247 
248 }
249 
250 
#define SIMD_EPSILON
Definition: btScalar.h:448
void push_back(const T &_Val)
#define BT_LARGE_FLOAT
Definition: btScalar.h:268
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
Definition: btVector3.h:640
virtual bool isInside(const btVector3 &pt, btScalar tolerance) const
virtual int getNumPlanes() const
virtual int getNumEdges() const
virtual btVector3 localGetSupportingVertex(const btVector3 &vec) const
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
virtual void * getUniquePointer(void *oldPtr)=0
btConvexInternalShapeData m_convexInternalShapeData
btVector3DoubleData * m_unscaledPointsDoublePtr
#define btAssert(x)
Definition: btScalar.h:101
long maxDot(const btVector3 *array, long array_count, btScalar &dotOut) const
returns index of maximum dot product between this and vectors in array[]
Definition: btVector3.h:1000
virtual void batchedUnitVectorGetSupportingVertexWithoutMargin(const btVector3 *vectors, btVector3 *supportVerticesOut, int numVectors) const
btAlignedObjectArray< btVector3 > m_unscaledPoints
#define btVector3Data
Definition: btVector3.h:29
virtual void getVertex(int i, btVector3 &vtx) const
btVector3 getScaledPoint(int i) const
btScalar dot(const btVector3 &v) const
Return the dot product.
Definition: btVector3.h:235
virtual btScalar getMargin() const
btVector3 & normalize()
Normalize this vector x^2 + y^2 + z^2 = 1.
Definition: btVector3.h:297
btConvexHullShape(const btScalar *points=0, int numPoints=0, int stride=sizeof(btVector3))
this constructor optionally takes in a pointer to points.
#define btVector3DataName
Definition: btVector3.h:30
virtual void getEdge(int i, btVector3 &pa, btVector3 &pb) const
int size() const
return the number of elements in the array
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
void btSwap(T &a, T &b)
Definition: btScalar.h:535
btMatrix3x3 & getBasis()
Return the basis matrix for the rotation.
Definition: btTransform.h:112
virtual int getNumVertices() const
btVector3FloatData * m_unscaledPointsFloatPtr
virtual void project(const btTransform &trans, const btVector3 &dir, btScalar &minProj, btScalar &maxProj, btVector3 &witnesPtMin, btVector3 &witnesPtMax) const
#define BT_ARRAY_CODE
Definition: btSerializer.h:121
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
The btPolyhedralConvexAabbCachingShape adds aabb caching to the btPolyhedralConvexShape.
virtual void finalizeChunk(btChunk *chunk, const char *structType, int chunkCode, void *oldPtr)=0
virtual void setLocalScaling(const btVector3 &scaling)
in case we receive negative scaling
void resize(int newsize, const T &fillData=T())
void addPoint(const btVector3 &point, bool recalculateLocalAabb=true)
virtual void getPlane(btVector3 &planeNormal, btVector3 &planeSupport, int i) const
void * m_oldPtr
Definition: btSerializer.h:56
virtual btChunk * allocate(size_t size, int numElements)=0
virtual btVector3 localGetSupportingVertexWithoutMargin(const btVector3 &vec) const
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:266