Bullet Collision Detection & Physics Library
btGImpactShape.h
Go to the documentation of this file.
1 
4 /*
5 This source file is part of GIMPACT Library.
6 
7 For the latest info, see http://gimpact.sourceforge.net/
8 
9 Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
10 email: projectileman@yahoo.com
11 
12 
13 This software is provided 'as-is', without any express or implied warranty.
14 In no event will the authors be held liable for any damages arising from the use of this software.
15 Permission is granted to anyone to use this software for any purpose,
16 including commercial applications, and to alter it and redistribute it freely,
17 subject to the following restrictions:
18 
19 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.
20 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
21 3. This notice may not be removed or altered from any source distribution.
22 */
23 
24 #ifndef GIMPACT_SHAPE_H
25 #define GIMPACT_SHAPE_H
26 
34 #include "LinearMath/btVector3.h"
35 #include "LinearMath/btTransform.h"
36 #include "LinearMath/btMatrix3x3.h"
38 
39 #include "btGImpactQuantizedBvh.h" // box tree class
40 
43 
45 {
49 };
50 
53 {
54 public:
56  {
57  m_numVertices = 4;
58  }
59 
61  const btVector3& v0, const btVector3& v1,
62  const btVector3& v2, const btVector3& v3)
63  {
64  m_vertices[0] = v0;
65  m_vertices[1] = v1;
66  m_vertices[2] = v2;
67  m_vertices[3] = v3;
69  }
70 };
71 
74 {
75 protected:
79  btGImpactBoxSet m_box_set; // optionally boxset
80 
83  virtual void calcLocalAABB()
84  {
86  if (m_box_set.getNodeCount() == 0)
87  {
89  }
90  else
91  {
92  m_box_set.update();
93  }
95 
97  }
98 
99 public:
101  {
104  m_needs_update = true;
105  localScaling.setValue(1.f, 1.f, 1.f);
106  }
107 
109 
116  {
117  if (!m_needs_update) return;
118  calcLocalAABB();
119  m_needs_update = false;
120  }
121 
123 
126  void getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const
127  {
128  btAABB transformedbox = m_localAABB;
129  transformedbox.appy_transform(t);
130  aabbMin = transformedbox.m_min;
131  aabbMax = transformedbox.m_max;
132  }
133 
135  virtual void postUpdate()
136  {
137  m_needs_update = true;
138  }
139 
142  {
143  return m_localAABB;
144  }
145 
146  virtual int getShapeType() const
147  {
149  }
150 
154  virtual void setLocalScaling(const btVector3& scaling)
155  {
156  localScaling = scaling;
157  postUpdate();
158  }
159 
160  virtual const btVector3& getLocalScaling() const
161  {
162  return localScaling;
163  }
164 
165  virtual void setMargin(btScalar margin)
166  {
167  m_collisionMargin = margin;
168  int i = getNumChildShapes();
169  while (i--)
170  {
171  btCollisionShape* child = getChildShape(i);
172  child->setMargin(margin);
173  }
174 
175  m_needs_update = true;
176  }
177 
180 
182  virtual eGIMPACT_SHAPE_TYPE getGImpactShapeType() const = 0;
183 
186  {
187  return &m_box_set;
188  }
189 
192  {
193  if (m_box_set.getNodeCount() == 0) return false;
194  return true;
195  }
196 
198  virtual const btPrimitiveManagerBase* getPrimitiveManager() const = 0;
199 
201  virtual int getNumChildShapes() const = 0;
202 
204  virtual bool childrenHasTransform() const = 0;
205 
207  virtual bool needsRetrieveTriangles() const = 0;
208 
210  virtual bool needsRetrieveTetrahedrons() const = 0;
211 
212  virtual void getBulletTriangle(int prim_index, btTriangleShapeEx& triangle) const = 0;
213 
214  virtual void getBulletTetrahedron(int prim_index, btTetrahedronShapeEx& tetrahedron) const = 0;
215 
217  virtual void lockChildShapes() const
218  {
219  }
220 
221  virtual void unlockChildShapes() const
222  {
223  }
224 
227  {
228  getPrimitiveManager()->get_primitive_triangle(index, triangle);
229  }
230 
232 
234  virtual void getChildAabb(int child_index, const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const
235  {
236  btAABB child_aabb;
237  getPrimitiveManager()->get_primitive_box(child_index, child_aabb);
238  child_aabb.appy_transform(t);
239  aabbMin = child_aabb.m_min;
240  aabbMax = child_aabb.m_max;
241  }
242 
244  virtual btCollisionShape* getChildShape(int index) = 0;
245 
247  virtual const btCollisionShape* getChildShape(int index) const = 0;
248 
250  virtual btTransform getChildTransform(int index) const = 0;
251 
253 
256  virtual void setChildTransform(int index, const btTransform& transform) = 0;
257 
259 
261  virtual void rayTest(const btVector3& rayFrom, const btVector3& rayTo, btCollisionWorld::RayResultCallback& resultCallback) const
262  {
263  (void)rayFrom;
264  (void)rayTo;
265  (void)resultCallback;
266  }
267 
269 
272  virtual void processAllTriangles(btTriangleCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) const
273  {
274  (void)callback;
275  (void)aabbMin;
276  (void)aabbMax;
277  }
278 
280 
283  virtual void processAllTrianglesRay(btTriangleCallback* /*callback*/, const btVector3& /*rayFrom*/, const btVector3& /*rayTo*/) const
284  {
285  }
286 
288 };
289 
291 
295 {
296 public:
299  {
300  public:
303 
306  {
307  m_compoundShape = compound.m_compoundShape;
308  }
309 
311  {
312  m_compoundShape = compoundShape;
313  }
314 
316  {
317  m_compoundShape = NULL;
318  }
319 
320  virtual bool is_trimesh() const
321  {
322  return false;
323  }
324 
325  virtual int get_primitive_count() const
326  {
327  return (int)m_compoundShape->getNumChildShapes();
328  }
329 
330  virtual void get_primitive_box(int prim_index, btAABB& primbox) const
331  {
332  btTransform prim_trans;
334  {
335  prim_trans = m_compoundShape->getChildTransform(prim_index);
336  }
337  else
338  {
339  prim_trans.setIdentity();
340  }
341  const btCollisionShape* shape = m_compoundShape->getChildShape(prim_index);
342  shape->getAabb(prim_trans, primbox.m_min, primbox.m_max);
343  }
344 
345  virtual void get_primitive_triangle(int prim_index, btPrimitiveTriangle& triangle) const
346  {
347  btAssert(0);
348  (void)prim_index;
349  (void)triangle;
350  }
351  };
352 
353 protected:
357 
358 public:
359  btGImpactCompoundShape(bool children_has_transform = true)
360  {
361  (void)children_has_transform;
364  }
365 
367  {
368  }
369 
371  virtual bool childrenHasTransform() const
372  {
373  if (m_childTransforms.size() == 0) return false;
374  return true;
375  }
376 
379  {
380  return &m_primitive_manager;
381  }
382 
385  {
386  return &m_primitive_manager;
387  }
388 
390  virtual int getNumChildShapes() const
391  {
392  return m_childShapes.size();
393  }
394 
396  void addChildShape(const btTransform& localTransform, btCollisionShape* shape)
397  {
398  btAssert(shape->isConvex());
399  m_childTransforms.push_back(localTransform);
400  m_childShapes.push_back(shape);
401  }
402 
405  {
406  btAssert(shape->isConvex());
407  m_childShapes.push_back(shape);
408  }
409 
411  virtual btCollisionShape* getChildShape(int index)
412  {
413  return m_childShapes[index];
414  }
415 
417  virtual const btCollisionShape* getChildShape(int index) const
418  {
419  return m_childShapes[index];
420  }
421 
423 
425  virtual void getChildAabb(int child_index, const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const
426  {
427  if (childrenHasTransform())
428  {
429  m_childShapes[child_index]->getAabb(t * m_childTransforms[child_index], aabbMin, aabbMax);
430  }
431  else
432  {
433  m_childShapes[child_index]->getAabb(t, aabbMin, aabbMax);
434  }
435  }
436 
438  virtual btTransform getChildTransform(int index) const
439  {
441  return m_childTransforms[index];
442  }
443 
445 
448  virtual void setChildTransform(int index, const btTransform& transform)
449  {
451  m_childTransforms[index] = transform;
452  postUpdate();
453  }
454 
456  virtual bool needsRetrieveTriangles() const
457  {
458  return false;
459  }
460 
462  virtual bool needsRetrieveTetrahedrons() const
463  {
464  return false;
465  }
466 
467  virtual void getBulletTriangle(int prim_index, btTriangleShapeEx& triangle) const
468  {
469  (void)prim_index;
470  (void)triangle;
471  btAssert(0);
472  }
473 
474  virtual void getBulletTetrahedron(int prim_index, btTetrahedronShapeEx& tetrahedron) const
475  {
476  (void)prim_index;
477  (void)tetrahedron;
478  btAssert(0);
479  }
480 
482  virtual void calculateLocalInertia(btScalar mass, btVector3& inertia) const;
483 
484  virtual const char* getName() const
485  {
486  return "GImpactCompound";
487  }
488 
490  {
492  }
493 };
494 
496 
503 {
504 public:
506 
510  {
511  public:
515  int m_part;
517  const unsigned char* vertexbase;
518  int numverts;
520  int stride;
521  const unsigned char* indexbase;
523  int numfaces;
525 
527  {
528  m_meshInterface = NULL;
529  m_part = 0;
530  m_margin = 0.01f;
531  m_scale = btVector3(1.f, 1.f, 1.f);
532  m_lock_count = 0;
533  vertexbase = 0;
534  numverts = 0;
535  stride = 0;
536  indexbase = 0;
537  indexstride = 0;
538  numfaces = 0;
539  }
540 
543  {
545  m_part = manager.m_part;
546  m_margin = manager.m_margin;
547  m_scale = manager.m_scale;
548  m_lock_count = 0;
549  vertexbase = 0;
550  numverts = 0;
551  stride = 0;
552  indexbase = 0;
553  indexstride = 0;
554  numfaces = 0;
555  }
556 
558  btStridingMeshInterface* meshInterface, int part)
559  {
560  m_meshInterface = meshInterface;
561  m_part = part;
563  m_margin = 0.1f;
564  m_lock_count = 0;
565  vertexbase = 0;
566  numverts = 0;
567  stride = 0;
568  indexbase = 0;
569  indexstride = 0;
570  numfaces = 0;
571  }
572 
574 
575  void lock()
576  {
577  if (m_lock_count > 0)
578  {
579  m_lock_count++;
580  return;
581  }
585 
586  m_lock_count = 1;
587  }
588 
589  void unlock()
590  {
591  if (m_lock_count == 0) return;
592  if (m_lock_count > 1)
593  {
594  --m_lock_count;
595  return;
596  }
598  vertexbase = NULL;
599  m_lock_count = 0;
600  }
601 
602  virtual bool is_trimesh() const
603  {
604  return true;
605  }
606 
607  virtual int get_primitive_count() const
608  {
609  return (int)numfaces;
610  }
611 
613  {
614  return (int)numverts;
615  }
616 
617  SIMD_FORCE_INLINE void get_indices(int face_index, unsigned int& i0, unsigned int& i1, unsigned int& i2) const
618  {
619  if (indicestype == PHY_SHORT)
620  {
621  unsigned short* s_indices = (unsigned short*)(indexbase + face_index * indexstride);
622  i0 = s_indices[0];
623  i1 = s_indices[1];
624  i2 = s_indices[2];
625  }
626  else
627  {
628  unsigned int* i_indices = (unsigned int*)(indexbase + face_index * indexstride);
629  i0 = i_indices[0];
630  i1 = i_indices[1];
631  i2 = i_indices[2];
632  }
633  }
634 
635  SIMD_FORCE_INLINE void get_vertex(unsigned int vertex_index, btVector3& vertex) const
636  {
637  if (type == PHY_DOUBLE)
638  {
639  double* dvertices = (double*)(vertexbase + vertex_index * stride);
640  vertex[0] = btScalar(dvertices[0] * m_scale[0]);
641  vertex[1] = btScalar(dvertices[1] * m_scale[1]);
642  vertex[2] = btScalar(dvertices[2] * m_scale[2]);
643  }
644  else
645  {
646  float* svertices = (float*)(vertexbase + vertex_index * stride);
647  vertex[0] = svertices[0] * m_scale[0];
648  vertex[1] = svertices[1] * m_scale[1];
649  vertex[2] = svertices[2] * m_scale[2];
650  }
651  }
652 
653  virtual void get_primitive_box(int prim_index, btAABB& primbox) const
654  {
655  btPrimitiveTriangle triangle;
656  get_primitive_triangle(prim_index, triangle);
658  triangle.m_vertices[0],
659  triangle.m_vertices[1], triangle.m_vertices[2], triangle.m_margin);
660  }
661 
662  virtual void get_primitive_triangle(int prim_index, btPrimitiveTriangle& triangle) const
663  {
664  unsigned int indices[3];
665  get_indices(prim_index, indices[0], indices[1], indices[2]);
666  get_vertex(indices[0], triangle.m_vertices[0]);
667  get_vertex(indices[1], triangle.m_vertices[1]);
668  get_vertex(indices[2], triangle.m_vertices[2]);
669  triangle.m_margin = m_margin;
670  }
671 
672  SIMD_FORCE_INLINE void get_bullet_triangle(int prim_index, btTriangleShapeEx& triangle) const
673  {
674  unsigned int indices[3];
675  get_indices(prim_index, indices[0], indices[1], indices[2]);
676  get_vertex(indices[0], triangle.m_vertices1[0]);
677  get_vertex(indices[1], triangle.m_vertices1[1]);
678  get_vertex(indices[2], triangle.m_vertices1[2]);
679  triangle.setMargin(m_margin);
680  }
681  };
682 
683 protected:
685 
686 public:
688  {
690  }
691 
692  btGImpactMeshShapePart(btStridingMeshInterface* meshInterface, int part);
693  virtual ~btGImpactMeshShapePart();
694 
696  virtual bool childrenHasTransform() const
697  {
698  return false;
699  }
700 
702  virtual void lockChildShapes() const;
703  virtual void unlockChildShapes() const;
704 
706  virtual int getNumChildShapes() const
707  {
709  }
710 
712  virtual btCollisionShape* getChildShape(int index)
713  {
714  (void)index;
715  btAssert(0);
716  return NULL;
717  }
718 
720  virtual const btCollisionShape* getChildShape(int index) const
721  {
722  (void)index;
723  btAssert(0);
724  return NULL;
725  }
726 
728  virtual btTransform getChildTransform(int index) const
729  {
730  (void)index;
731  btAssert(0);
732  return btTransform();
733  }
734 
736 
739  virtual void setChildTransform(int index, const btTransform& transform)
740  {
741  (void)index;
742  (void)transform;
743  btAssert(0);
744  }
745 
748  {
749  return &m_primitive_manager;
750  }
751 
753  {
754  return &m_primitive_manager;
755  }
756 
757  virtual void calculateLocalInertia(btScalar mass, btVector3& inertia) const;
758 
759  virtual const char* getName() const
760  {
761  return "GImpactMeshShapePart";
762  }
763 
765  {
767  }
768 
770  virtual bool needsRetrieveTriangles() const
771  {
772  return true;
773  }
774 
776  virtual bool needsRetrieveTetrahedrons() const
777  {
778  return false;
779  }
780 
781  virtual void getBulletTriangle(int prim_index, btTriangleShapeEx& triangle) const
782  {
783  m_primitive_manager.get_bullet_triangle(prim_index, triangle);
784  }
785 
786  virtual void getBulletTetrahedron(int prim_index, btTetrahedronShapeEx& tetrahedron) const
787  {
788  (void)prim_index;
789  (void)tetrahedron;
790  btAssert(0);
791  }
792 
794  {
796  }
797 
798  SIMD_FORCE_INLINE void getVertex(int vertex_index, btVector3& vertex) const
799  {
800  m_primitive_manager.get_vertex(vertex_index, vertex);
801  }
802 
804  {
805  m_primitive_manager.m_margin = margin;
806  postUpdate();
807  }
808 
810  {
812  }
813 
814  virtual void setLocalScaling(const btVector3& scaling)
815  {
816  m_primitive_manager.m_scale = scaling;
817  postUpdate();
818  }
819 
820  virtual const btVector3& getLocalScaling() const
821  {
823  }
824 
826  {
827  return (int)m_primitive_manager.m_part;
828  }
829 
830  virtual void processAllTriangles(btTriangleCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) const;
831  virtual void processAllTrianglesRay(btTriangleCallback* callback, const btVector3& rayFrom, const btVector3& rayTo) const;
832 };
833 
835 
843 {
845 
846 protected:
849  {
850  for (int i = 0; i < meshInterface->getNumSubParts(); ++i)
851  {
852  btGImpactMeshShapePart* newpart = new btGImpactMeshShapePart(meshInterface, i);
853  m_mesh_parts.push_back(newpart);
854  }
855  }
856 
858  virtual void calcLocalAABB()
859  {
861  int i = m_mesh_parts.size();
862  while (i--)
863  {
864  m_mesh_parts[i]->updateBound();
866  }
867  }
868 
869 public:
871  {
872  m_meshInterface = meshInterface;
873  buildMeshParts(meshInterface);
874  }
875 
877  {
878  int i = m_mesh_parts.size();
879  while (i--)
880  {
882  delete part;
883  }
885  }
886 
888  {
889  return m_meshInterface;
890  }
891 
893  {
894  return m_meshInterface;
895  }
896 
897  int getMeshPartCount() const
898  {
899  return m_mesh_parts.size();
900  }
901 
903  {
904  return m_mesh_parts[index];
905  }
906 
907  const btGImpactMeshShapePart* getMeshPart(int index) const
908  {
909  return m_mesh_parts[index];
910  }
911 
912  virtual void setLocalScaling(const btVector3& scaling)
913  {
914  localScaling = scaling;
915 
916  int i = m_mesh_parts.size();
917  while (i--)
918  {
920  part->setLocalScaling(scaling);
921  }
922 
923  m_needs_update = true;
924  }
925 
926  virtual void setMargin(btScalar margin)
927  {
928  m_collisionMargin = margin;
929 
930  int i = m_mesh_parts.size();
931  while (i--)
932  {
934  part->setMargin(margin);
935  }
936 
937  m_needs_update = true;
938  }
939 
941  virtual void postUpdate()
942  {
943  int i = m_mesh_parts.size();
944  while (i--)
945  {
947  part->postUpdate();
948  }
949 
950  m_needs_update = true;
951  }
952 
953  virtual void calculateLocalInertia(btScalar mass, btVector3& inertia) const;
954 
957  {
958  btAssert(0);
959  return NULL;
960  }
961 
963  virtual int getNumChildShapes() const
964  {
965  btAssert(0);
966  return 0;
967  }
968 
970  virtual bool childrenHasTransform() const
971  {
972  btAssert(0);
973  return false;
974  }
975 
977  virtual bool needsRetrieveTriangles() const
978  {
979  btAssert(0);
980  return false;
981  }
982 
984  virtual bool needsRetrieveTetrahedrons() const
985  {
986  btAssert(0);
987  return false;
988  }
989 
990  virtual void getBulletTriangle(int prim_index, btTriangleShapeEx& triangle) const
991  {
992  (void)prim_index;
993  (void)triangle;
994  btAssert(0);
995  }
996 
997  virtual void getBulletTetrahedron(int prim_index, btTetrahedronShapeEx& tetrahedron) const
998  {
999  (void)prim_index;
1000  (void)tetrahedron;
1001  btAssert(0);
1002  }
1003 
1005  virtual void lockChildShapes() const
1006  {
1007  btAssert(0);
1008  }
1009 
1010  virtual void unlockChildShapes() const
1011  {
1012  btAssert(0);
1013  }
1014 
1016 
1018  virtual void getChildAabb(int child_index, const btTransform& t, btVector3& aabbMin, btVector3& aabbMax) const
1019  {
1020  (void)child_index;
1021  (void)t;
1022  (void)aabbMin;
1023  (void)aabbMax;
1024  btAssert(0);
1025  }
1026 
1028  virtual btCollisionShape* getChildShape(int index)
1029  {
1030  (void)index;
1031  btAssert(0);
1032  return NULL;
1033  }
1034 
1036  virtual const btCollisionShape* getChildShape(int index) const
1037  {
1038  (void)index;
1039  btAssert(0);
1040  return NULL;
1041  }
1042 
1044  virtual btTransform getChildTransform(int index) const
1045  {
1046  (void)index;
1047  btAssert(0);
1048  return btTransform();
1049  }
1050 
1052 
1055  virtual void setChildTransform(int index, const btTransform& transform)
1056  {
1057  (void)index;
1058  (void)transform;
1059  btAssert(0);
1060  }
1061 
1063  {
1065  }
1066 
1067  virtual const char* getName() const
1068  {
1069  return "GImpactMesh";
1070  }
1071 
1072  virtual void rayTest(const btVector3& rayFrom, const btVector3& rayTo, btCollisionWorld::RayResultCallback& resultCallback) const;
1073 
1075 
1078  virtual void processAllTriangles(btTriangleCallback* callback, const btVector3& aabbMin, const btVector3& aabbMax) const;
1079 
1080  virtual void processAllTrianglesRay(btTriangleCallback* callback, const btVector3& rayFrom, const btVector3& rayTo) const;
1081 
1082  virtual int calculateSerializeBufferSize() const;
1083 
1085  virtual const char* serialize(void* dataBuffer, btSerializer* serializer) const;
1086 };
1087 
1090 {
1092 
1094 
1096 
1098 
1100 };
1101 
1103 {
1104  return sizeof(btGImpactMeshShapeData);
1105 }
1106 
1107 #endif //GIMPACT_MESH_SHAPE_H
int getMeshPartCount() const
virtual const btVector3 & getLocalScaling() const
virtual bool childrenHasTransform() const =0
if true, then its children must get transforms.
virtual btTransform getChildTransform(int index) const
Gets the children transform.
void push_back(const T &_Val)
virtual const char * getName() const
virtual bool needsRetrieveTetrahedrons() const =0
Determines if this shape has tetrahedrons.
virtual ~btGImpactMeshShape()
Helper class for colliding Bullet Triangle Shapes.
virtual eGIMPACT_SHAPE_TYPE getGImpactShapeType() const
Subshape member functions.
void setValue(const btScalar &_x, const btScalar &_y, const btScalar &_z)
Definition: btVector3.h:640
virtual void setMargin(btScalar margin)
virtual void postUpdate()
Tells to this object that is needed to refit all the meshes.
virtual btTransform getChildTransform(int index) const
Gets the children transform.
void setVertices(const btVector3 &v0, const btVector3 &v1, const btVector3 &v2, const btVector3 &v3)
virtual void lockChildShapes() const
call when reading child shapes
virtual bool childrenHasTransform() const
if true, then its children must get transforms.
bool isConvex() const
virtual void setLocalScaling(const btVector3 &scaling)
virtual void processAllTriangles(btTriangleCallback *callback, const btVector3 &aabbMin, const btVector3 &aabbMax) const
Function for retrieve triangles.
virtual bool needsRetrieveTetrahedrons() const
Determines if this shape has tetrahedrons.
eGIMPACT_SHAPE_TYPE
virtual bool needsRetrieveTriangles() const =0
Determines if this shape has triangles.
btVector3 m_max
const btAABB & getLocalBox()
Obtains the local box, which is the global calculated box of the total of subshapes.
virtual bool needsRetrieveTriangles() const
Determines if this shape has triangles.
virtual int getNumChildShapes() const
Gets the number of children.
virtual bool needsRetrieveTetrahedrons() const
Determines if this shape has tetrahedrons.
btScalar getMargin() const
TrimeshPrimitiveManager(btStridingMeshInterface *meshInterface, int part)
virtual void setLocalScaling(const btVector3 &scaling)
void setMargin(btScalar margin)
CompoundPrimitiveManager(const CompoundPrimitiveManager &compound)
void get_indices(int face_index, unsigned int &i0, unsigned int &i1, unsigned int &i2) const
void setIdentity()
Set this transformation to the identity.
Definition: btTransform.h:166
virtual void processAllTrianglesRay(btTriangleCallback *callback, const btVector3 &rayFrom, const btVector3 &rayTo) const
Function for retrieve triangles.
void addChildShape(const btTransform &localTransform, btCollisionShape *shape)
Use this method for adding children. Only Convex shapes are allowed.
#define btAssert(x)
Definition: btScalar.h:133
virtual void calcLocalAABB()
use this function for perfofm refit in bounding boxes use this function for perfofm refit in bounding...
btScalar m_collisionMargin
virtual bool childrenHasTransform() const
if true, then its children must get transforms.
virtual void rayTest(const btVector3 &rayFrom, const btVector3 &rayTo, btCollisionWorld::RayResultCallback &resultCallback) const
virtual method for ray collision
The btCollisionShape class provides an interface for collision shapes that can be shared among btColl...
RayResultCallback is used to report new raycast results.
virtual const btVector3 & getLocalScaling() const
virtual void unlockChildShapes() const
#define SIMD_FORCE_INLINE
Definition: btScalar.h:83
CompoundPrimitiveManager m_primitive_manager
void addChildShape(btCollisionShape *shape)
Use this method for adding children. Only Convex shapes are allowed.
virtual void lockChildShapes() const
call when reading child shapes
void get_bullet_triangle(int prim_index, btTriangleShapeEx &triangle) const
virtual void processAllTriangles(btTriangleCallback *callback, const btVector3 &aabbMin, const btVector3 &aabbMax) const
Function for retrieve triangles.
virtual int getNumChildShapes() const
Gets the number of children.
virtual bool is_trimesh() const
determines if this manager consist on only triangles, which special case will be optimized ...
const btGImpactBoxSet * getBoxSet() const
gets boxset
virtual bool is_trimesh() const
determines if this manager consist on only triangles, which special case will be optimized ...
btVector3 m_min
void buildMeshParts(btStridingMeshInterface *meshInterface)
void merge(const btAABB &box)
Merges a Box.
This class manages a mesh supplied by the btStridingMeshInterface interface.
Used for GIMPACT Trimesh integration.
virtual void getChildAabb(int child_index, const btTransform &t, btVector3 &aabbMin, btVector3 &aabbMax) const
Retrieves the bound from a child.
virtual void unlockChildShapes() const
btGImpactBoxSet m_box_set
Prototype Base class for primitive classification.
Definition: btGImpactBvh.h:149
virtual void getAabb(const btTransform &t, btVector3 &aabbMin, btVector3 &aabbMax) const =0
getAabb returns the axis aligned bounding box in the coordinate frame of the given transform t...
CompoundPrimitiveManager(btGImpactCompoundShape *compoundShape)
virtual eGIMPACT_SHAPE_TYPE getGImpactShapeType() const
Subshape member functions.
void clear()
clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations.
virtual void getBulletTetrahedron(int prim_index, btTetrahedronShapeEx &tetrahedron) const =0
virtual void getBulletTriangle(int prim_index, btTriangleShapeEx &triangle) const
btGImpactCompoundShape(bool children_has_transform=true)
void getAabb(const btTransform &t, btVector3 &aabbMin, btVector3 &aabbMax) const
If the Bounding box is not updated, then this class attemps to calculate it.
void getVertex(int vertex_index, btVector3 &vertex) const
btGImpactMeshShapePart * getMeshPart(int index)
virtual void processAllTrianglesRay(btTriangleCallback *callback, const btVector3 &rayFrom, const btVector3 &rayTo) const
Function for retrieve triangles.
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
virtual const btPrimitiveManagerBase * getPrimitiveManager() const
Obtains the primitive manager.
btStridingMeshInterface * getMeshInterface()
TrimeshPrimitiveManager * getTrimeshPrimitiveManager()
virtual void getChildAabb(int child_index, const btTransform &t, btVector3 &aabbMin, btVector3 &aabbMax) const
Retrieves the bound from a child.
virtual void setMargin(btScalar margin)
btAlignedObjectArray< btTransform > m_childTransforms
Base class for gimpact shapes.
This class manages a sub part of a mesh supplied by the btStridingMeshInterface interface.
virtual void getBulletTetrahedron(int prim_index, btTetrahedronShapeEx &tetrahedron) const
virtual void getBulletTetrahedron(int prim_index, btTetrahedronShapeEx &tetrahedron) const
virtual void postUpdate()
Tells to this object that is needed to refit the box set.
virtual const btPrimitiveManagerBase * getPrimitiveManager() const
Obtains the primitive manager.
The btTriangleCallback provides a callback for each overlapping triangle when calling processAllTrian...
The btBU_Simplex1to4 implements tetrahedron, triangle, line, vertex collision shapes. In most cases it is better to use btConvexHullShape instead.
void update()
node manager prototype functions
btStridingMeshInterfaceData m_meshInterface
TrimeshPrimitiveManager m_primitive_manager
virtual eGIMPACT_SHAPE_TYPE getGImpactShapeType() const =0
Subshape member functions.
void calc_from_triangle_margin(const CLASS_POINT &V1, const CLASS_POINT &V2, const CLASS_POINT &V3, btScalar margin)
virtual const char * getName() const
virtual void setChildTransform(int index, const btTransform &transform)
Sets the children transform.
virtual void get_primitive_box(int prim_index, btAABB &primbox) const
virtual bool needsRetrieveTriangles() const
Determines if this shape has triangles.
void setPrimitiveManager(btPrimitiveManagerBase *primitive_manager)
virtual void get_primitive_box(int prim_index, btAABB &primbox) const =0
Axis aligned box.
int getNodeCount() const
node count
virtual void setMargin(btScalar margin)=0
Helper class for tetrahedrons.
virtual btCollisionShape * getChildShape(int index)=0
Gets the children.
virtual void get_primitive_box(int prim_index, btAABB &primbox) const
TrimeshPrimitiveManager(const TrimeshPrimitiveManager &manager)
void appy_transform(const btTransform &trans)
Apply a transform to an AABB.
virtual bool childrenHasTransform() const
if true, then its children must get transforms.
virtual void get_primitive_triangle(int prim_index, btPrimitiveTriangle &triangle) const
retrieves only the points of the triangle, and the collision margin
virtual void calculateLocalInertia(btScalar mass, btVector3 &inertia) const
virtual int getNumChildShapes() const
Gets the number of children.
virtual void getBulletTriangle(int prim_index, btTriangleShapeEx &triangle) const =0
virtual void getChildAabb(int child_index, const btTransform &t, btVector3 &aabbMin, btVector3 &aabbMax) const
Retrieves the bound from a child.
virtual void rayTest(const btVector3 &rayFrom, const btVector3 &rayTo, btCollisionWorld::RayResultCallback &resultCallback) const
virtual method for ray collision
virtual void get_primitive_triangle(int prim_index, btPrimitiveTriangle &triangle) const
retrieves only the points of the triangle, and the collision margin
CompoundPrimitiveManager * getCompoundPrimitiveManager()
Obtains the compopund primitive manager.
btCollisionShapeData m_collisionShapeData
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:80
virtual int getNumSubParts() const =0
getNumSubParts returns the number of seperate subparts each subpart has a continuous array of vertice...
virtual void getBulletTriangle(int prim_index, btTriangleShapeEx &triangle) const
virtual void calcLocalAABB()
use this function for perfofm refit in bounding boxes
virtual void get_primitive_triangle(int prim_index, btPrimitiveTriangle &triangle) const =0
retrieves only the points of the triangle, and the collision margin
int size() const
return the number of elements in the array
virtual const btPrimitiveManagerBase * getPrimitiveManager() const =0
Obtains the primitive manager.
virtual btCollisionShape * getChildShape(int index)
Gets the children.
virtual btTransform getChildTransform(int index) const =0
Gets the children transform.
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:28
virtual const char * getName() const
The btStridingMeshInterface is the interface class for high performance generic access to triangle me...
virtual void getBulletTetrahedron(int prim_index, btTetrahedronShapeEx &tetrahedron) const
virtual void setLocalScaling(const btVector3 &scaling)
virtual btTransform getChildTransform(int index) const
Gets the children transform.
virtual int getShapeType() const
The btConcaveShape class provides an interface for non-moving (static) concave shapes.
virtual int getNumChildShapes() const =0
Gets the number of children.
const btVector3 & getScaling() const
virtual btCollisionShape * getChildShape(int index)
Gets the children.
virtual const btCollisionShape * getChildShape(int index) const
Gets the child.
virtual void getBulletTriangle(int prim_index, btTriangleShapeEx &triangle) const
virtual void setChildTransform(int index, const btTransform &transform)
Sets the children transform.
void get_vertex(unsigned int vertex_index, btVector3 &vertex) const
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
void getPrimitiveTriangle(int index, btPrimitiveTriangle &triangle) const
if this trimesh
void invalidate()
bool hasBoxSet() const
Determines if this class has a hierarchy structure for sorting its primitives.
virtual eGIMPACT_SHAPE_TYPE getGImpactShapeType() const
Subshape member functions.
virtual const btCollisionShape * getChildShape(int index) const
Gets the children.
btStridingMeshInterface * m_meshInterface
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
virtual void processAllTrianglesRay(btTriangleCallback *, const btVector3 &, const btVector3 &) const
Function for retrieve triangles.
virtual int calculateSerializeBufferSize() const
const btGImpactMeshShapePart * getMeshPart(int index) const
virtual btCollisionShape * getChildShape(int index)
Gets the children.
virtual void unLockReadOnlyVertexBase(int subpart) const =0
void updateBound()
performs refit operation
virtual bool needsRetrieveTetrahedrons() const
Determines if this shape has tetrahedrons.
btVector3 m_vertices[4]
virtual ~btGImpactCompoundShape()
virtual void unlockChildShapes() const
btAlignedObjectArray< btGImpactMeshShapePart * > m_mesh_parts
btVector3FloatData m_localScaling
Structure for containing Boxes.
btAlignedObjectArray< btCollisionShape * > m_childShapes
virtual const btCollisionShape * getChildShape(int index) const
Gets the child.
virtual void calculateLocalInertia(btScalar mass, btVector3 &inertia) const
const btStridingMeshInterface * getMeshInterface() const
virtual bool needsRetrieveTriangles() const
Determines if this shape has triangles.
virtual void setChildTransform(int index, const btTransform &transform)
Sets the children transform.
btVector3 m_vertices1[3]
do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 ...
virtual void processAllTriangles(btTriangleCallback *callback, const btVector3 &aabbMin, const btVector3 &aabbMax) const
Function for retrieve triangles.
virtual void setChildTransform(int index, const btTransform &transform)=0
Sets the children transform.
virtual const btPrimitiveManagerBase * getPrimitiveManager() const
Obtains the primitive manager.
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:294
btGImpactCompoundShape allows to handle multiple btCollisionShape objects at once ...
PHY_ScalarType
PHY_ScalarType enumerates possible scalar types.
btGImpactMeshShape(btStridingMeshInterface *meshInterface)
virtual void lockChildShapes() const
call when reading child shapes
btGImpactQuantizedBvh btGImpactBoxSet
declare Quantized trees, (you can change to float based trees)
virtual void calculateLocalInertia(btScalar mass, btVector3 &inertia) const
Calculates the exact inertia tensor for this shape.
void buildSet()
this rebuild the entire set
virtual void setMargin(btScalar margin)