Bullet Collision Detection & Physics Library
btGImpactQuantizedBvh.h
Go to the documentation of this file.
1#ifndef GIM_QUANTIZED_SET_H_INCLUDED
2#define GIM_QUANTIZED_SET_H_INCLUDED
3
7/*
8This source file is part of GIMPACT Library.
9
10For the latest info, see http://gimpact.sourceforge.net/
11
12Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
13email: projectileman@yahoo.com
14
15
16This software is provided 'as-is', without any express or implied warranty.
17In no event will the authors be held liable for any damages arising from the use of this software.
18Permission is granted to anyone to use this software for any purpose,
19including commercial applications, and to alter it and redistribute it freely,
20subject to the following restrictions:
21
221. 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.
232. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
243. This notice may not be removed or altered from any source distribution.
25*/
26
27#include "btGImpactBvh.h"
28#include "btQuantization.h"
30
31class GIM_QUANTIZED_BVH_NODE_ARRAY:public btAlignedObjectArray<BT_QUANTIZED_BVH_NODE>
32{
33};
34
35
36
37
40{
41protected:
46protected:
47 void calc_quantization(GIM_BVH_DATA_ARRAY & primitive_boxes, btScalar boundMargin = btScalar(1.0) );
48
50 GIM_BVH_DATA_ARRAY & primitive_boxes,
51 int startIndex, int endIndex, int splitAxis);
52
53 int _calc_splitting_axis(GIM_BVH_DATA_ARRAY & primitive_boxes, int startIndex, int endIndex);
54
55 void _build_sub_tree(GIM_BVH_DATA_ARRAY & primitive_boxes, int startIndex, int endIndex);
56public:
58 {
59 m_num_nodes = 0;
60 }
61
64 void build_tree(GIM_BVH_DATA_ARRAY & primitive_boxes);
65
67 unsigned short * quantizedpoint, const btVector3 & point) const
68 {
70 }
71
72
74 int node_index,
75 unsigned short * quantizedMin,unsigned short * quantizedMax) const
76 {
77 return m_node_array[node_index].testQuantizedBoxOverlapp(quantizedMin,quantizedMax);
78 }
79
81 {
83 m_num_nodes = 0;
84 }
85
88 {
89 return m_num_nodes;
90 }
91
93 SIMD_FORCE_INLINE bool isLeafNode(int nodeindex) const
94 {
95 return m_node_array[nodeindex].isLeafNode();
96 }
97
98 SIMD_FORCE_INLINE int getNodeData(int nodeindex) const
99 {
100 return m_node_array[nodeindex].getDataIndex();
101 }
102
103 SIMD_FORCE_INLINE void getNodeBound(int nodeindex, btAABB & bound) const
104 {
105 bound.m_min = bt_unquantize(
106 m_node_array[nodeindex].m_quantizedAabbMin,
108
109 bound.m_max = bt_unquantize(
110 m_node_array[nodeindex].m_quantizedAabbMax,
112 }
113
114 SIMD_FORCE_INLINE void setNodeBound(int nodeindex, const btAABB & bound)
115 {
116 bt_quantize_clamp( m_node_array[nodeindex].m_quantizedAabbMin,
117 bound.m_min,
121
122 bt_quantize_clamp( m_node_array[nodeindex].m_quantizedAabbMax,
123 bound.m_max,
127 }
128
129 SIMD_FORCE_INLINE int getLeftNode(int nodeindex) const
130 {
131 return nodeindex+1;
132 }
133
134 SIMD_FORCE_INLINE int getRightNode(int nodeindex) const
135 {
136 if(m_node_array[nodeindex+1].isLeafNode()) return nodeindex+2;
137 return nodeindex+1 + m_node_array[nodeindex+1].getEscapeIndex();
138 }
139
140 SIMD_FORCE_INLINE int getEscapeNodeIndex(int nodeindex) const
141 {
142 return m_node_array[nodeindex].getEscapeIndex();
143 }
144
146 {
147 return &m_node_array[index];
148 }
149
151};
152
153
154
156
161{
162protected:
165
166protected:
167 //stackless refit
168 void refit();
169public:
170
173 {
174 m_primitive_manager = NULL;
175 }
176
179 {
180 m_primitive_manager = primitive_manager;
181 }
182
184 {
185 btAABB totalbox;
186 getNodeBound(0, totalbox);
187 return totalbox;
188 }
189
191 {
192 m_primitive_manager = primitive_manager;
193 }
194
196 {
197 return m_primitive_manager;
198 }
199
200
203
206 {
207 refit();
208 }
209
211 void buildSet();
212
214 bool boxQuery(const btAABB & box, btAlignedObjectArray<int> & collided_results) const;
215
218 const btTransform & transform, btAlignedObjectArray<int> & collided_results) const
219 {
220 btAABB transbox=box;
221 transbox.appy_transform(transform);
222 return boxQuery(transbox,collided_results);
223 }
224
226 bool rayQuery(
227 const btVector3 & ray_dir,const btVector3 & ray_origin ,
228 btAlignedObjectArray<int> & collided_results) const;
229
232 {
233 return true;
234 }
235
238 {
240 }
241
244 {
245 return m_box_tree.getNodeCount();
246 }
247
249 SIMD_FORCE_INLINE bool isLeafNode(int nodeindex) const
250 {
251 return m_box_tree.isLeafNode(nodeindex);
252 }
253
254 SIMD_FORCE_INLINE int getNodeData(int nodeindex) const
255 {
256 return m_box_tree.getNodeData(nodeindex);
257 }
258
259 SIMD_FORCE_INLINE void getNodeBound(int nodeindex, btAABB & bound) const
260 {
261 m_box_tree.getNodeBound(nodeindex, bound);
262 }
263
264 SIMD_FORCE_INLINE void setNodeBound(int nodeindex, const btAABB & bound)
265 {
266 m_box_tree.setNodeBound(nodeindex, bound);
267 }
268
269
270 SIMD_FORCE_INLINE int getLeftNode(int nodeindex) const
271 {
272 return m_box_tree.getLeftNode(nodeindex);
273 }
274
275 SIMD_FORCE_INLINE int getRightNode(int nodeindex) const
276 {
277 return m_box_tree.getRightNode(nodeindex);
278 }
279
280 SIMD_FORCE_INLINE int getEscapeNodeIndex(int nodeindex) const
281 {
282 return m_box_tree.getEscapeNodeIndex(nodeindex);
283 }
284
285 SIMD_FORCE_INLINE void getNodeTriangle(int nodeindex,btPrimitiveTriangle & triangle) const
286 {
288 }
289
290
292 {
293 return m_box_tree.get_node_pointer(index);
294 }
295
296#ifdef TRI_COLLISION_PROFILING
297 static float getAverageTreeCollisionTime();
298#endif //TRI_COLLISION_PROFILING
299
300 static void find_collision(const btGImpactQuantizedBvh * boxset1, const btTransform & trans1,
301 const btGImpactQuantizedBvh * boxset2, const btTransform & trans2,
302 btPairSet & collision_pairs);
303};
304
305#endif // GIM_BOXPRUNING_H_INCLUDED
void bt_quantize_clamp(unsigned short *out, const btVector3 &point, const btVector3 &min_bound, const btVector3 &max_bound, const btVector3 &bvhQuantization)
btVector3 bt_unquantize(const unsigned short *vecIn, const btVector3 &offset, const btVector3 &bvhQuantization)
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition: btScalar.h:292
#define SIMD_FORCE_INLINE
Definition: btScalar.h:81
Axis aligned box.
btVector3 m_min
btVector3 m_max
void appy_transform(const btTransform &trans)
Apply a transform to an AABB.
The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It...
void clear()
clear the array, deallocated memory. Generally it is better to use array.resize(0),...
Structure for containing Boxes.
int getNodeData(int nodeindex) const
bool boxQueryTrans(const btAABB &box, const btTransform &transform, btAlignedObjectArray< int > &collided_results) const
returns the indices of the primitives in the m_primitive_manager
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
btPrimitiveManagerBase * m_primitive_manager
btPrimitiveManagerBase * getPrimitiveManager() const
void buildSet()
this rebuild the entire set
btGImpactQuantizedBvh()
this constructor doesn't build the tree. you must call buildSet
bool boxQuery(const btAABB &box, btAlignedObjectArray< int > &collided_results) const
returns the indices of the primitives in the m_primitive_manager
bool isLeafNode(int nodeindex) const
tells if the node is a leaf
btGImpactQuantizedBvh(btPrimitiveManagerBase *primitive_manager)
this constructor doesn't build the tree. you must call buildSet
void getNodeTriangle(int nodeindex, btPrimitiveTriangle &triangle) const
btQuantizedBvhTree m_box_tree
void setNodeBound(int nodeindex, const btAABB &bound)
int getNodeCount() const
node count
int getRightNode(int nodeindex) const
void update()
node manager prototype functions
void setPrimitiveManager(btPrimitiveManagerBase *primitive_manager)
const BT_QUANTIZED_BVH_NODE * get_node_pointer(int index=0) const
int getEscapeNodeIndex(int nodeindex) const
bool isTrimesh() const
tells if this set is a trimesh
void getNodeBound(int nodeindex, btAABB &bound) const
int getLeftNode(int nodeindex) const
static void find_collision(const btGImpactQuantizedBvh *boxset1, const btTransform &trans1, const btGImpactQuantizedBvh *boxset2, const btTransform &trans2, btPairSet &collision_pairs)
bool hasHierarchy() const
tells if this set has hierarcht
A pairset array.
Definition: btGImpactBvh.h:36
Prototype Base class for primitive classification.
Definition: btGImpactBvh.h:154
virtual void get_primitive_triangle(int prim_index, btPrimitiveTriangle &triangle) const =0
retrieves only the points of the triangle, and the collision margin
virtual bool is_trimesh() const =0
determines if this manager consist on only triangles, which special case will be optimized
Basic Box tree structure.
void setNodeBound(int nodeindex, const btAABB &bound)
const BT_QUANTIZED_BVH_NODE * get_node_pointer(int index=0) const
void getNodeBound(int nodeindex, btAABB &bound) const
int getRightNode(int nodeindex) const
bool isLeafNode(int nodeindex) const
tells if the node is a leaf
void _build_sub_tree(GIM_BVH_DATA_ARRAY &primitive_boxes, int startIndex, int endIndex)
void quantizePoint(unsigned short *quantizedpoint, const btVector3 &point) const
int getNodeCount() const
node count
void calc_quantization(GIM_BVH_DATA_ARRAY &primitive_boxes, btScalar boundMargin=btScalar(1.0))
void build_tree(GIM_BVH_DATA_ARRAY &primitive_boxes)
prototype functions for box tree management
int getEscapeNodeIndex(int nodeindex) const
GIM_QUANTIZED_BVH_NODE_ARRAY m_node_array
int _sort_and_calc_splitting_index(GIM_BVH_DATA_ARRAY &primitive_boxes, int startIndex, int endIndex, int splitAxis)
int getNodeData(int nodeindex) const
int _calc_splitting_axis(GIM_BVH_DATA_ARRAY &primitive_boxes, int startIndex, int endIndex)
bool testQuantizedBoxOverlapp(int node_index, unsigned short *quantizedMin, unsigned short *quantizedMax) const
int getLeftNode(int nodeindex) const
The btTransform class supports rigid transforms with only translation and rotation and no scaling/she...
Definition: btTransform.h:34
btVector3 can be used to represent 3D points and vectors.
Definition: btVector3.h:84
btQuantizedBvhNode is a compressed aabb node, 16 bytes.