Bullet Collision Detection & Physics Library
gim_box_collision.h
Go to the documentation of this file.
1 #ifndef GIM_BOX_COLLISION_H_INCLUDED
2 #define GIM_BOX_COLLISION_H_INCLUDED
3 
7 /*
8 -----------------------------------------------------------------------------
9 This source file is part of GIMPACT Library.
10 
11 For the latest info, see http://gimpact.sourceforge.net/
12 
13 Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
14 email: projectileman@yahoo.com
15 
16  This library is free software; you can redistribute it and/or
17  modify it under the terms of EITHER:
18  (1) The GNU Lesser General Public License as published by the Free
19  Software Foundation; either version 2.1 of the License, or (at
20  your option) any later version. The text of the GNU Lesser
21  General Public License is included with this library in the
22  file GIMPACT-LICENSE-LGPL.TXT.
23  (2) The BSD-style license that is included with this library in
24  the file GIMPACT-LICENSE-BSD.TXT.
25  (3) The zlib/libpng license that is included with this library in
26  the file GIMPACT-LICENSE-ZLIB.TXT.
27 
28  This library is distributed in the hope that it will be useful,
29  but WITHOUT ANY WARRANTY; without even the implied warranty of
30  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
31  GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
32 
33 -----------------------------------------------------------------------------
34 */
35 #include "gim_basic_geometry_operations.h"
36 #include "LinearMath/btTransform.h"
37 
38 
39 
40 //SIMD_FORCE_INLINE bool test_cross_edge_box(
41 // const btVector3 & edge,
42 // const btVector3 & absolute_edge,
43 // const btVector3 & pointa,
44 // const btVector3 & pointb, const btVector3 & extend,
45 // int dir_index0,
46 // int dir_index1
47 // int component_index0,
48 // int component_index1)
49 //{
50 // // dir coords are -z and y
51 //
52 // const btScalar dir0 = -edge[dir_index0];
53 // const btScalar dir1 = edge[dir_index1];
54 // btScalar pmin = pointa[component_index0]*dir0 + pointa[component_index1]*dir1;
55 // btScalar pmax = pointb[component_index0]*dir0 + pointb[component_index1]*dir1;
56 // //find minmax
57 // if(pmin>pmax)
58 // {
59 // GIM_SWAP_NUMBERS(pmin,pmax);
60 // }
61 // //find extends
62 // const btScalar rad = extend[component_index0] * absolute_edge[dir_index0] +
63 // extend[component_index1] * absolute_edge[dir_index1];
64 //
65 // if(pmin>rad || -rad>pmax) return false;
66 // return true;
67 //}
68 //
69 //SIMD_FORCE_INLINE bool test_cross_edge_box_X_axis(
70 // const btVector3 & edge,
71 // const btVector3 & absolute_edge,
72 // const btVector3 & pointa,
73 // const btVector3 & pointb, btVector3 & extend)
74 //{
75 //
76 // return test_cross_edge_box(edge,absolute_edge,pointa,pointb,extend,2,1,1,2);
77 //}
78 //
79 //
80 //SIMD_FORCE_INLINE bool test_cross_edge_box_Y_axis(
81 // const btVector3 & edge,
82 // const btVector3 & absolute_edge,
83 // const btVector3 & pointa,
84 // const btVector3 & pointb, btVector3 & extend)
85 //{
86 //
87 // return test_cross_edge_box(edge,absolute_edge,pointa,pointb,extend,0,2,2,0);
88 //}
89 //
90 //SIMD_FORCE_INLINE bool test_cross_edge_box_Z_axis(
91 // const btVector3 & edge,
92 // const btVector3 & absolute_edge,
93 // const btVector3 & pointa,
94 // const btVector3 & pointb, btVector3 & extend)
95 //{
96 //
97 // return test_cross_edge_box(edge,absolute_edge,pointa,pointb,extend,1,0,0,1);
98 //}
99 
100 #define TEST_CROSS_EDGE_BOX_MCR(edge,absolute_edge,pointa,pointb,_extend,i_dir_0,i_dir_1,i_comp_0,i_comp_1)\
101 {\
102  const btScalar dir0 = -edge[i_dir_0];\
103  const btScalar dir1 = edge[i_dir_1];\
104  btScalar pmin = pointa[i_comp_0]*dir0 + pointa[i_comp_1]*dir1;\
105  btScalar pmax = pointb[i_comp_0]*dir0 + pointb[i_comp_1]*dir1;\
106  if(pmin>pmax)\
107  {\
108  GIM_SWAP_NUMBERS(pmin,pmax); \
109  }\
110  const btScalar abs_dir0 = absolute_edge[i_dir_0];\
111  const btScalar abs_dir1 = absolute_edge[i_dir_1];\
112  const btScalar rad = _extend[i_comp_0] * abs_dir0 + _extend[i_comp_1] * abs_dir1;\
113  if(pmin>rad || -rad>pmax) return false;\
114 }\
115 
116 
117 #define TEST_CROSS_EDGE_BOX_X_AXIS_MCR(edge,absolute_edge,pointa,pointb,_extend)\
118 {\
119  TEST_CROSS_EDGE_BOX_MCR(edge,absolute_edge,pointa,pointb,_extend,2,1,1,2);\
120 }\
121 
122 #define TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(edge,absolute_edge,pointa,pointb,_extend)\
123 {\
124  TEST_CROSS_EDGE_BOX_MCR(edge,absolute_edge,pointa,pointb,_extend,0,2,2,0);\
125 }\
126 
127 #define TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(edge,absolute_edge,pointa,pointb,_extend)\
128 {\
129  TEST_CROSS_EDGE_BOX_MCR(edge,absolute_edge,pointa,pointb,_extend,1,0,0,1);\
130 }\
131 
132 
133 
135 class GIM_BOX_BOX_TRANSFORM_CACHE
136 {
137 public:
138  btVector3 m_T1to0;
139  btMatrix3x3 m_R1to0;
140  btMatrix3x3 m_AR;
141 
142  SIMD_FORCE_INLINE void calc_absolute_matrix()
143  {
144  static const btVector3 vepsi(1e-6f,1e-6f,1e-6f);
145  m_AR[0] = vepsi + m_R1to0[0].absolute();
146  m_AR[1] = vepsi + m_R1to0[1].absolute();
147  m_AR[2] = vepsi + m_R1to0[2].absolute();
148  }
149 
150  GIM_BOX_BOX_TRANSFORM_CACHE()
151  {
152  }
153 
154 
155  GIM_BOX_BOX_TRANSFORM_CACHE(mat4f trans1_to_0)
156  {
157  COPY_MATRIX_3X3(m_R1to0,trans1_to_0)
158  MAT_GET_TRANSLATION(trans1_to_0,m_T1to0)
159  calc_absolute_matrix();
160  }
161 
163  SIMD_FORCE_INLINE void calc_from_homogenic(const btTransform & trans0,const btTransform & trans1)
164  {
165 
166  m_R1to0 = trans0.getBasis().transpose();
167  m_T1to0 = m_R1to0 * (-trans0.getOrigin());
168 
169  m_T1to0 += m_R1to0*trans1.getOrigin();
170  m_R1to0 *= trans1.getBasis();
171 
172  calc_absolute_matrix();
173  }
174 
176  SIMD_FORCE_INLINE void calc_from_full_invert(const btTransform & trans0,const btTransform & trans1)
177  {
178  m_R1to0 = trans0.getBasis().inverse();
179  m_T1to0 = m_R1to0 * (-trans0.getOrigin());
180 
181  m_T1to0 += m_R1to0*trans1.getOrigin();
182  m_R1to0 *= trans1.getBasis();
183 
184  calc_absolute_matrix();
185  }
186 
187  SIMD_FORCE_INLINE btVector3 transform(const btVector3 & point)
188  {
189  return point.dot3(m_R1to0[0], m_R1to0[1], m_R1to0[2]) + m_T1to0;
190  }
191 };
192 
193 
194 #define BOX_PLANE_EPSILON 0.000001f
195 
197 class GIM_AABB
198 {
199 public:
200  btVector3 m_min;
201  btVector3 m_max;
202 
203  GIM_AABB()
204  {}
205 
206 
207  GIM_AABB(const btVector3 & V1,
208  const btVector3 & V2,
209  const btVector3 & V3)
210  {
211  m_min[0] = GIM_MIN3(V1[0],V2[0],V3[0]);
212  m_min[1] = GIM_MIN3(V1[1],V2[1],V3[1]);
213  m_min[2] = GIM_MIN3(V1[2],V2[2],V3[2]);
214 
215  m_max[0] = GIM_MAX3(V1[0],V2[0],V3[0]);
216  m_max[1] = GIM_MAX3(V1[1],V2[1],V3[1]);
217  m_max[2] = GIM_MAX3(V1[2],V2[2],V3[2]);
218  }
219 
220  GIM_AABB(const btVector3 & V1,
221  const btVector3 & V2,
222  const btVector3 & V3,
223  GREAL margin)
224  {
225  m_min[0] = GIM_MIN3(V1[0],V2[0],V3[0]);
226  m_min[1] = GIM_MIN3(V1[1],V2[1],V3[1]);
227  m_min[2] = GIM_MIN3(V1[2],V2[2],V3[2]);
228 
229  m_max[0] = GIM_MAX3(V1[0],V2[0],V3[0]);
230  m_max[1] = GIM_MAX3(V1[1],V2[1],V3[1]);
231  m_max[2] = GIM_MAX3(V1[2],V2[2],V3[2]);
232 
233  m_min[0] -= margin;
234  m_min[1] -= margin;
235  m_min[2] -= margin;
236  m_max[0] += margin;
237  m_max[1] += margin;
238  m_max[2] += margin;
239  }
240 
241  GIM_AABB(const GIM_AABB &other):
242  m_min(other.m_min),m_max(other.m_max)
243  {
244  }
245 
246  GIM_AABB(const GIM_AABB &other,btScalar margin ):
247  m_min(other.m_min),m_max(other.m_max)
248  {
249  m_min[0] -= margin;
250  m_min[1] -= margin;
251  m_min[2] -= margin;
252  m_max[0] += margin;
253  m_max[1] += margin;
254  m_max[2] += margin;
255  }
256 
257  SIMD_FORCE_INLINE void invalidate()
258  {
259  m_min[0] = G_REAL_INFINITY;
260  m_min[1] = G_REAL_INFINITY;
261  m_min[2] = G_REAL_INFINITY;
262  m_max[0] = -G_REAL_INFINITY;
263  m_max[1] = -G_REAL_INFINITY;
264  m_max[2] = -G_REAL_INFINITY;
265  }
266 
267  SIMD_FORCE_INLINE void increment_margin(btScalar margin)
268  {
269  m_min[0] -= margin;
270  m_min[1] -= margin;
271  m_min[2] -= margin;
272  m_max[0] += margin;
273  m_max[1] += margin;
274  m_max[2] += margin;
275  }
276 
277  SIMD_FORCE_INLINE void copy_with_margin(const GIM_AABB &other, btScalar margin)
278  {
279  m_min[0] = other.m_min[0] - margin;
280  m_min[1] = other.m_min[1] - margin;
281  m_min[2] = other.m_min[2] - margin;
282 
283  m_max[0] = other.m_max[0] + margin;
284  m_max[1] = other.m_max[1] + margin;
285  m_max[2] = other.m_max[2] + margin;
286  }
287 
288  template<typename CLASS_POINT>
289  SIMD_FORCE_INLINE void calc_from_triangle(
290  const CLASS_POINT & V1,
291  const CLASS_POINT & V2,
292  const CLASS_POINT & V3)
293  {
294  m_min[0] = GIM_MIN3(V1[0],V2[0],V3[0]);
295  m_min[1] = GIM_MIN3(V1[1],V2[1],V3[1]);
296  m_min[2] = GIM_MIN3(V1[2],V2[2],V3[2]);
297 
298  m_max[0] = GIM_MAX3(V1[0],V2[0],V3[0]);
299  m_max[1] = GIM_MAX3(V1[1],V2[1],V3[1]);
300  m_max[2] = GIM_MAX3(V1[2],V2[2],V3[2]);
301  }
302 
303  template<typename CLASS_POINT>
304  SIMD_FORCE_INLINE void calc_from_triangle_margin(
305  const CLASS_POINT & V1,
306  const CLASS_POINT & V2,
307  const CLASS_POINT & V3, btScalar margin)
308  {
309  m_min[0] = GIM_MIN3(V1[0],V2[0],V3[0]);
310  m_min[1] = GIM_MIN3(V1[1],V2[1],V3[1]);
311  m_min[2] = GIM_MIN3(V1[2],V2[2],V3[2]);
312 
313  m_max[0] = GIM_MAX3(V1[0],V2[0],V3[0]);
314  m_max[1] = GIM_MAX3(V1[1],V2[1],V3[1]);
315  m_max[2] = GIM_MAX3(V1[2],V2[2],V3[2]);
316 
317  m_min[0] -= margin;
318  m_min[1] -= margin;
319  m_min[2] -= margin;
320  m_max[0] += margin;
321  m_max[1] += margin;
322  m_max[2] += margin;
323  }
324 
326  SIMD_FORCE_INLINE void appy_transform(const btTransform & trans)
327  {
328  btVector3 center = (m_max+m_min)*0.5f;
329  btVector3 extends = m_max - center;
330  // Compute new center
331  center = trans(center);
332 
333  btVector3 textends = extends.dot3(trans.getBasis().getRow(0).absolute(),
334  trans.getBasis().getRow(1).absolute(),
335  trans.getBasis().getRow(2).absolute());
336 
337  m_min = center - textends;
338  m_max = center + textends;
339  }
340 
342  SIMD_FORCE_INLINE void merge(const GIM_AABB & box)
343  {
344  m_min[0] = GIM_MIN(m_min[0],box.m_min[0]);
345  m_min[1] = GIM_MIN(m_min[1],box.m_min[1]);
346  m_min[2] = GIM_MIN(m_min[2],box.m_min[2]);
347 
348  m_max[0] = GIM_MAX(m_max[0],box.m_max[0]);
349  m_max[1] = GIM_MAX(m_max[1],box.m_max[1]);
350  m_max[2] = GIM_MAX(m_max[2],box.m_max[2]);
351  }
352 
354  template<typename CLASS_POINT>
355  SIMD_FORCE_INLINE void merge_point(const CLASS_POINT & point)
356  {
357  m_min[0] = GIM_MIN(m_min[0],point[0]);
358  m_min[1] = GIM_MIN(m_min[1],point[1]);
359  m_min[2] = GIM_MIN(m_min[2],point[2]);
360 
361  m_max[0] = GIM_MAX(m_max[0],point[0]);
362  m_max[1] = GIM_MAX(m_max[1],point[1]);
363  m_max[2] = GIM_MAX(m_max[2],point[2]);
364  }
365 
367  SIMD_FORCE_INLINE void get_center_extend(btVector3 & center,btVector3 & extend) const
368  {
369  center = (m_max+m_min)*0.5f;
370  extend = m_max - center;
371  }
372 
374  SIMD_FORCE_INLINE void find_intersection(const GIM_AABB & other, GIM_AABB & intersection) const
375  {
376  intersection.m_min[0] = GIM_MAX(other.m_min[0],m_min[0]);
377  intersection.m_min[1] = GIM_MAX(other.m_min[1],m_min[1]);
378  intersection.m_min[2] = GIM_MAX(other.m_min[2],m_min[2]);
379 
380  intersection.m_max[0] = GIM_MIN(other.m_max[0],m_max[0]);
381  intersection.m_max[1] = GIM_MIN(other.m_max[1],m_max[1]);
382  intersection.m_max[2] = GIM_MIN(other.m_max[2],m_max[2]);
383  }
384 
385 
386  SIMD_FORCE_INLINE bool has_collision(const GIM_AABB & other) const
387  {
388  if(m_min[0] > other.m_max[0] ||
389  m_max[0] < other.m_min[0] ||
390  m_min[1] > other.m_max[1] ||
391  m_max[1] < other.m_min[1] ||
392  m_min[2] > other.m_max[2] ||
393  m_max[2] < other.m_min[2])
394  {
395  return false;
396  }
397  return true;
398  }
399 
405  SIMD_FORCE_INLINE bool collide_ray(const btVector3 & vorigin,const btVector3 & vdir)
406  {
407  btVector3 extents,center;
408  this->get_center_extend(center,extents);;
409 
410  btScalar Dx = vorigin[0] - center[0];
411  if(GIM_GREATER(Dx, extents[0]) && Dx*vdir[0]>=0.0f) return false;
412  btScalar Dy = vorigin[1] - center[1];
413  if(GIM_GREATER(Dy, extents[1]) && Dy*vdir[1]>=0.0f) return false;
414  btScalar Dz = vorigin[2] - center[2];
415  if(GIM_GREATER(Dz, extents[2]) && Dz*vdir[2]>=0.0f) return false;
416 
417 
418  btScalar f = vdir[1] * Dz - vdir[2] * Dy;
419  if(btFabs(f) > extents[1]*btFabs(vdir[2]) + extents[2]*btFabs(vdir[1])) return false;
420  f = vdir[2] * Dx - vdir[0] * Dz;
421  if(btFabs(f) > extents[0]*btFabs(vdir[2]) + extents[2]*btFabs(vdir[0]))return false;
422  f = vdir[0] * Dy - vdir[1] * Dx;
423  if(btFabs(f) > extents[0]*btFabs(vdir[1]) + extents[1]*btFabs(vdir[0]))return false;
424  return true;
425  }
426 
427 
428  SIMD_FORCE_INLINE void projection_interval(const btVector3 & direction, btScalar &vmin, btScalar &vmax) const
429  {
430  btVector3 center = (m_max+m_min)*0.5f;
431  btVector3 extend = m_max-center;
432 
433  btScalar _fOrigin = direction.dot(center);
434  btScalar _fMaximumExtent = extend.dot(direction.absolute());
435  vmin = _fOrigin - _fMaximumExtent;
436  vmax = _fOrigin + _fMaximumExtent;
437  }
438 
439  SIMD_FORCE_INLINE ePLANE_INTERSECTION_TYPE plane_classify(const btVector4 &plane) const
440  {
441  btScalar _fmin,_fmax;
442  this->projection_interval(plane,_fmin,_fmax);
443 
444  if(plane[3] > _fmax + BOX_PLANE_EPSILON)
445  {
446  return G_BACK_PLANE; // 0
447  }
448 
449  if(plane[3]+BOX_PLANE_EPSILON >=_fmin)
450  {
451  return G_COLLIDE_PLANE; //1
452  }
453  return G_FRONT_PLANE;//2
454  }
455 
456  SIMD_FORCE_INLINE bool overlapping_trans_conservative(const GIM_AABB & box, btTransform & trans1_to_0)
457  {
458  GIM_AABB tbox = box;
459  tbox.appy_transform(trans1_to_0);
460  return has_collision(tbox);
461  }
462 
464  SIMD_FORCE_INLINE bool overlapping_trans_cache(
465  const GIM_AABB & box,const GIM_BOX_BOX_TRANSFORM_CACHE & transcache, bool fulltest)
466  {
467 
468  //Taken from OPCODE
469  btVector3 ea,eb;//extends
470  btVector3 ca,cb;//extends
471  get_center_extend(ca,ea);
472  box.get_center_extend(cb,eb);
473 
474 
475  btVector3 T;
476  btScalar t,t2;
477  int i;
478 
479  // Class I : A's basis vectors
480  for(i=0;i<3;i++)
481  {
482  T[i] = transcache.m_R1to0[i].dot(cb) + transcache.m_T1to0[i] - ca[i];
483  t = transcache.m_AR[i].dot(eb) + ea[i];
484  if(GIM_GREATER(T[i], t)) return false;
485  }
486  // Class II : B's basis vectors
487  for(i=0;i<3;i++)
488  {
489  t = MAT_DOT_COL(transcache.m_R1to0,T,i);
490  t2 = MAT_DOT_COL(transcache.m_AR,ea,i) + eb[i];
491  if(GIM_GREATER(t,t2)) return false;
492  }
493  // Class III : 9 cross products
494  if(fulltest)
495  {
496  int j,m,n,o,p,q,r;
497  for(i=0;i<3;i++)
498  {
499  m = (i+1)%3;
500  n = (i+2)%3;
501  o = i==0?1:0;
502  p = i==2?1:2;
503  for(j=0;j<3;j++)
504  {
505  q = j==2?1:2;
506  r = j==0?1:0;
507  t = T[n]*transcache.m_R1to0[m][j] - T[m]*transcache.m_R1to0[n][j];
508  t2 = ea[o]*transcache.m_AR[p][j] + ea[p]*transcache.m_AR[o][j] +
509  eb[r]*transcache.m_AR[i][q] + eb[q]*transcache.m_AR[i][r];
510  if(GIM_GREATER(t,t2)) return false;
511  }
512  }
513  }
514  return true;
515  }
516 
518  SIMD_FORCE_INLINE bool collide_plane(
519  const btVector4 & plane)
520  {
521  ePLANE_INTERSECTION_TYPE classify = plane_classify(plane);
522  return (classify == G_COLLIDE_PLANE);
523  }
524 
526  SIMD_FORCE_INLINE bool collide_triangle_exact(
527  const btVector3 & p1,
528  const btVector3 & p2,
529  const btVector3 & p3,
530  const btVector4 & triangle_plane)
531  {
532  if(!collide_plane(triangle_plane)) return false;
533 
534  btVector3 center,extends;
535  this->get_center_extend(center,extends);
536 
537  const btVector3 v1(p1 - center);
538  const btVector3 v2(p2 - center);
539  const btVector3 v3(p3 - center);
540 
541  //First axis
542  btVector3 diff(v2 - v1);
543  btVector3 abs_diff = diff.absolute();
544  //Test With X axis
545  TEST_CROSS_EDGE_BOX_X_AXIS_MCR(diff,abs_diff,v1,v3,extends);
546  //Test With Y axis
547  TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(diff,abs_diff,v1,v3,extends);
548  //Test With Z axis
549  TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(diff,abs_diff,v1,v3,extends);
550 
551 
552  diff = v3 - v2;
553  abs_diff = diff.absolute();
554  //Test With X axis
555  TEST_CROSS_EDGE_BOX_X_AXIS_MCR(diff,abs_diff,v2,v1,extends);
556  //Test With Y axis
557  TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(diff,abs_diff,v2,v1,extends);
558  //Test With Z axis
559  TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(diff,abs_diff,v2,v1,extends);
560 
561  diff = v1 - v3;
562  abs_diff = diff.absolute();
563  //Test With X axis
564  TEST_CROSS_EDGE_BOX_X_AXIS_MCR(diff,abs_diff,v3,v2,extends);
565  //Test With Y axis
566  TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(diff,abs_diff,v3,v2,extends);
567  //Test With Z axis
568  TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(diff,abs_diff,v3,v2,extends);
569 
570  return true;
571  }
572 };
573 
574 
576 SIMD_FORCE_INLINE bool btCompareTransformsEqual(const btTransform & t1,const btTransform & t2)
577 {
578  if(!(t1.getOrigin() == t2.getOrigin()) ) return false;
579 
580  if(!(t1.getBasis().getRow(0) == t2.getBasis().getRow(0)) ) return false;
581  if(!(t1.getBasis().getRow(1) == t2.getBasis().getRow(1)) ) return false;
582  if(!(t1.getBasis().getRow(2) == t2.getBasis().getRow(2)) ) return false;
583  return true;
584 }
585 
586 
587 
588 #endif // GIM_BOX_COLLISION_H_INCLUDED
btMatrix3x3::inverse
btMatrix3x3 inverse() const
Return the inverse of the matrix.
Definition: btMatrix3x3.h:1025
GIM_AABB::invalidate
void invalidate()
Definition: gim_box_collision.h:257
GIM_MIN
#define GIM_MIN(a, b)
Definition: gim_math.h:94
GIM_AABB::plane_classify
ePLANE_INTERSECTION_TYPE plane_classify(const btVector4 &plane) const
Definition: gim_box_collision.h:439
GIM_BOX_BOX_TRANSFORM_CACHE::calc_absolute_matrix
void calc_absolute_matrix()
Definition: gim_box_collision.h:142
GIM_AABB::calc_from_triangle_margin
void calc_from_triangle_margin(const CLASS_POINT &V1, const CLASS_POINT &V2, const CLASS_POINT &V3, btScalar margin)
Definition: gim_box_collision.h:304
GIM_BOX_BOX_TRANSFORM_CACHE::m_T1to0
btVector3 m_T1to0
Transforms translation of model1 to model 0.
Definition: gim_box_collision.h:138
GIM_AABB::find_intersection
void find_intersection(const GIM_AABB &other, GIM_AABB &intersection) const
Finds the intersecting box between this box and the other.
Definition: gim_box_collision.h:374
GIM_AABB::get_center_extend
void get_center_extend(btVector3 &center, btVector3 &extend) const
Gets the extend and center.
Definition: gim_box_collision.h:367
TEST_CROSS_EDGE_BOX_X_AXIS_MCR
#define TEST_CROSS_EDGE_BOX_X_AXIS_MCR(edge, absolute_edge, pointa, pointb, _extend)
Definition: gim_box_collision.h:117
GIM_AABB::m_min
btVector3 m_min
Definition: gim_box_collision.h:200
GIM_BOX_BOX_TRANSFORM_CACHE::calc_from_homogenic
void calc_from_homogenic(const btTransform &trans0, const btTransform &trans1)
Calc the transformation relative 1 to 0. Inverts matrics by transposing.
Definition: gim_box_collision.h:163
GIM_GREATER
#define GIM_GREATER(x, y)
Definition: gim_math.h:110
gim_basic_geometry_operations.h
btVector3::absolute
btVector3 absolute() const
Return a vector will the absolute values of each element.
Definition: btVector3.h:360
GIM_AABB::has_collision
bool has_collision(const GIM_AABB &other) const
Definition: gim_box_collision.h:386
SIMD_FORCE_INLINE
#define SIMD_FORCE_INLINE
Definition: btScalar.h:58
GIM_AABB
Axis aligned box.
Definition: gim_box_collision.h:197
btMatrix3x3::getRow
const btVector3 & getRow(int i) const
Get a row of the matrix as a vector.
Definition: btMatrix3x3.h:142
GIM_AABB::GIM_AABB
GIM_AABB(const GIM_AABB &other)
Definition: gim_box_collision.h:241
btVector3::dot
btScalar dot(const btVector3 &v) const
Return the dot product.
Definition: btVector3.h:235
GIM_AABB::copy_with_margin
void copy_with_margin(const GIM_AABB &other, btScalar margin)
Definition: gim_box_collision.h:277
GREAL
#define GREAL
Definition: gim_math.h:39
GIM_AABB::overlapping_trans_conservative
bool overlapping_trans_conservative(const GIM_AABB &box, btTransform &trans1_to_0)
Definition: gim_box_collision.h:456
GIM_AABB::collide_ray
bool collide_ray(const btVector3 &vorigin, const btVector3 &vdir)
Finds the Ray intersection parameter.
Definition: gim_box_collision.h:405
GIM_BOX_BOX_TRANSFORM_CACHE::m_AR
btMatrix3x3 m_AR
Absolute value of m_R1to0.
Definition: gim_box_collision.h:140
GIM_AABB::calc_from_triangle
void calc_from_triangle(const CLASS_POINT &V1, const CLASS_POINT &V2, const CLASS_POINT &V3)
Definition: gim_box_collision.h:289
GIM_MAX
#define GIM_MAX(a, b)
Definition: gim_math.h:93
btTransform::getOrigin
btVector3 & getOrigin()
Return the origin vector translation.
Definition: btTransform.h:117
btMatrix3x3::absolute
btMatrix3x3 absolute() const
Return the matrix with all values non negative.
Definition: btMatrix3x3.h:959
BOX_PLANE_EPSILON
#define BOX_PLANE_EPSILON
Definition: gim_box_collision.h:194
GIM_AABB::GIM_AABB
GIM_AABB()
Definition: gim_box_collision.h:203
TEST_CROSS_EDGE_BOX_Y_AXIS_MCR
#define TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(edge, absolute_edge, pointa, pointb, _extend)
Definition: gim_box_collision.h:122
GIM_AABB::collide_plane
bool collide_plane(const btVector4 &plane)
Simple test for planes.
Definition: gim_box_collision.h:518
btTransform::getBasis
btMatrix3x3 & getBasis()
Return the basis matrix for the rotation.
Definition: btTransform.h:112
G_BACK_PLANE
Definition: gim_basic_geometry_operations.h:124
GIM_AABB::GIM_AABB
GIM_AABB(const GIM_AABB &other, btScalar margin)
Definition: gim_box_collision.h:246
GIM_MIN3
#define GIM_MIN3(a, b, c)
Definition: gim_math.h:97
G_COLLIDE_PLANE
Definition: gim_basic_geometry_operations.h:125
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
GIM_BOX_BOX_TRANSFORM_CACHE::calc_from_full_invert
void calc_from_full_invert(const btTransform &trans0, const btTransform &trans1)
Calcs the full invertion of the matrices. Useful for scaling matrices.
Definition: gim_box_collision.h:176
GIM_AABB::overlapping_trans_cache
bool overlapping_trans_cache(const GIM_AABB &box, const GIM_BOX_BOX_TRANSFORM_CACHE &transcache, bool fulltest)
transcache is the transformation cache from box to this AABB
Definition: gim_box_collision.h:464
mat4f
GREAL mat4f[4][4]
Matrix 4D, row ordered.
Definition: gim_geom_types.h:88
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
GIM_AABB::GIM_AABB
GIM_AABB(const btVector3 &V1, const btVector3 &V2, const btVector3 &V3)
Definition: gim_box_collision.h:207
btCompareTransformsEqual
bool btCompareTransformsEqual(const btTransform &t1, const btTransform &t2)
Compairison of transformation objects.
Definition: gim_box_collision.h:576
btMatrix3x3::transpose
btMatrix3x3 transpose() const
Return the transpose of the matrix.
Definition: btMatrix3x3.h:980
GIM_BOX_BOX_TRANSFORM_CACHE::m_R1to0
btMatrix3x3 m_R1to0
Transforms Rotation of model1 to model 0, equal to R0' * R1.
Definition: gim_box_collision.h:139
GIM_AABB::m_max
btVector3 m_max
Definition: gim_box_collision.h:201
GIM_BOX_BOX_TRANSFORM_CACHE
Class for transforming a model1 to the space of model0.
Definition: gim_box_collision.h:135
GIM_AABB::merge_point
void merge_point(const CLASS_POINT &point)
Merges a point.
Definition: gim_box_collision.h:355
GIM_AABB::appy_transform
void appy_transform(const btTransform &trans)
Apply a transform to an AABB.
Definition: gim_box_collision.h:326
btVector3::dot3
btVector3 dot3(const btVector3 &v0, const btVector3 &v1, const btVector3 &v2) const
Definition: btVector3.h:718
ePLANE_INTERSECTION_TYPE
ePLANE_INTERSECTION_TYPE
Definition: gim_basic_geometry_operations.h:122
GIM_BOX_BOX_TRANSFORM_CACHE::GIM_BOX_BOX_TRANSFORM_CACHE
GIM_BOX_BOX_TRANSFORM_CACHE(mat4f trans1_to_0)
Definition: gim_box_collision.h:155
MAT_GET_TRANSLATION
#define MAT_GET_TRANSLATION(mat, vec3)
Get the triple(3) col of a transform matrix.
Definition: gim_linear_math.h:1524
G_REAL_INFINITY
#define G_REAL_INFINITY
Definition: gim_math.h:58
COPY_MATRIX_3X3
#define COPY_MATRIX_3X3(b, a)
Definition: gim_linear_math.h:615
TEST_CROSS_EDGE_BOX_Z_AXIS_MCR
#define TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(edge, absolute_edge, pointa, pointb, _extend)
Definition: gim_box_collision.h:127
btMatrix3x3
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
Definition: btMatrix3x3.h:48
G_FRONT_PLANE
Definition: gim_basic_geometry_operations.h:126
GIM_AABB::collide_triangle_exact
bool collide_triangle_exact(const btVector3 &p1, const btVector3 &p2, const btVector3 &p3, const btVector4 &triangle_plane)
test for a triangle, with edges
Definition: gim_box_collision.h:526
GIM_BOX_BOX_TRANSFORM_CACHE::GIM_BOX_BOX_TRANSFORM_CACHE
GIM_BOX_BOX_TRANSFORM_CACHE()
Definition: gim_box_collision.h:150
GIM_AABB::projection_interval
void projection_interval(const btVector3 &direction, btScalar &vmin, btScalar &vmax) const
Definition: gim_box_collision.h:428
GIM_MAX3
#define GIM_MAX3(a, b, c)
Definition: gim_math.h:96
GIM_AABB::GIM_AABB
GIM_AABB(const btVector3 &V1, const btVector3 &V2, const btVector3 &V3, GREAL margin)
Definition: gim_box_collision.h:220
GIM_BOX_BOX_TRANSFORM_CACHE::transform
btVector3 transform(const btVector3 &point)
Definition: gim_box_collision.h:187
MAT_DOT_COL
#define MAT_DOT_COL(mat, vec3, colindex)
Returns the dot product between a vec3f and the col of a matrix.
Definition: gim_linear_math.h:1552
GIM_AABB::increment_margin
void increment_margin(btScalar margin)
Definition: gim_box_collision.h:267
GIM_AABB::merge
void merge(const GIM_AABB &box)
Merges a Box.
Definition: gim_box_collision.h:342
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:266
btFabs
btScalar btFabs(btScalar x)
Definition: btScalar.h:407
Generated on Wed Feb 5 2014 21:36:54 for Bullet Collision Detection & Physics Library by   doxygen 1.8.6