27 #ifdef TRI_COLLISION_PROFILING 31 float g_q_accum_tree_collision_time = 0;
32 int g_q_count_traversing = 0;
35 void bt_begin_gim02_q_tree_time()
37 g_q_tree_clock.
reset();
40 void bt_end_gim02_q_tree_time()
43 g_q_count_traversing++;
48 float btGImpactQuantizedBvh::getAverageTreeCollisionTime()
50 if(g_q_count_traversing == 0)
return 0;
52 float avgtime = g_q_accum_tree_collision_time;
53 avgtime /= (float)g_q_count_traversing;
55 g_q_accum_tree_collision_time = 0;
56 g_q_count_traversing = 0;
65 #endif //TRI_COLLISION_PROFILING 76 for (
int i=0;i<primitive_boxes.
size() ;i++ )
78 global_bound.
merge(primitive_boxes[i].m_bound);
82 m_global_bound.m_min,m_global_bound.m_max,m_bvhQuantization,global_bound.
m_min,global_bound.
m_max,boundMargin);
96 int numIndices = endIndex-startIndex;
98 for (i=startIndex;i<endIndex;i++)
101 primitive_boxes[i].m_bound.m_min);
106 for (i=startIndex;i<endIndex;i++)
109 primitive_boxes[i].m_bound.m_min);
111 diff2 = diff2 * diff2;
122 int endIndex,
int splitAxis)
125 int splitIndex =startIndex;
126 int numIndices = endIndex - startIndex;
132 for (i=startIndex;i<endIndex;i++)
135 primitive_boxes[i].m_bound.m_min);
140 splitValue = means[splitAxis];
144 for (i=startIndex;i<endIndex;i++)
147 primitive_boxes[i].m_bound.m_min);
148 if (center[splitAxis] > splitValue)
151 primitive_boxes.
swap(i,splitIndex);
166 int rangeBalancedIndices = numIndices/3;
167 bool unbalanced = ((splitIndex<=(startIndex+rangeBalancedIndices)) || (splitIndex >=(endIndex-1-rangeBalancedIndices)));
171 splitIndex = startIndex+ (numIndices>>1);
174 btAssert(!((splitIndex==startIndex) || (splitIndex == (endIndex))));
183 int curIndex = m_num_nodes;
188 if ((endIndex-startIndex)==1)
191 setNodeBound(curIndex,primitive_boxes[startIndex].m_bound);
192 m_node_array[curIndex].setDataIndex(primitive_boxes[startIndex].m_data);
199 int splitIndex = _calc_splitting_axis(primitive_boxes,startIndex,endIndex);
201 splitIndex = _sort_and_calc_splitting_index(
202 primitive_boxes,startIndex,endIndex,
212 for (
int i=startIndex;i<endIndex;i++)
214 node_bound.
merge(primitive_boxes[i].m_bound);
221 _build_sub_tree(primitive_boxes, startIndex, splitIndex );
225 _build_sub_tree(primitive_boxes, splitIndex ,endIndex);
227 m_node_array[curIndex].setEscapeIndex(m_num_nodes - curIndex);
236 calc_quantization(primitive_boxes);
240 m_node_array.resize(primitive_boxes.
size()*2);
242 _build_sub_tree(primitive_boxes, 0, primitive_boxes.
size());
271 bound.
merge(temp_box);
278 bound.
merge(temp_box);
293 for (
int i = 0;i<primitive_boxes.
size() ;i++ )
296 primitive_boxes[i].m_data = i;
310 unsigned short quantizedMin[3];
311 unsigned short quantizedMax[3];
317 while (curIndex < numNodes)
325 if (isleafnode && aabbOverlap)
330 if (aabbOverlap || isleafnode)
341 if(collided_results.
size()>0)
return true;
355 while (curIndex < numNodes)
362 bool aabbOverlap = bound.
collide_ray(ray_origin,ray_dir);
365 if (isleafnode && aabbOverlap)
370 if (aabbOverlap || isleafnode)
381 if(collided_results.
size()>0)
return true;
389 int node0 ,
int node1,
bool complete_primitive_tests)
408 int node0,
int node1,
bool complete_primitive_tests)
414 boxset0,boxset1,trans_cache_1to0,
415 node0,node1,complete_primitive_tests) ==
false)
return;
433 collision_pairs,trans_cache_1to0,
439 collision_pairs,trans_cache_1to0,
453 collision_pairs,trans_cache_1to0,
461 collision_pairs,trans_cache_1to0,
474 collision_pairs,trans_cache_1to0,
481 collision_pairs,trans_cache_1to0,
489 collision_pairs,trans_cache_1to0,
496 collision_pairs,trans_cache_1to0,
515 #ifdef TRI_COLLISION_PROFILING 516 bt_begin_gim02_q_tree_time();
517 #endif //TRI_COLLISION_PROFILING 521 &collision_pairs,trans_cache_1to0,0,0,
true);
522 #ifdef TRI_COLLISION_PROFILING 523 bt_end_gim02_q_tree_time();
524 #endif //TRI_COLLISION_PROFILING void build_tree(GIM_BVH_DATA_ARRAY &primitive_boxes)
prototype functions for box tree management
void push_back(const T &_Val)
void calc_quantization(GIM_BVH_DATA_ARRAY &primitive_boxes, btScalar boundMargin=btScalar(1.0))
int _calc_splitting_axis(GIM_BVH_DATA_ARRAY &primitive_boxes, int startIndex, int endIndex)
bool rayQuery(const btVector3 &ray_dir, const btVector3 &ray_origin, btAlignedObjectArray< int > &collided_results) const
returns the indices of the primitives in the m_primitive_manager
virtual int get_primitive_count() const =0
int getNodeData(int nodeindex) const
bool overlapping_trans_cache(const btAABB &box, const BT_BOX_BOX_TRANSFORM_CACHE &transcache, bool fulltest) const
transcache is the transformation cache from box to this AABB
bool testQuantizedBoxOverlapp(int node_index, unsigned short *quantizedMin, unsigned short *quantizedMax) const
unsigned long int getTimeMicroseconds()
Returns the time in us since the last call to reset or since the Clock was created.
The btClock is a portable basic clock that measures accurate time in seconds, use for profiling...
#define SIMD_FORCE_INLINE
void reset()
Resets the initial reference time.
void merge(const btAABB &box)
Merges a Box.
int getEscapeNodeIndex(int nodeindex) const
btQuantizedBvhTree m_box_tree
void swap(int index0, int index1)
void push_pair(int index1, int index2)
bool boxQuery(const btAABB &box, btAlignedObjectArray< int > &collided_results) const
returns the indices of the primitives in the m_primitive_manager
void setNodeBound(int nodeindex, const btAABB &bound)
bool isLeafNode(int nodeindex) const
tells if the node is a leaf
static void _find_quantized_collision_pairs_recursive(const btGImpactQuantizedBvh *boxset0, const btGImpactQuantizedBvh *boxset1, btPairSet *collision_pairs, const BT_BOX_BOX_TRANSFORM_CACHE &trans_cache_1to0, int node0, int node1, bool complete_primitive_tests)
void quantizePoint(unsigned short *quantizedpoint, const btVector3 &point) const
virtual void get_primitive_box(int prim_index, btAABB &primbox) const =0
int getNodeCount() const
node count
btVector3 can be used to represent 3D points and vectors.
bool collide_ray(const btVector3 &vorigin, const btVector3 &vdir) const
Finds the Ray intersection parameter.
int size() const
return the number of elements in the array
void getNodeBound(int nodeindex, btAABB &bound) const
void bt_calc_quantization_parameters(btVector3 &outMinBound, btVector3 &outMaxBound, btVector3 &bvhQuantization, const btVector3 &srcMinBound, const btVector3 &srcMaxBound, btScalar quantizationMargin)
int getLeftNode(int nodeindex) const
void resize(int newsize, const T &fillData=T())
btPrimitiveManagerBase * m_primitive_manager
bool _quantized_node_collision(const btGImpactQuantizedBvh *boxset0, const btGImpactQuantizedBvh *boxset1, const BT_BOX_BOX_TRANSFORM_CACHE &trans_cache_1to0, int node0, int node1, bool complete_primitive_tests)
int getRightNode(int nodeindex) const
int maxAxis() const
Return the axis with the largest value Note return values are 0,1,2 for x, y, or z.
int _sort_and_calc_splitting_index(GIM_BVH_DATA_ARRAY &primitive_boxes, int startIndex, int endIndex, int splitAxis)
static void find_collision(const btGImpactQuantizedBvh *boxset1, const btTransform &trans1, const btGImpactQuantizedBvh *boxset2, const btTransform &trans2, btPairSet &collision_pairs)
Structure for containing Boxes.
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
void buildSet()
this rebuild the entire set
void _build_sub_tree(GIM_BVH_DATA_ARRAY &primitive_boxes, int startIndex, int endIndex)