Bullet Collision Detection & Physics Library: btBvhTriangleMeshShape.cpp Source File

Bullet Collision Detection & Physics Library

btBvhTriangleMeshShape.cpp
Go to the documentation of this file.
1/*
2Bullet Continuous Collision Detection and Physics Library
3Copyright (c) 2003-2009 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//#define DISABLE_BVH
17
18#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h"
19#include "BulletCollision/CollisionShapes/btOptimizedBvh.h"
20#include "LinearMath/btSerializer.h"
21
24btBvhTriangleMeshShape::btBvhTriangleMeshShape(btStridingMeshInterface* meshInterface, bool useQuantizedAabbCompression, bool buildBvh)
25 : btTriangleMeshShape(meshInterface),
26 m_bvh(0),
27 m_triangleInfoMap(0),
28 m_useQuantizedAabbCompression(useQuantizedAabbCompression),
29 m_ownsBvh(false)
30{
31 m_shapeType = TRIANGLE_MESH_SHAPE_PROXYTYPE;
32 //construct bvh from meshInterface
33#ifndef DISABLE_BVH
34
35 if (buildBvh)
36 {
37 buildOptimizedBvh();
38 }
39
40#endif //DISABLE_BVH
41}
42
43 btBvhTriangleMeshShape::btBvhTriangleMeshShape(btStridingMeshInterface* meshInterface, bool useQuantizedAabbCompression, const btVector3& bvhAabbMin, const btVector3& bvhAabbMax, bool buildBvh)
44 : btTriangleMeshShape(meshInterface),
45 m_bvh(0),
46 m_triangleInfoMap(0),
47 m_useQuantizedAabbCompression(useQuantizedAabbCompression),
48 m_ownsBvh(false)
49{
50 m_shapeType = TRIANGLE_MESH_SHAPE_PROXYTYPE;
51 //construct bvh from meshInterface
52#ifndef DISABLE_BVH
53
54 if (buildBvh)
55 {
56 void* mem = btAlignedAlloc(sizeof(btOptimizedBvh), 16);
57 m_bvh = new (mem) btOptimizedBvh();
58
59 m_bvh->build(meshInterface, m_useQuantizedAabbCompression, bvhAabbMin, bvhAabbMax);
60 m_ownsBvh = true;
61 }
62
63#endif //DISABLE_BVH
64}
65
66 void btBvhTriangleMeshShape::partialRefitTree(const btVector3& aabbMin, const btVector3& aabbMax)
67{
68 m_bvh->refitPartial(m_meshInterface, aabbMin, aabbMax);
69
70 m_localAabbMin.setMin(aabbMin);
71 m_localAabbMax.setMax(aabbMax);
72}
73
74 void btBvhTriangleMeshShape::refitTree(const btVector3& aabbMin, const btVector3& aabbMax)
75{
76 m_bvh->refit(m_meshInterface, aabbMin, aabbMax);
77
78 recalcLocalAabb();
79}
80
81btBvhTriangleMeshShape::~btBvhTriangleMeshShape()
82{
83 if (m_ownsBvh)
84 {
85 m_bvh->~btOptimizedBvh();
86 btAlignedFree(m_bvh);
87 }
88}
89
90 void btBvhTriangleMeshShape::performRaycast(btTriangleCallback* callback, const btVector3& raySource, const btVector3& rayTarget)
91{
92 struct MyNodeOverlapCallback : public btNodeOverlapCallback
93 {
94 btStridingMeshInterface* m_meshInterface;
95 btTriangleCallback* m_callback;
96
97 MyNodeOverlapCallback(btTriangleCallback* callback, btStridingMeshInterface* meshInterface)
98 : m_meshInterface(meshInterface),
99 m_callback(callback)
100 {
101 }
102
103 virtual void processNode(int nodeSubPart, int nodeTriangleIndex)
104 {
105 btVector3 m_triangle[3];
106 const unsigned char* vertexbase;
107 int numverts;
108 PHY_ScalarType type;
109 int stride;
110 const unsigned char* indexbase;
111 int indexstride;
112 int numfaces;
113 PHY_ScalarType indicestype;
114
115 m_meshInterface->getLockedReadOnlyVertexIndexBase(
116 &vertexbase,
117 numverts,
118 type,
119 stride,
120 &indexbase,
121 indexstride,
122 numfaces,
123 indicestype,
124 nodeSubPart);
125
126 unsigned int* gfxbase = (unsigned int*)(indexbase + nodeTriangleIndex * indexstride);
127
128 const btVector3& meshScaling = m_meshInterface->getScaling();
129 for (int j = 2; j >= 0; j--)
130 {
131 int graphicsindex;
132 switch (indicestype) {
133 case PHY_INTEGER: graphicsindex = gfxbase[j]; break;
134 case PHY_SHORT: graphicsindex = ((unsigned short*)gfxbase)[j]; break;
135 case PHY_UCHAR: graphicsindex = ((unsigned char*)gfxbase)[j]; break;
136 default: btAssert(0);
137 }
138
139 if (type == PHY_FLOAT)
140 {
141 float* graphicsbase = (float*)(vertexbase + graphicsindex * stride);
142
143 m_triangle[j] = btVector3(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ());
144 }
145 else
146 {
147 double* graphicsbase = (double*)(vertexbase + graphicsindex * stride);
148
149 m_triangle[j] = btVector3(btScalar(graphicsbase[0]) * meshScaling.getX(), btScalar(graphicsbase[1]) * meshScaling.getY(), btScalar(graphicsbase[2]) * meshScaling.getZ());
150 }
151 }
152
153 /* Perform ray vs. triangle collision here */
154 m_callback->processTriangle(m_triangle, nodeSubPart, nodeTriangleIndex);
155 m_meshInterface->unLockReadOnlyVertexBase(nodeSubPart);
156 }
157 };
158
159 MyNodeOverlapCallback myNodeCallback(callback, m_meshInterface);
160
161 m_bvh->reportRayOverlappingNodex(&myNodeCallback, raySource, rayTarget);
162}
163
164 void btBvhTriangleMeshShape::performConvexcast(btTriangleCallback* callback, const btVector3& raySource, const btVector3& rayTarget, const btVector3& aabbMin, const btVector3& aabbMax)
165{
166 struct MyNodeOverlapCallback : public btNodeOverlapCallback
167 {
168 btStridingMeshInterface* m_meshInterface;
169 btTriangleCallback* m_callback;
170
171 MyNodeOverlapCallback(btTriangleCallback* callback, btStridingMeshInterface* meshInterface)
172 : m_meshInterface(meshInterface),
173 m_callback(callback)
174 {
175 }
176
177 virtual void processNode(int nodeSubPart, int nodeTriangleIndex)
178 {
179 btVector3 m_triangle[3];
180 const unsigned char* vertexbase;
181 int numverts;
182 PHY_ScalarType type;
183 int stride;
184 const unsigned char* indexbase;
185 int indexstride;
186 int numfaces;
187 PHY_ScalarType indicestype;
188
189 m_meshInterface->getLockedReadOnlyVertexIndexBase(
190 &vertexbase,
191 numverts,
192 type,
193 stride,
194 &indexbase,
195 indexstride,
196 numfaces,
197 indicestype,
198 nodeSubPart);
199
200 unsigned int* gfxbase = (unsigned int*)(indexbase + nodeTriangleIndex * indexstride);
201
202 const btVector3& meshScaling = m_meshInterface->getScaling();
203 for (int j = 2; j >= 0; j--)
204 {
205 int graphicsindex;
206 switch (indicestype) {
207 case PHY_INTEGER: graphicsindex = gfxbase[j]; break;
208 case PHY_SHORT: graphicsindex = ((unsigned short*)gfxbase)[j]; break;
209 case PHY_UCHAR: graphicsindex = ((unsigned char*)gfxbase)[j]; break;
210 default: btAssert(0);
211 }
212
213 if (type == PHY_FLOAT)
214 {
215 float* graphicsbase = (float*)(vertexbase + graphicsindex * stride);
216
217 m_triangle[j] = btVector3(graphicsbase[0] * meshScaling.getX(), graphicsbase[1] * meshScaling.getY(), graphicsbase[2] * meshScaling.getZ());
218 }
219 else
220 {
221 double* graphicsbase = (double*)(vertexbase + graphicsindex * stride);
222
223 m_triangle[j] = btVector3(btScalar(graphicsbase[0]) * meshScaling.getX(), btScalar(graphicsbase[1]) * meshScaling.getY(), btScalar(graphicsbase[2]) * meshScaling.getZ());
224 }
225 }
226
227 /* Perform ray vs. triangle collision here */
228 m_callback->processTriangle(m_triangle, nodeSubPart, nodeTriangleIndex);
229 m_meshInterface->unLockReadOnlyVertexBase(nodeSubPart);
230 }
231 };
232
233 MyNodeOverlapCallback myNodeCallback(callback, m_meshInterface);
234
235 m_bvh->reportBoxCastOverlappingNodex(&myNodeCallback, raySource, rayTarget, aabbMin, aabbMax);
236}
237
238//perform bvh tree traversal and report overlapping triangles to 'callback'
239 void btBvhTriangleMeshShape::processAllTriangles(btTriangleCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) const
240{
241#ifdef DISABLE_BVH
242 //brute force traverse all triangles
243 btTriangleMeshShape::processAllTriangles(callback, aabbMin, aabbMax);
244#else
245
246 //first get all the nodes
247
248 struct MyNodeOverlapCallback : public btNodeOverlapCallback
249 {
250 btStridingMeshInterface* m_meshInterface;
251 btTriangleCallback* m_callback;
252 btVector3 m_triangle[3];
253 int m_numOverlap;
254
255 MyNodeOverlapCallback(btTriangleCallback* callback, btStridingMeshInterface* meshInterface)
256 : m_meshInterface(meshInterface),
257 m_callback(callback),
258 m_numOverlap(0)
259 {
260 }
261
262 virtual void processNode(int nodeSubPart, int nodeTriangleIndex)
263 {
264 m_numOverlap++;
265 const unsigned char* vertexbase;
266 int numverts;
267 PHY_ScalarType type;
268 int stride;
269 const unsigned char* indexbase;
270 int indexstride;
271 int numfaces;
272 PHY_ScalarType indicestype;
273
274 m_meshInterface->getLockedReadOnlyVertexIndexBase(
275 &vertexbase,
276 numverts,
277 type,
278 stride,
279 &indexbase,
280 indexstride,
281 numfaces,
282 indicestype,
283 nodeSubPart);
284
285 unsigned int* gfxbase = (unsigned int*)(indexbase + nodeTriangleIndex * indexstride);
286 btAssert(indicestype == PHY_INTEGER || indicestype == PHY_SHORT || indicestype == PHY_UCHAR);
287
288 const btVector3& meshScaling = m_meshInterface->getScaling();
289 for (int j = 2; j >= 0; j--)
290 {
291 int graphicsindex = indicestype == PHY_SHORT ? ((unsigned short*)gfxbase)[j] : indicestype == PHY_INTEGER ? gfxbase[j] : ((unsigned char*)gfxbase)[j];
292
293#ifdef DEBUG_TRIANGLE_MESH
294 printf("%d ,", graphicsindex);
295#endif //DEBUG_TRIANGLE_MESH
296 if (type == PHY_FLOAT)
297 {
298 float* graphicsbase = (float*)(vertexbase + graphicsindex * stride);
299
300 m_triangle[j] = btVector3(
301 graphicsbase[0] * meshScaling.getX(),
302 graphicsbase[1] * meshScaling.getY(),
303 graphicsbase[2] * meshScaling.getZ());
304 }
305 else
306 {
307 double* graphicsbase = (double*)(vertexbase + graphicsindex * stride);
308
309 m_triangle[j] = btVector3(
310 btScalar(graphicsbase[0]) * meshScaling.getX(),
311 btScalar(graphicsbase[1]) * meshScaling.getY(),
312 btScalar(graphicsbase[2]) * meshScaling.getZ());
313 }
314#ifdef DEBUG_TRIANGLE_MESH
315 printf("triangle vertices:%f,%f,%f\n", triangle[j].x(), triangle[j].y(), triangle[j].z());
316#endif //DEBUG_TRIANGLE_MESH
317 }
318
319 m_callback->processTriangle(m_triangle, nodeSubPart, nodeTriangleIndex);
320 m_meshInterface->unLockReadOnlyVertexBase(nodeSubPart);
321 }
322 };
323
324 MyNodeOverlapCallback myNodeCallback(callback, m_meshInterface);
325
326 m_bvh->reportAabbOverlappingNodex(&myNodeCallback, aabbMin, aabbMax);
327
328#endif //DISABLE_BVH
329}
330
331 void btBvhTriangleMeshShape::setLocalScaling(const btVector3& scaling)
332{
333 if ((getLocalScaling() - scaling).length2() > SIMD_EPSILON)
334 {
335 btTriangleMeshShape::setLocalScaling(scaling);
336 buildOptimizedBvh();
337 }
338}
339
340 void btBvhTriangleMeshShape::buildOptimizedBvh()
341{
342 if (m_ownsBvh)
343 {
344 m_bvh->~btOptimizedBvh();
345 btAlignedFree(m_bvh);
346 }
348 void* mem = btAlignedAlloc(sizeof(btOptimizedBvh), 16);
349 m_bvh = new (mem) btOptimizedBvh();
350 //rebuild the bvh...
351 m_bvh->build(m_meshInterface, m_useQuantizedAabbCompression, m_localAabbMin, m_localAabbMax);
352 m_ownsBvh = true;
353}
354
355 void btBvhTriangleMeshShape::setOptimizedBvh(btOptimizedBvh* bvh, const btVector3& scaling)
356{
357 btAssert(!m_bvh);
358 btAssert(!m_ownsBvh);
359
360 m_bvh = bvh;
361 m_ownsBvh = false;
362 // update the scaling without rebuilding the bvh
363 if ((getLocalScaling() - scaling).length2() > SIMD_EPSILON)
364 {
365 btTriangleMeshShape::setLocalScaling(scaling);
366 }
367}
368
370 const char* btBvhTriangleMeshShape::serialize(void* dataBuffer, btSerializer* serializer) const
371{
372 btTriangleMeshShapeData* trimeshData = (btTriangleMeshShapeData*)dataBuffer;
373
374 btCollisionShape::serialize(&trimeshData->m_collisionShapeData, serializer);
375
376 m_meshInterface->serialize(&trimeshData->m_meshInterface, serializer);
377
378 trimeshData->m_collisionMargin = float(m_collisionMargin);
379
380 if (m_bvh && !(serializer->getSerializationFlags() & BT_SERIALIZE_NO_BVH))
381 {
382 void* chunk = serializer->findPointer(m_bvh);
383 if (chunk)
384 {
385#ifdef BT_USE_DOUBLE_PRECISION
386 trimeshData->m_quantizedDoubleBvh = (btQuantizedBvhData*)chunk;
387 trimeshData->m_quantizedFloatBvh = 0;
388#else
389 trimeshData->m_quantizedFloatBvh = (btQuantizedBvhData*)chunk;
390 trimeshData->m_quantizedDoubleBvh = 0;
391#endif //BT_USE_DOUBLE_PRECISION
392 }
393 else
394 {
395#ifdef BT_USE_DOUBLE_PRECISION
396 trimeshData->m_quantizedDoubleBvh = (btQuantizedBvhData*)serializer->getUniquePointer(m_bvh);
397 trimeshData->m_quantizedFloatBvh = 0;
398#else
399 trimeshData->m_quantizedFloatBvh = (btQuantizedBvhData*)serializer->getUniquePointer(m_bvh);
400 trimeshData->m_quantizedDoubleBvh = 0;
401#endif //BT_USE_DOUBLE_PRECISION
402
403 int sz = m_bvh->calculateSerializeBufferSizeNew();
404 btChunk* chunk = serializer->allocate(sz, 1);
405 const char* structType = m_bvh->serialize(chunk->m_oldPtr, serializer);
406 serializer->finalizeChunk(chunk, structType, BT_QUANTIZED_BVH_CODE, m_bvh);
407 }
408 }
409 else
410 {
411 trimeshData->m_quantizedFloatBvh = 0;
412 trimeshData->m_quantizedDoubleBvh = 0;
413 }
414
415 if (m_triangleInfoMap && !(serializer->getSerializationFlags() & BT_SERIALIZE_NO_TRIANGLEINFOMAP))
416 {
417 void* chunk = serializer->findPointer(m_triangleInfoMap);
418 if (chunk)
419 {
420 trimeshData->m_triangleInfoMap = (btTriangleInfoMapData*)chunk;
421 }
422 else
423 {
424 trimeshData->m_triangleInfoMap = (btTriangleInfoMapData*)serializer->getUniquePointer(m_triangleInfoMap);
425 int sz = m_triangleInfoMap->calculateSerializeBufferSize();
426 btChunk* chunk = serializer->allocate(sz, 1);
427 const char* structType = m_triangleInfoMap->serialize(chunk->m_oldPtr, serializer);
428 serializer->finalizeChunk(chunk, structType, BT_TRIANLGE_INFO_MAP, m_triangleInfoMap);
429 }
430 }
431 else
432 {
433 trimeshData->m_triangleInfoMap = 0;
434 }
435
436 // Fill padding with zeros to appease msan.
437 memset(trimeshData->m_pad3, 0, sizeof(trimeshData->m_pad3));
438
439 return "btTriangleMeshShapeData";
440}
441
442 void btBvhTriangleMeshShape::serializeSingleBvh(btSerializer* serializer) const
443{
444 if (m_bvh)
445 {
446 int len = m_bvh->calculateSerializeBufferSizeNew(); //make sure not to use calculateSerializeBufferSize because it is used for in-place
447 btChunk* chunk = serializer->allocate(len, 1);
448 const char* structType = m_bvh->serialize(chunk->m_oldPtr, serializer);
449 serializer->finalizeChunk(chunk, structType, BT_QUANTIZED_BVH_CODE, (void*)m_bvh);
450 }
451}
452
453 void btBvhTriangleMeshShape::serializeSingleTriangleInfoMap(btSerializer* serializer) const
454{
455 if (m_triangleInfoMap)
456 {
457 int len = m_triangleInfoMap->calculateSerializeBufferSize();
458 btChunk* chunk = serializer->allocate(len, 1);
459 const char* structType = m_triangleInfoMap->serialize(chunk->m_oldPtr, serializer);
460 serializer->finalizeChunk(chunk, structType, BT_TRIANLGE_INFO_MAP, (void*)m_triangleInfoMap);
461 }
462}
btAlignedFree
#define btAlignedFree(ptr)
Definition: btAlignedAllocator.h:47
btAlignedAlloc
#define btAlignedAlloc(size, alignment)
Definition: btAlignedAllocator.h:46
TRIANGLE_MESH_SHAPE_PROXYTYPE
@ TRIANGLE_MESH_SHAPE_PROXYTYPE
Definition: btBroadphaseProxy.h:54
btBvhTriangleMeshShape.h
PHY_ScalarType
PHY_ScalarType
PHY_ScalarType enumerates possible scalar types.
Definition: btConcaveShape.h:26
PHY_FLOAT
@ PHY_FLOAT
Definition: btConcaveShape.h:27
PHY_UCHAR
@ PHY_UCHAR
Definition: btConcaveShape.h:32
PHY_SHORT
@ PHY_SHORT
Definition: btConcaveShape.h:30
PHY_INTEGER
@ PHY_INTEGER
Definition: btConcaveShape.h:29
btOptimizedBvh.h
btQuantizedBvhData
#define btQuantizedBvhData
Definition: btQuantizedBvh.h:39
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:314
SIMD_EPSILON
#define SIMD_EPSILON
Definition: btScalar.h:543
btAssert
#define btAssert(x)
Definition: btScalar.h:153
btSerializer.h
BT_SERIALIZE_NO_TRIANGLEINFOMAP
@ BT_SERIALIZE_NO_TRIANGLEINFOMAP
Definition: btSerializer.h:60
BT_SERIALIZE_NO_BVH
@ BT_SERIALIZE_NO_BVH
Definition: btSerializer.h:59
BT_TRIANLGE_INFO_MAP
#define BT_TRIANLGE_INFO_MAP
Definition: btSerializer.h:116
BT_QUANTIZED_BVH_CODE
#define BT_QUANTIZED_BVH_CODE
Definition: btSerializer.h:115
btBvhTriangleMeshShape::serializeSingleBvh
virtual void serializeSingleBvh(btSerializer *serializer) const
Definition: btBvhTriangleMeshShape.cpp:442
btBvhTriangleMeshShape::performRaycast
void performRaycast(btTriangleCallback *callback, const btVector3 &raySource, const btVector3 &rayTarget)
Definition: btBvhTriangleMeshShape.cpp:90
btBvhTriangleMeshShape::refitTree
void refitTree(const btVector3 &aabbMin, const btVector3 &aabbMax)
Definition: btBvhTriangleMeshShape.cpp:74
btBvhTriangleMeshShape::buildOptimizedBvh
void buildOptimizedBvh()
Definition: btBvhTriangleMeshShape.cpp:340
btBvhTriangleMeshShape::~btBvhTriangleMeshShape
virtual ~btBvhTriangleMeshShape()
Definition: btBvhTriangleMeshShape.cpp:81
btBvhTriangleMeshShape::m_ownsBvh
bool m_ownsBvh
Definition: btBvhTriangleMeshShape.h:41
btBvhTriangleMeshShape::setOptimizedBvh
void setOptimizedBvh(btOptimizedBvh *bvh, const btVector3 &localScaling=btVector3(1, 1, 1))
Definition: btBvhTriangleMeshShape.cpp:355
btBvhTriangleMeshShape::processAllTriangles
virtual void processAllTriangles(btTriangleCallback *callback, const btVector3 &aabbMin, const btVector3 &aabbMax) const
Definition: btBvhTriangleMeshShape.cpp:239
btBvhTriangleMeshShape::partialRefitTree
void partialRefitTree(const btVector3 &aabbMin, const btVector3 &aabbMax)
for a fast incremental refit of parts of the tree. Note: the entire AABB of the tree will become more...
Definition: btBvhTriangleMeshShape.cpp:66
btBvhTriangleMeshShape::performConvexcast
void performConvexcast(btTriangleCallback *callback, const btVector3 &boxSource, const btVector3 &boxTarget, const btVector3 &boxMin, const btVector3 &boxMax)
Definition: btBvhTriangleMeshShape.cpp:164
btBvhTriangleMeshShape::m_triangleInfoMap
btTriangleInfoMap * m_triangleInfoMap
Definition: btBvhTriangleMeshShape.h:38
btBvhTriangleMeshShape::m_useQuantizedAabbCompression
bool m_useQuantizedAabbCompression
Definition: btBvhTriangleMeshShape.h:40
btBvhTriangleMeshShape::setLocalScaling
virtual void setLocalScaling(const btVector3 &scaling)
Definition: btBvhTriangleMeshShape.cpp:331
btBvhTriangleMeshShape::serializeSingleTriangleInfoMap
virtual void serializeSingleTriangleInfoMap(btSerializer *serializer) const
Definition: btBvhTriangleMeshShape.cpp:453
btBvhTriangleMeshShape::serialize
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
Definition: btBvhTriangleMeshShape.cpp:370
btBvhTriangleMeshShape::m_bvh
btOptimizedBvh * m_bvh
Definition: btBvhTriangleMeshShape.h:37
btBvhTriangleMeshShape::btBvhTriangleMeshShape
btBvhTriangleMeshShape(btStridingMeshInterface *meshInterface, bool useQuantizedAabbCompression, bool buildBvh=true)
Bvh Concave triangle mesh is a static-triangle mesh shape with Bounding Volume Hierarchy optimization...
Definition: btBvhTriangleMeshShape.cpp:24
btChunk
Definition: btSerializer.h:48
btChunk::m_oldPtr
void * m_oldPtr
Definition: btSerializer.h:52
btCollisionShape::m_shapeType
int m_shapeType
Definition: btCollisionShape.h:30
btCollisionShape::serialize
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
Definition: btCollisionShape.cpp:96
btConcaveShape::m_collisionMargin
btScalar m_collisionMargin
Definition: btConcaveShape.h:41
btNodeOverlapCallback
Definition: btQuantizedBvh.h:148
btOptimizedBvh
The btOptimizedBvh extends the btQuantizedBvh to create AABB tree for triangle meshes,...
Definition: btOptimizedBvh.h:28
btOptimizedBvh::~btOptimizedBvh
virtual ~btOptimizedBvh()
Definition: btOptimizedBvh.cpp:25
btOptimizedBvh::refitPartial
void refitPartial(btStridingMeshInterface *triangles, const btVector3 &aabbMin, const btVector3 &aabbMax)
Definition: btOptimizedBvh.cpp:213
btOptimizedBvh::refit
void refit(btStridingMeshInterface *triangles, const btVector3 &aabbMin, const btVector3 &aabbMax)
Definition: btOptimizedBvh.cpp:191
btOptimizedBvh::build
void build(btStridingMeshInterface *triangles, bool useQuantizedAabbCompression, const btVector3 &bvhAabbMin, const btVector3 &bvhAabbMax)
Definition: btOptimizedBvh.cpp:29
btQuantizedBvh::reportAabbOverlappingNodex
void reportAabbOverlappingNodex(btNodeOverlapCallback *nodeCallback, const btVector3 &aabbMin, const btVector3 &aabbMax) const
‍***************************************** expert/internal use only *************************
Definition: btQuantizedBvh.cpp:312
btQuantizedBvh::reportRayOverlappingNodex
void reportRayOverlappingNodex(btNodeOverlapCallback *nodeCallback, const btVector3 &raySource, const btVector3 &rayTarget) const
Definition: btQuantizedBvh.cpp:737
btQuantizedBvh::reportBoxCastOverlappingNodex
void reportBoxCastOverlappingNodex(btNodeOverlapCallback *nodeCallback, const btVector3 &raySource, const btVector3 &rayTarget, const btVector3 &aabbMin, const btVector3 &aabbMax) const
Definition: btQuantizedBvh.cpp:742
btQuantizedBvh::calculateSerializeBufferSizeNew
virtual int calculateSerializeBufferSizeNew() const
Definition: btQuantizedBvh.h:538
btQuantizedBvh::serialize
virtual bool serialize(void *o_alignedDataBuffer, unsigned i_dataBufferSize, bool i_swapEndian) const
Data buffer MUST be 16 byte aligned.
Definition: btQuantizedBvh.cpp:824
btSerializer
Definition: btSerializer.h:66
btSerializer::allocate
virtual btChunk * allocate(size_t size, int numElements)=0
btSerializer::getUniquePointer
virtual void * getUniquePointer(void *oldPtr)=0
btSerializer::getSerializationFlags
virtual int getSerializationFlags() const =0
btSerializer::finalizeChunk
virtual void finalizeChunk(btChunk *chunk, const char *structType, int chunkCode, void *oldPtr)=0
btSerializer::findPointer
virtual void * findPointer(void *oldPtr)=0
btStridingMeshInterface
The btStridingMeshInterface is the interface class for high performance generic access to triangle me...
Definition: btStridingMeshInterface.h:28
btStridingMeshInterface::getScaling
const btVector3 & getScaling() const
Definition: btStridingMeshInterface.h:80
btStridingMeshInterface::getLockedReadOnlyVertexIndexBase
virtual void getLockedReadOnlyVertexIndexBase(const unsigned char **vertexbase, int &numverts, PHY_ScalarType &type, int &stride, const unsigned char **indexbase, int &indexstride, int &numfaces, PHY_ScalarType &indicestype, int subpart=0) const =0
btStridingMeshInterface::serialize
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
Definition: btStridingMeshInterface.cpp:211
btStridingMeshInterface::unLockReadOnlyVertexBase
virtual void unLockReadOnlyVertexBase(int subpart) const =0
btTriangleCallback
The btTriangleCallback provides a callback for each overlapping triangle when calling processAllTrian...
Definition: btTriangleCallback.h:24
btTriangleCallback::processTriangle
virtual void processTriangle(btVector3 *triangle, int partId, int triangleIndex)=0
btTriangleMeshShape
The btTriangleMeshShape is an internal concave triangle mesh interface. Don't use this class directly...
Definition: btTriangleMeshShape.h:25
btTriangleMeshShape::m_localAabbMin
btVector3 m_localAabbMin
Definition: btTriangleMeshShape.h:27
btTriangleMeshShape::recalcLocalAabb
void recalcLocalAabb()
Definition: btTriangleMeshShape.cpp:56
btTriangleMeshShape::m_localAabbMax
btVector3 m_localAabbMax
Definition: btTriangleMeshShape.h:28
btTriangleMeshShape::processAllTriangles
virtual void processAllTriangles(btTriangleCallback *callback, const btVector3 &aabbMin, const btVector3 &aabbMax) const
Definition: btTriangleMeshShape.cpp:125
btTriangleMeshShape::setLocalScaling
virtual void setLocalScaling(const btVector3 &scaling)
Definition: btTriangleMeshShape.cpp:112
btTriangleMeshShape::m_meshInterface
btStridingMeshInterface * m_meshInterface
Definition: btTriangleMeshShape.h:29
btTriangleMeshShape::getLocalScaling
virtual const btVector3 & getLocalScaling() const
Definition: btTriangleMeshShape.cpp:118
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:82
btVector3::getZ
const btScalar & getZ() const
Return the z value.
Definition: btVector3.h:565
btVector3::setMax
void setMax(const btVector3 &other)
Set each element to the max of the current values and the values of another btVector3.
Definition: btVector3.h:609
btVector3::getY
const btScalar & getY() const
Return the y value.
Definition: btVector3.h:563
btVector3::setMin
void setMin(const btVector3 &other)
Set each element to the min of the current values and the values of another btVector3.
Definition: btVector3.h:626
btVector3::getX
const btScalar & getX() const
Return the x value.
Definition: btVector3.h:561
btTriangleInfoMapData
Definition: btTriangleInfoMap.h:93
btTriangleInfoMap::serialize
virtual const char * serialize(void *dataBuffer, btSerializer *serializer) const
fills the dataBuffer and returns the struct name (and 0 on failure)
Definition: btTriangleInfoMap.h:120
btTriangleInfoMap::calculateSerializeBufferSize
virtual int calculateSerializeBufferSize() const
Definition: btTriangleInfoMap.h:114
btTriangleMeshShapeData
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
Definition: btBvhTriangleMeshShape.h:121
btTriangleMeshShapeData::m_meshInterface
btStridingMeshInterfaceData m_meshInterface
Definition: btBvhTriangleMeshShape.h:124
btTriangleMeshShapeData::m_quantizedDoubleBvh
btQuantizedBvhDoubleData * m_quantizedDoubleBvh
Definition: btBvhTriangleMeshShape.h:127
btTriangleMeshShapeData::m_pad3
char m_pad3[4]
Definition: btBvhTriangleMeshShape.h:133
btTriangleMeshShapeData::m_quantizedFloatBvh
btQuantizedBvhFloatData * m_quantizedFloatBvh
Definition: btBvhTriangleMeshShape.h:126
btTriangleMeshShapeData::m_collisionShapeData
btCollisionShapeData m_collisionShapeData
Definition: btBvhTriangleMeshShape.h:122
btTriangleMeshShapeData::m_collisionMargin
float m_collisionMargin
Definition: btBvhTriangleMeshShape.h:131
btTriangleMeshShapeData::m_triangleInfoMap
btTriangleInfoMapData * m_triangleInfoMap
Definition: btBvhTriangleMeshShape.h:129