Bullet Collision Detection & Physics Library: gim_box_set.h Source File

Bullet Collision Detection & Physics Library

gim_box_set.h
Go to the documentation of this file.
1 #ifndef GIM_BOX_SET_H_INCLUDED
2 #define GIM_BOX_SET_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
36
37 #include "gim_array.h"
38 #include "gim_radixsort.h"
39 #include "gim_box_collision.h"
40 #include "gim_tri_collision.h"
41
42
43
45 struct GIM_PAIR
46 {
47 GUINT m_index1;
48 GUINT m_index2;
49 GIM_PAIR()
50 {}
51
52 GIM_PAIR(const GIM_PAIR & p)
53 {
54 m_index1 = p.m_index1;
55 m_index2 = p.m_index2;
56 }
57
58 GIM_PAIR(GUINT index1, GUINT index2)
59 {
60 m_index1 = index1;
61 m_index2 = index2;
62 }
63 };
64
66 class gim_pair_set: public gim_array<GIM_PAIR>
67 {
68 public:
69 gim_pair_set():gim_array<GIM_PAIR>(32)
70 {
71 }
72 inline void push_pair(GUINT index1,GUINT index2)
73 {
74 push_back(GIM_PAIR(index1,index2));
75 }
76
77 inline void push_pair_inv(GUINT index1,GUINT index2)
78 {
79 push_back(GIM_PAIR(index2,index1));
80 }
81 };
82
83
85
90 class GIM_PRIMITIVE_MANAGER_PROTOTYPE
91 {
92 public:
93
94 virtual ~GIM_PRIMITIVE_MANAGER_PROTOTYPE() {}
96 virtual bool is_trimesh() = 0;
97 virtual GUINT get_primitive_count() = 0;
98 virtual void get_primitive_box(GUINT prim_index ,GIM_AABB & primbox) = 0;
99 virtual void get_primitive_triangle(GUINT prim_index,GIM_TRIANGLE & triangle) = 0;
100 };
101
102
103 struct GIM_AABB_DATA
104 {
105 GIM_AABB m_bound;
106 GUINT m_data;
107 };
108
110 struct GIM_BOX_TREE_NODE
111 {
112 GIM_AABB m_bound;
113 GUINT m_left;
114 GUINT m_right;
115 GUINT m_escapeIndex;
116 GUINT m_data;
117
118 GIM_BOX_TREE_NODE()
119 {
120 m_left = 0;
121 m_right = 0;
122 m_escapeIndex = 0;
123 m_data = 0;
124 }
125
126 SIMD_FORCE_INLINE bool is_leaf_node() const
127 {
128 return (!m_left && !m_right);
129 }
130 };
131
133 class GIM_BOX_TREE
134 {
135 protected:
136 GUINT m_num_nodes;
137 gim_array<GIM_BOX_TREE_NODE> m_node_array;
138 protected:
139 GUINT _sort_and_calc_splitting_index(
140 gim_array<GIM_AABB_DATA> & primitive_boxes,
141 GUINT startIndex, GUINT endIndex, GUINT splitAxis);
142
143 GUINT _calc_splitting_axis(gim_array<GIM_AABB_DATA> & primitive_boxes, GUINT startIndex, GUINT endIndex);
144
145 void _build_sub_tree(gim_array<GIM_AABB_DATA> & primitive_boxes, GUINT startIndex, GUINT endIndex);
146 public:
147 GIM_BOX_TREE()
148 {
149 m_num_nodes = 0;
150 }
151
154 void build_tree(gim_array<GIM_AABB_DATA> & primitive_boxes);
155
156 SIMD_FORCE_INLINE void clearNodes()
157 {
158 m_node_array.clear();
159 m_num_nodes = 0;
160 }
161
163 SIMD_FORCE_INLINE GUINT getNodeCount() const
164 {
165 return m_num_nodes;
166 }
167
169 SIMD_FORCE_INLINE bool isLeafNode(GUINT nodeindex) const
170 {
171 return m_node_array[nodeindex].is_leaf_node();
172 }
173
174 SIMD_FORCE_INLINE GUINT getNodeData(GUINT nodeindex) const
175 {
176 return m_node_array[nodeindex].m_data;
177 }
178
179 SIMD_FORCE_INLINE void getNodeBound(GUINT nodeindex, GIM_AABB & bound) const
180 {
181 bound = m_node_array[nodeindex].m_bound;
182 }
183
184 SIMD_FORCE_INLINE void setNodeBound(GUINT nodeindex, const GIM_AABB & bound)
185 {
186 m_node_array[nodeindex].m_bound = bound;
187 }
188
189 SIMD_FORCE_INLINE GUINT getLeftNodeIndex(GUINT nodeindex) const
190 {
191 return m_node_array[nodeindex].m_left;
192 }
193
194 SIMD_FORCE_INLINE GUINT getRightNodeIndex(GUINT nodeindex) const
195 {
196 return m_node_array[nodeindex].m_right;
197 }
198
199 SIMD_FORCE_INLINE GUINT getScapeNodeIndex(GUINT nodeindex) const
200 {
201 return m_node_array[nodeindex].m_escapeIndex;
202 }
203
205 };
206
207
209
214 template<typename _GIM_PRIMITIVE_MANAGER_PROTOTYPE, typename _GIM_BOX_TREE_PROTOTYPE>
215 class GIM_BOX_TREE_TEMPLATE_SET
216 {
217 protected:
218 _GIM_PRIMITIVE_MANAGER_PROTOTYPE m_primitive_manager;
219 _GIM_BOX_TREE_PROTOTYPE m_box_tree;
220 protected:
221 //stackless refit
222 SIMD_FORCE_INLINE void refit()
223 {
224 GUINT nodecount = getNodeCount();
225 while(nodecount--)
226 {
227 if(isLeafNode(nodecount))
228 {
229 GIM_AABB leafbox;
230 m_primitive_manager.get_primitive_box(getNodeData(nodecount),leafbox);
231 setNodeBound(nodecount,leafbox);
232 }
233 else
234 {
235 //get left bound
236 GUINT childindex = getLeftNodeIndex(nodecount);
237 GIM_AABB bound;
238 getNodeBound(childindex,bound);
239 //get right bound
240 childindex = getRightNodeIndex(nodecount);
241 GIM_AABB bound2;
242 getNodeBound(childindex,bound2);
243 bound.merge(bound2);
244
245 setNodeBound(nodecount,bound);
246 }
247 }
248 }
249 public:
250
251 GIM_BOX_TREE_TEMPLATE_SET()
252 {
253 }
254
255 SIMD_FORCE_INLINE GIM_AABB getGlobalBox() const
256 {
257 GIM_AABB totalbox;
258 getNodeBound(0, totalbox);
259 return totalbox;
260 }
261
262 SIMD_FORCE_INLINE void setPrimitiveManager(const _GIM_PRIMITIVE_MANAGER_PROTOTYPE & primitive_manager)
263 {
264 m_primitive_manager = primitive_manager;
265 }
266
267 const _GIM_PRIMITIVE_MANAGER_PROTOTYPE & getPrimitiveManager() const
268 {
269 return m_primitive_manager;
270 }
271
272 _GIM_PRIMITIVE_MANAGER_PROTOTYPE & getPrimitiveManager()
273 {
274 return m_primitive_manager;
275 }
276
279
281 SIMD_FORCE_INLINE void update()
282 {
283 refit();
284 }
285
287 SIMD_FORCE_INLINE void buildSet()
288 {
289 //obtain primitive boxes
290 gim_array<GIM_AABB_DATA> primitive_boxes;
291 primitive_boxes.resize(m_primitive_manager.get_primitive_count(),false);
292
293 for (GUINT i = 0;i<primitive_boxes.size() ;i++ )
294 {
295 m_primitive_manager.get_primitive_box(i,primitive_boxes[i].m_bound);
296 primitive_boxes[i].m_data = i;
297 }
298
299 m_box_tree.build_tree(primitive_boxes);
300 }
301
303 SIMD_FORCE_INLINE bool boxQuery(const GIM_AABB & box, gim_array<GUINT> & collided_results) const
304 {
305 GUINT curIndex = 0;
306 GUINT numNodes = getNodeCount();
307
308 while (curIndex < numNodes)
309 {
310 GIM_AABB bound;
311 getNodeBound(curIndex,bound);
312
313 //catch bugs in tree data
314
315 bool aabbOverlap = bound.has_collision(box);
316 bool isleafnode = isLeafNode(curIndex);
317
318 if (isleafnode && aabbOverlap)
319 {
320 collided_results.push_back(getNodeData(curIndex));
321 }
322
323 if (aabbOverlap || isleafnode)
324 {
325 //next subnode
326 curIndex++;
327 }
328 else
329 {
330 //skip node
331 curIndex+= getScapeNodeIndex(curIndex);
332 }
333 }
334 if(collided_results.size()>0) return true;
335 return false;
336 }
337
339 SIMD_FORCE_INLINE bool boxQueryTrans(const GIM_AABB & box,
340 const btTransform & transform, gim_array<GUINT> & collided_results) const
341 {
342 GIM_AABB transbox=box;
343 transbox.appy_transform(transform);
344 return boxQuery(transbox,collided_results);
345 }
346
348 SIMD_FORCE_INLINE bool rayQuery(
349 const btVector3 & ray_dir,const btVector3 & ray_origin ,
350 gim_array<GUINT> & collided_results) const
351 {
352 GUINT curIndex = 0;
353 GUINT numNodes = getNodeCount();
354
355 while (curIndex < numNodes)
356 {
357 GIM_AABB bound;
358 getNodeBound(curIndex,bound);
359
360 //catch bugs in tree data
361
362 bool aabbOverlap = bound.collide_ray(ray_origin,ray_dir);
363 bool isleafnode = isLeafNode(curIndex);
364
365 if (isleafnode && aabbOverlap)
366 {
367 collided_results.push_back(getNodeData( curIndex));
368 }
369
370 if (aabbOverlap || isleafnode)
371 {
372 //next subnode
373 curIndex++;
374 }
375 else
376 {
377 //skip node
378 curIndex+= getScapeNodeIndex(curIndex);
379 }
380 }
381 if(collided_results.size()>0) return true;
382 return false;
383 }
384
386 SIMD_FORCE_INLINE bool hasHierarchy() const
387 {
388 return true;
389 }
390
392 SIMD_FORCE_INLINE bool isTrimesh() const
393 {
394 return m_primitive_manager.is_trimesh();
395 }
396
398 SIMD_FORCE_INLINE GUINT getNodeCount() const
399 {
400 return m_box_tree.getNodeCount();
401 }
402
404 SIMD_FORCE_INLINE bool isLeafNode(GUINT nodeindex) const
405 {
406 return m_box_tree.isLeafNode(nodeindex);
407 }
408
409 SIMD_FORCE_INLINE GUINT getNodeData(GUINT nodeindex) const
410 {
411 return m_box_tree.getNodeData(nodeindex);
412 }
413
414 SIMD_FORCE_INLINE void getNodeBound(GUINT nodeindex, GIM_AABB & bound) const
415 {
416 m_box_tree.getNodeBound(nodeindex, bound);
417 }
418
419 SIMD_FORCE_INLINE void setNodeBound(GUINT nodeindex, const GIM_AABB & bound)
420 {
421 m_box_tree.setNodeBound(nodeindex, bound);
422 }
423
424 SIMD_FORCE_INLINE GUINT getLeftNodeIndex(GUINT nodeindex) const
425 {
426 return m_box_tree.getLeftNodeIndex(nodeindex);
427 }
428
429 SIMD_FORCE_INLINE GUINT getRightNodeIndex(GUINT nodeindex) const
430 {
431 return m_box_tree.getRightNodeIndex(nodeindex);
432 }
433
434 SIMD_FORCE_INLINE GUINT getScapeNodeIndex(GUINT nodeindex) const
435 {
436 return m_box_tree.getScapeNodeIndex(nodeindex);
437 }
438
439 SIMD_FORCE_INLINE void getNodeTriangle(GUINT nodeindex,GIM_TRIANGLE & triangle) const
440 {
441 m_primitive_manager.get_primitive_triangle(getNodeData(nodeindex),triangle);
442 }
443
444 };
445
447
450 template<typename _GIM_PRIMITIVE_MANAGER_PROTOTYPE>
451 class GIM_BOX_TREE_SET: public GIM_BOX_TREE_TEMPLATE_SET< _GIM_PRIMITIVE_MANAGER_PROTOTYPE, GIM_BOX_TREE>
452 {
453 public:
454
455 };
456
457
458
459
460
462 template<typename BOX_SET_CLASS0,typename BOX_SET_CLASS1>
463 class GIM_TREE_TREE_COLLIDER
464 {
465 public:
466 gim_pair_set * m_collision_pairs;
467 BOX_SET_CLASS0 * m_boxset0;
468 BOX_SET_CLASS1 * m_boxset1;
469 GUINT current_node0;
470 GUINT current_node1;
471 bool node0_is_leaf;
472 bool node1_is_leaf;
473 bool t0_is_trimesh;
474 bool t1_is_trimesh;
475 bool node0_has_triangle;
476 bool node1_has_triangle;
477 GIM_AABB m_box0;
478 GIM_AABB m_box1;
479 GIM_BOX_BOX_TRANSFORM_CACHE trans_cache_1to0;
480 btTransform trans_cache_0to1;
481 GIM_TRIANGLE m_tri0;
482 btVector4 m_tri0_plane;
483 GIM_TRIANGLE m_tri1;
484 btVector4 m_tri1_plane;
485
486
487 public:
488 GIM_TREE_TREE_COLLIDER()
489 {
490 current_node0 = G_UINT_INFINITY;
491 current_node1 = G_UINT_INFINITY;
492 }
493 protected:
494 SIMD_FORCE_INLINE void retrieve_node0_triangle(GUINT node0)
495 {
496 if(node0_has_triangle) return;
497 m_boxset0->getNodeTriangle(node0,m_tri0);
498 //transform triangle
499 m_tri0.m_vertices[0] = trans_cache_0to1(m_tri0.m_vertices[0]);
500 m_tri0.m_vertices[1] = trans_cache_0to1(m_tri0.m_vertices[1]);
501 m_tri0.m_vertices[2] = trans_cache_0to1(m_tri0.m_vertices[2]);
502 m_tri0.get_plane(m_tri0_plane);
503
504 node0_has_triangle = true;
505 }
506
507 SIMD_FORCE_INLINE void retrieve_node1_triangle(GUINT node1)
508 {
509 if(node1_has_triangle) return;
510 m_boxset1->getNodeTriangle(node1,m_tri1);
511 //transform triangle
512 m_tri1.m_vertices[0] = trans_cache_1to0.transform(m_tri1.m_vertices[0]);
513 m_tri1.m_vertices[1] = trans_cache_1to0.transform(m_tri1.m_vertices[1]);
514 m_tri1.m_vertices[2] = trans_cache_1to0.transform(m_tri1.m_vertices[2]);
515 m_tri1.get_plane(m_tri1_plane);
516
517 node1_has_triangle = true;
518 }
519
520 SIMD_FORCE_INLINE void retrieve_node0_info(GUINT node0)
521 {
522 if(node0 == current_node0) return;
523 m_boxset0->getNodeBound(node0,m_box0);
524 node0_is_leaf = m_boxset0->isLeafNode(node0);
525 node0_has_triangle = false;
526 current_node0 = node0;
527 }
528
529 SIMD_FORCE_INLINE void retrieve_node1_info(GUINT node1)
530 {
531 if(node1 == current_node1) return;
532 m_boxset1->getNodeBound(node1,m_box1);
533 node1_is_leaf = m_boxset1->isLeafNode(node1);
534 node1_has_triangle = false;
535 current_node1 = node1;
536 }
537
538 SIMD_FORCE_INLINE bool node_collision(GUINT node0 ,GUINT node1)
539 {
540 retrieve_node0_info(node0);
541 retrieve_node1_info(node1);
542 bool result = m_box0.overlapping_trans_cache(m_box1,trans_cache_1to0,true);
543 if(!result) return false;
544
545 if(t0_is_trimesh && node0_is_leaf)
546 {
547 //perform primitive vs box collision
548 retrieve_node0_triangle(node0);
549 //do triangle vs box collision
550 m_box1.increment_margin(m_tri0.m_margin);
551
552 result = m_box1.collide_triangle_exact(
553 m_tri0.m_vertices[0],m_tri0.m_vertices[1],m_tri0.m_vertices[2],m_tri0_plane);
554
555 m_box1.increment_margin(-m_tri0.m_margin);
556
557 if(!result) return false;
558 return true;
559 }
560 else if(t1_is_trimesh && node1_is_leaf)
561 {
562 //perform primitive vs box collision
563 retrieve_node1_triangle(node1);
564 //do triangle vs box collision
565 m_box0.increment_margin(m_tri1.m_margin);
566
567 result = m_box0.collide_triangle_exact(
568 m_tri1.m_vertices[0],m_tri1.m_vertices[1],m_tri1.m_vertices[2],m_tri1_plane);
569
570 m_box0.increment_margin(-m_tri1.m_margin);
571
572 if(!result) return false;
573 return true;
574 }
575 return true;
576 }
577
578 //stackless collision routine
579 void find_collision_pairs()
580 {
581 gim_pair_set stack_collisions;
582 stack_collisions.reserve(32);
583
584 //add the first pair
585 stack_collisions.push_pair(0,0);
586
587
588 while(stack_collisions.size())
589 {
590 //retrieve the last pair and pop
591 GUINT node0 = stack_collisions.back().m_index1;
592 GUINT node1 = stack_collisions.back().m_index2;
593 stack_collisions.pop_back();
594 if(node_collision(node0,node1)) // a collision is found
595 {
596 if(node0_is_leaf)
597 {
598 if(node1_is_leaf)
599 {
600 m_collision_pairs->push_pair(m_boxset0->getNodeData(node0),m_boxset1->getNodeData(node1));
601 }
602 else
603 {
604 //collide left
605 stack_collisions.push_pair(node0,m_boxset1->getLeftNodeIndex(node1));
606
607 //collide right
608 stack_collisions.push_pair(node0,m_boxset1->getRightNodeIndex(node1));
609 }
610 }
611 else
612 {
613 if(node1_is_leaf)
614 {
615 //collide left
616 stack_collisions.push_pair(m_boxset0->getLeftNodeIndex(node0),node1);
617 //collide right
618 stack_collisions.push_pair(m_boxset0->getRightNodeIndex(node0),node1);
619 }
620 else
621 {
622 GUINT left0 = m_boxset0->getLeftNodeIndex(node0);
623 GUINT right0 = m_boxset0->getRightNodeIndex(node0);
624 GUINT left1 = m_boxset1->getLeftNodeIndex(node1);
625 GUINT right1 = m_boxset1->getRightNodeIndex(node1);
626 //collide left
627 stack_collisions.push_pair(left0,left1);
628 //collide right
629 stack_collisions.push_pair(left0,right1);
630 //collide left
631 stack_collisions.push_pair(right0,left1);
632 //collide right
633 stack_collisions.push_pair(right0,right1);
634
635 }// else if node1 is not a leaf
636 }// else if node0 is not a leaf
637
638 }// if(node_collision(node0,node1))
639 }//while(stack_collisions.size())
640 }
641 public:
642 void find_collision(BOX_SET_CLASS0 * boxset1, const btTransform & trans1,
643 BOX_SET_CLASS1 * boxset2, const btTransform & trans2,
644 gim_pair_set & collision_pairs, bool complete_primitive_tests = true)
645 {
646 m_collision_pairs = &collision_pairs;
647 m_boxset0 = boxset1;
648 m_boxset1 = boxset2;
649
650 trans_cache_1to0.calc_from_homogenic(trans1,trans2);
651
652 trans_cache_0to1 = trans2.inverse();
653 trans_cache_0to1 *= trans1;
654
655
656 if(complete_primitive_tests)
657 {
658 t0_is_trimesh = boxset1->getPrimitiveManager().is_trimesh();
659 t1_is_trimesh = boxset2->getPrimitiveManager().is_trimesh();
660 }
661 else
662 {
663 t0_is_trimesh = false;
664 t1_is_trimesh = false;
665 }
666
667 find_collision_pairs();
668 }
669 };
670
671
672 #endif // GIM_BOXPRUNING_H_INCLUDED
673
674
GIM_TREE_TREE_COLLIDER::find_collision
void find_collision(BOX_SET_CLASS0 *boxset1, const btTransform &trans1, BOX_SET_CLASS1 *boxset2, const btTransform &trans2, gim_pair_set &collision_pairs, bool complete_primitive_tests=true)
Definition: gim_box_set.h:642
GIM_BOX_TREE_TEMPLATE_SET::m_primitive_manager
_GIM_PRIMITIVE_MANAGER_PROTOTYPE m_primitive_manager
Definition: gim_box_set.h:218
GIM_BOX_TREE_NODE::m_data
GUINT m_data
primitive index if apply
Definition: gim_box_set.h:116
GIM_TREE_TREE_COLLIDER::m_boxset0
BOX_SET_CLASS0 * m_boxset0
Definition: gim_box_set.h:467
GIM_BOX_TREE_SET
Class for Box Tree Sets.
Definition: gim_box_set.h:451
GIM_TREE_TREE_COLLIDER::GIM_TREE_TREE_COLLIDER
GIM_TREE_TREE_COLLIDER()
Definition: gim_box_set.h:488
GIM_BOX_TREE_NODE::m_right
GUINT m_right
Right subtree.
Definition: gim_box_set.h:114
GIM_BOX_TREE_TEMPLATE_SET::boxQuery
bool boxQuery(const GIM_AABB &box, gim_array< GUINT > &collided_results) const
returns the indices of the primitives in the m_primitive_manager
Definition: gim_box_set.h:303
GIM_BOX_TREE::getNodeBound
void getNodeBound(GUINT nodeindex, GIM_AABB &bound) const
Definition: gim_box_set.h:179
gim_pair_set::push_pair
void push_pair(GUINT index1, GUINT index2)
Definition: gim_box_set.h:72
GIM_BOX_TREE::getNodeData
GUINT getNodeData(GUINT nodeindex) const
Definition: gim_box_set.h:174
GIM_PAIR::GIM_PAIR
GIM_PAIR()
Definition: gim_box_set.h:49
GIM_TREE_TREE_COLLIDER::node_collision
bool node_collision(GUINT node0, GUINT node1)
Definition: gim_box_set.h:538
GIM_TREE_TREE_COLLIDER::t1_is_trimesh
bool t1_is_trimesh
Definition: gim_box_set.h:474
GIM_TREE_TREE_COLLIDER::m_boxset1
BOX_SET_CLASS1 * m_boxset1
Definition: gim_box_set.h:468
GIM_BOX_TREE_NODE::m_left
GUINT m_left
Left subtree.
Definition: gim_box_set.h:113
gim_array::pop_back
void pop_back()
Definition: gim_array.h:235
GIM_BOX_TREE_NODE::m_bound
GIM_AABB m_bound
Definition: gim_box_set.h:112
GIM_BOX_TREE::clearNodes
void clearNodes()
Definition: gim_box_set.h:156
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:166
GIM_BOX_TREE_TEMPLATE_SET::GIM_BOX_TREE_TEMPLATE_SET
GIM_BOX_TREE_TEMPLATE_SET()
Definition: gim_box_set.h:251
GIM_PAIR::GIM_PAIR
GIM_PAIR(GUINT index1, GUINT index2)
Definition: gim_box_set.h:58
GIM_PAIR::m_index2
int m_index2
Definition: btGImpactBvhStructs.h:37
G_UINT_INFINITY
#define G_UINT_INFINITY
A very very high value.
Definition: gim_math.h:57
gim_tri_collision.h
gim_array::back
T & back()
Definition: gim_array.h:198
GIM_BOX_TREE::getScapeNodeIndex
GUINT getScapeNodeIndex(GUINT nodeindex) const
Definition: gim_box_set.h:199
GIM_TREE_TREE_COLLIDER
GIM_BOX_SET collision methods.
Definition: gim_box_set.h:463
GIM_AABB_DATA
Definition: gim_box_set.h:103
GIM_BOX_TREE_TEMPLATE_SET::buildSet
void buildSet()
this rebuild the entire set
Definition: gim_box_set.h:287
GIM_BOX_TREE_TEMPLATE_SET::rayQuery
bool rayQuery(const btVector3 &ray_dir, const btVector3 &ray_origin, gim_array< GUINT > &collided_results) const
returns the indices of the primitives in the m_primitive_manager
Definition: gim_box_set.h:348
GIM_TRIANGLE::m_vertices
btVector3 m_vertices[3]
Definition: gim_tri_collision.h:130
SIMD_FORCE_INLINE
#define SIMD_FORCE_INLINE
Definition: btScalar.h:81
GIM_BOX_TREE_TEMPLATE_SET::getRightNodeIndex
GUINT getRightNodeIndex(GUINT nodeindex) const
Definition: gim_box_set.h:429
GIM_BOX_TREE_TEMPLATE_SET::getPrimitiveManager
const _GIM_PRIMITIVE_MANAGER_PROTOTYPE & getPrimitiveManager() const
Definition: gim_box_set.h:267
GIM_BOX_TREE_TEMPLATE_SET::getNodeBound
void getNodeBound(GUINT nodeindex, GIM_AABB &bound) const
Definition: gim_box_set.h:414
gim_radixsort.h
GIM_BOX_TREE_TEMPLATE_SET::getNodeCount
GUINT getNodeCount() const
node count
Definition: gim_box_set.h:398
GIM_AABB
Axis aligned box.
Definition: gim_box_collision.h:201
gim_array::resize
void resize(GUINT size, bool call_constructor=true, const T &fillData=T())
Definition: gim_array.h:288
GIM_BOX_TREE_TEMPLATE_SET::setPrimitiveManager
void setPrimitiveManager(const _GIM_PRIMITIVE_MANAGER_PROTOTYPE &primitive_manager)
Definition: gim_box_set.h:262
gim_pair_set
A pairset array.
Definition: gim_box_set.h:66
GIM_TREE_TREE_COLLIDER::current_node1
GUINT current_node1
Definition: gim_box_set.h:470
GIM_PRIMITIVE_MANAGER_PROTOTYPE::~GIM_PRIMITIVE_MANAGER_PROTOTYPE
virtual ~GIM_PRIMITIVE_MANAGER_PROTOTYPE()
Definition: gim_box_set.h:94
GIM_TREE_TREE_COLLIDER::retrieve_node0_triangle
void retrieve_node0_triangle(GUINT node0)
Definition: gim_box_set.h:494
GIM_BOX_TREE_TEMPLATE_SET::getPrimitiveManager
_GIM_PRIMITIVE_MANAGER_PROTOTYPE & getPrimitiveManager()
Definition: gim_box_set.h:272
GIM_BOX_TREE::m_num_nodes
GUINT m_num_nodes
Definition: gim_box_set.h:136
GIM_AABB::collide_ray
bool collide_ray(const btVector3 &vorigin, const btVector3 &vdir)
Finds the Ray intersection parameter.
Definition: gim_box_collision.h:409
gim_array::clear
void clear()
Definition: gim_array.h:111
gim_array::m_data
T * m_data
properties
Definition: gim_array.h:48
GIM_BOX_TREE_NODE::GIM_BOX_TREE_NODE
GIM_BOX_TREE_NODE()
Definition: gim_box_set.h:118
GIM_BOX_TREE::getNodeCount
GUINT getNodeCount() const
node count
Definition: gim_box_set.h:163
btVector4
Definition: btVector3.h:1089
GIM_TREE_TREE_COLLIDER::find_collision_pairs
void find_collision_pairs()
Definition: gim_box_set.h:579
GIM_BOX_TREE_TEMPLATE_SET::getLeftNodeIndex
GUINT getLeftNodeIndex(GUINT nodeindex) const
Definition: gim_box_set.h:424
GIM_AABB::has_collision
bool has_collision(const GIM_AABB &other) const
Definition: gim_box_collision.h:390
GIM_BOX_TREE_NODE::m_escapeIndex
GUINT m_escapeIndex
Scape index for traversing.
Definition: gim_box_set.h:115
GIM_BOX_TREE_TEMPLATE_SET::m_box_tree
_GIM_BOX_TREE_PROTOTYPE m_box_tree
Definition: gim_box_set.h:219
GIM_BOX_TREE_TEMPLATE_SET::getNodeTriangle
void getNodeTriangle(GUINT nodeindex, GIM_TRIANGLE &triangle) const
Definition: gim_box_set.h:439
GIM_TRIANGLE
Class for colliding triangles.
Definition: gim_tri_collision.h:126
GIM_BOX_TREE_TEMPLATE_SET::update
void update()
node manager prototype functions
Definition: gim_box_set.h:281
GIM_TRIANGLE::get_plane
void get_plane(btVector4 &plane) const
Definition: gim_tri_collision.h:146
GIM_BOX_TREE::GIM_BOX_TREE
GIM_BOX_TREE()
Definition: gim_box_set.h:147
GIM_BOX_TREE::getRightNodeIndex
GUINT getRightNodeIndex(GUINT nodeindex) const
Definition: gim_box_set.h:194
GIM_TREE_TREE_COLLIDER::node0_has_triangle
bool node0_has_triangle
Definition: gim_box_set.h:475
GIM_TREE_TREE_COLLIDER::retrieve_node1_info
void retrieve_node1_info(GUINT node1)
Definition: gim_box_set.h:529
gim_array
Very simple array container with fast access and simd memory.
Definition: gim_array.h:43
GIM_BOX_TREE_TEMPLATE_SET::refit
void refit()
Definition: gim_box_set.h:222
GIM_BOX_TREE_TEMPLATE_SET::setNodeBound
void setNodeBound(GUINT nodeindex, const GIM_AABB &bound)
Definition: gim_box_set.h:419
GIM_BOX_TREE_NODE::is_leaf_node
bool is_leaf_node() const
Definition: gim_box_set.h:126
GIM_TREE_TREE_COLLIDER::m_tri1_plane
btVector4 m_tri1_plane
Definition: gim_box_set.h:484
GIM_TREE_TREE_COLLIDER::m_tri0_plane
btVector4 m_tri0_plane
Definition: gim_box_set.h:482
GIM_AABB_DATA::m_bound
GIM_AABB m_bound
Definition: gim_box_set.h:105
GIM_BOX_TREE_TEMPLATE_SET::isTrimesh
bool isTrimesh() const
tells if this set is a trimesh
Definition: gim_box_set.h:392
gim_array::size
GUINT size() const
Definition: gim_array.h:144
gim_array.h
GIM_PAIR::m_index2
GUINT m_index2
Definition: gim_box_set.h:48
GIM_BOX_TREE
Basic Box tree structure.
Definition: gim_box_set.h:133
GIM_TREE_TREE_COLLIDER::node1_has_triangle
bool node1_has_triangle
Definition: gim_box_set.h:476
GIM_TREE_TREE_COLLIDER::trans_cache_1to0
GIM_BOX_BOX_TRANSFORM_CACHE trans_cache_1to0
Definition: gim_box_set.h:479
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:83
GIM_BOX_TREE_TEMPLATE_SET::getNodeData
GUINT getNodeData(GUINT nodeindex) const
Definition: gim_box_set.h:409
GIM_AABB_DATA::m_data
GUINT m_data
Definition: gim_box_set.h:106
gim_box_collision.h
gim_pair_set::push_pair_inv
void push_pair_inv(GUINT index1, GUINT index2)
Definition: gim_box_set.h:77
GIM_TREE_TREE_COLLIDER::node0_is_leaf
bool node0_is_leaf
Definition: gim_box_set.h:471
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:468
btTransform
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
GIM_BOX_TREE_TEMPLATE_SET::getScapeNodeIndex
GUINT getScapeNodeIndex(GUINT nodeindex) const
Definition: gim_box_set.h:434
GIM_TREE_TREE_COLLIDER::retrieve_node0_info
void retrieve_node0_info(GUINT node0)
Definition: gim_box_set.h:520
GIM_BOX_TREE_TEMPLATE_SET::boxQueryTrans
bool boxQueryTrans(const GIM_AABB &box, const btTransform &transform, gim_array< GUINT > &collided_results) const
returns the indices of the primitives in the m_primitive_manager
Definition: gim_box_set.h:339
GIM_TREE_TREE_COLLIDER::m_box1
GIM_AABB m_box1
Definition: gim_box_set.h:478
GIM_TREE_TREE_COLLIDER::m_collision_pairs
gim_pair_set * m_collision_pairs
Definition: gim_box_set.h:466
GIM_PAIR::GIM_PAIR
GIM_PAIR(const GIM_PAIR &p)
Definition: gim_box_set.h:52
GIM_PAIR::m_index1
GUINT m_index1
Definition: gim_box_set.h:47
GIM_BOX_BOX_TRANSFORM_CACHE
Class for transforming a model1 to the space of model0.
Definition: gim_box_collision.h:138
GIM_TREE_TREE_COLLIDER::node1_is_leaf
bool node1_is_leaf
Definition: gim_box_set.h:472
GIM_AABB::appy_transform
void appy_transform(const btTransform &trans)
Apply a transform to an AABB.
Definition: gim_box_collision.h:330
GIM_BOX_TREE_TEMPLATE_SET::isLeafNode
bool isLeafNode(GUINT nodeindex) const
tells if the node is a leaf
Definition: gim_box_set.h:404
gim_pair_set::gim_pair_set
gim_pair_set()
Definition: gim_box_set.h:69
GIM_PAIR
Overlapping pair.
Definition: btGImpactBvhStructs.h:34
GIM_BOX_TREE::getLeftNodeIndex
GUINT getLeftNodeIndex(GUINT nodeindex) const
Definition: gim_box_set.h:189
GIM_TREE_TREE_COLLIDER::retrieve_node1_triangle
void retrieve_node1_triangle(GUINT node1)
Definition: gim_box_set.h:507
GIM_BOX_TREE::setNodeBound
void setNodeBound(GUINT nodeindex, const GIM_AABB &bound)
Definition: gim_box_set.h:184
GUINT
#define GUINT
Definition: gim_math.h:42
GIM_BOX_TREE_TEMPLATE_SET
Generic Box Tree Template.
Definition: gim_box_set.h:215
GIM_BOX_TREE::isLeafNode
bool isLeafNode(GUINT nodeindex) const
tells if the node is a leaf
Definition: gim_box_set.h:169
GIM_BOX_TREE::m_node_array
gim_array< GIM_BOX_TREE_NODE > m_node_array
Definition: gim_box_set.h:137
GIM_TREE_TREE_COLLIDER::m_box0
GIM_AABB m_box0
Definition: gim_box_set.h:477
GIM_PRIMITIVE_MANAGER_PROTOTYPE
Prototype Base class for primitive classification.
Definition: gim_box_set.h:90
GIM_BOX_TREE_TEMPLATE_SET::hasHierarchy
bool hasHierarchy() const
tells if this set has hierarcht
Definition: gim_box_set.h:386
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:530
GIM_BOX_BOX_TRANSFORM_CACHE::transform
btVector3 transform(const btVector3 &point)
Definition: gim_box_collision.h:190
GIM_TREE_TREE_COLLIDER::m_tri0
GIM_TRIANGLE m_tri0
Definition: gim_box_set.h:481
GIM_BOX_TREE_NODE
Node Structure for trees.
Definition: gim_box_set.h:110
GIM_TRIANGLE::m_margin
btScalar m_margin
Definition: gim_tri_collision.h:129
GIM_TREE_TREE_COLLIDER::m_tri1
GIM_TRIANGLE m_tri1
Definition: gim_box_set.h:483
GIM_TREE_TREE_COLLIDER::current_node0
GUINT current_node0
Definition: gim_box_set.h:469
gim_array::reserve
bool reserve(GUINT size)
public operations
Definition: gim_array.h:97
btTransform::inverse
btTransform inverse() const
Return the inverse of this transform.
Definition: btTransform.h:188
GIM_TREE_TREE_COLLIDER::t0_is_trimesh
bool t0_is_trimesh
Definition: gim_box_set.h:473
gim_array::push_back
void push_back(const T &obj)
Definition: gim_array.h:214
GIM_TREE_TREE_COLLIDER::trans_cache_0to1
btTransform trans_cache_0to1
Definition: gim_box_set.h:480
GIM_AABB::increment_margin
void increment_margin(btScalar margin)
Definition: gim_box_collision.h:271
GIM_AABB::merge
void merge(const GIM_AABB &box)
Merges a Box.
Definition: gim_box_collision.h:346
GIM_BOX_TREE_TEMPLATE_SET::getGlobalBox
GIM_AABB getGlobalBox() const
Definition: gim_box_set.h:255
GIM_PAIR::m_index1
int m_index1
Definition: btGImpactBvhStructs.h:36