dali-physics/third-party/bullet3/src/BulletCollision/Gimpact/btGImpactQuantizedBvh.h

   1 #ifndef GIM_QUANTIZED_SET_H_INCLUDED
   2 #define GIM_QUANTIZED_SET_H_INCLUDED
   3
   4 /*! \file btGImpactQuantizedBvh.h
   5 \author Francisco Leon Najera
   6 */
   7 /*
   8 This source file is part of GIMPACT Library.
   9
  10 For the latest info, see http://gimpact.sourceforge.net/
  11
  12 Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
  13 email: projectileman@yahoo.com
  14
  15
  16 This software is provided 'as-is', without any express or implied warranty.
  17 In no event will the authors be held liable for any damages arising from the use of this software.
  18 Permission is granted to anyone to use this software for any purpose,
  19 including commercial applications, and to alter it and redistribute it freely,
  20 subject to the following restrictions:
  21
  22 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.
  23 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
  24 3. This notice may not be removed or altered from any source distribution.
  25 */
  26
  27 #include "btGImpactBvh.h"
  28 #include "btQuantization.h"
  29 #include "btGImpactQuantizedBvhStructs.h"
  30
  31 class GIM_QUANTIZED_BVH_NODE_ARRAY : public btAlignedObjectArray<BT_QUANTIZED_BVH_NODE>
  32 {
  33 };
  34
  35 //! Basic Box tree structure
  36 class btQuantizedBvhTree
  37 {
  38 protected:
  39         int m_num_nodes;
  40         GIM_QUANTIZED_BVH_NODE_ARRAY m_node_array;
  41         btAABB m_global_bound;
  42         btVector3 m_bvhQuantization;
  43
  44 protected:
  45         void calc_quantization(GIM_BVH_DATA_ARRAY& primitive_boxes, btScalar boundMargin = btScalar(1.0));
  46
  47         int _sort_and_calc_splitting_index(
  48                 GIM_BVH_DATA_ARRAY& primitive_boxes,
  49                 int startIndex, int endIndex, int splitAxis);
  50
  51         int _calc_splitting_axis(GIM_BVH_DATA_ARRAY& primitive_boxes, int startIndex, int endIndex);
  52
  53         void _build_sub_tree(GIM_BVH_DATA_ARRAY& primitive_boxes, int startIndex, int endIndex);
  54
  55 public:
  56         btQuantizedBvhTree()
  57         {
  58                 m_num_nodes = 0;
  59         }
  60
  61         //! prototype functions for box tree management
  62         //!@{
  63         void build_tree(GIM_BVH_DATA_ARRAY& primitive_boxes);
  64
  65         SIMD_FORCE_INLINE void quantizePoint(
  66                 unsigned short* quantizedpoint, const btVector3& point) const
  67         {
  68                 bt_quantize_clamp(quantizedpoint, point, m_global_bound.m_min, m_global_bound.m_max, m_bvhQuantization);
  69         }
  70
  71         SIMD_FORCE_INLINE bool testQuantizedBoxOverlapp(
  72                 int node_index,
  73                 unsigned short* quantizedMin, unsigned short* quantizedMax) const
  74         {
  75                 return m_node_array[node_index].testQuantizedBoxOverlapp(quantizedMin, quantizedMax);
  76         }
  77
  78         SIMD_FORCE_INLINE void clearNodes()
  79         {
  80                 m_node_array.clear();
  81                 m_num_nodes = 0;
  82         }
  83
  84         //! node count
  85         SIMD_FORCE_INLINE int getNodeCount() const
  86         {
  87                 return m_num_nodes;
  88         }
  89
  90         //! tells if the node is a leaf
  91         SIMD_FORCE_INLINE bool isLeafNode(int nodeindex) const
  92         {
  93                 return m_node_array[nodeindex].isLeafNode();
  94         }
  95
  96         SIMD_FORCE_INLINE int getNodeData(int nodeindex) const
  97         {
  98                 return m_node_array[nodeindex].getDataIndex();
  99         }
 100
 101         SIMD_FORCE_INLINE void getNodeBound(int nodeindex, btAABB& bound) const
 102         {
 103                 bound.m_min = bt_unquantize(
 104                         m_node_array[nodeindex].m_quantizedAabbMin,
 105                         m_global_bound.m_min, m_bvhQuantization);
 106
 107                 bound.m_max = bt_unquantize(
 108                         m_node_array[nodeindex].m_quantizedAabbMax,
 109                         m_global_bound.m_min, m_bvhQuantization);
 110         }
 111
 112         SIMD_FORCE_INLINE void setNodeBound(int nodeindex, const btAABB& bound)
 113         {
 114                 bt_quantize_clamp(m_node_array[nodeindex].m_quantizedAabbMin,
 115                                                   bound.m_min,
 116                                                   m_global_bound.m_min,
 117                                                   m_global_bound.m_max,
 118                                                   m_bvhQuantization);
 119
 120                 bt_quantize_clamp(m_node_array[nodeindex].m_quantizedAabbMax,
 121                                                   bound.m_max,
 122                                                   m_global_bound.m_min,
 123                                                   m_global_bound.m_max,
 124                                                   m_bvhQuantization);
 125         }
 126
 127         SIMD_FORCE_INLINE int getLeftNode(int nodeindex) const
 128         {
 129                 return nodeindex + 1;
 130         }
 131
 132         SIMD_FORCE_INLINE int getRightNode(int nodeindex) const
 133         {
 134                 if (m_node_array[nodeindex + 1].isLeafNode()) return nodeindex + 2;
 135                 return nodeindex + 1 + m_node_array[nodeindex + 1].getEscapeIndex();
 136         }
 137
 138         SIMD_FORCE_INLINE int getEscapeNodeIndex(int nodeindex) const
 139         {
 140                 return m_node_array[nodeindex].getEscapeIndex();
 141         }
 142
 143         SIMD_FORCE_INLINE const BT_QUANTIZED_BVH_NODE* get_node_pointer(int index = 0) const
 144         {
 145                 return &m_node_array[index];
 146         }
 147
 148         //!@}
 149 };
 150
 151 //! Structure for containing Boxes
 152 /*!
 153 This class offers an structure for managing a box tree of primitives.
 154 Requires a Primitive prototype (like btPrimitiveManagerBase )
 155 */
 156 class btGImpactQuantizedBvh
 157 {
 158 protected:
 159         btQuantizedBvhTree m_box_tree;
 160         btPrimitiveManagerBase* m_primitive_manager;
 161
 162 protected:
 163         //stackless refit
 164         void refit();
 165
 166 public:
 167         //! this constructor doesn't build the tree. you must call      buildSet
 168         btGImpactQuantizedBvh()
 169         {
 170                 m_primitive_manager = NULL;
 171         }
 172
 173         //! this constructor doesn't build the tree. you must call      buildSet
 174         btGImpactQuantizedBvh(btPrimitiveManagerBase* primitive_manager)
 175         {
 176                 m_primitive_manager = primitive_manager;
 177         }
 178
 179         SIMD_FORCE_INLINE btAABB getGlobalBox() const
 180         {
 181                 btAABB totalbox;
 182                 getNodeBound(0, totalbox);
 183                 return totalbox;
 184         }
 185
 186         SIMD_FORCE_INLINE void setPrimitiveManager(btPrimitiveManagerBase* primitive_manager)
 187         {
 188                 m_primitive_manager = primitive_manager;
 189         }
 190
 191         SIMD_FORCE_INLINE btPrimitiveManagerBase* getPrimitiveManager() const
 192         {
 193                 return m_primitive_manager;
 194         }
 195
 196         //! node manager prototype functions
 197         ///@{
 198
 199         //! this attemps to refit the box set.
 200         SIMD_FORCE_INLINE void update()
 201         {
 202                 refit();
 203         }
 204
 205         //! this rebuild the entire set
 206         void buildSet();
 207
 208         //! returns the indices of the primitives in the m_primitive_manager
 209         bool boxQuery(const btAABB& box, btAlignedObjectArray<int>& collided_results) const;
 210
 211         //! returns the indices of the primitives in the m_primitive_manager
 212         SIMD_FORCE_INLINE bool boxQueryTrans(const btAABB& box,
 213                                                                                  const btTransform& transform, btAlignedObjectArray<int>& collided_results) const
 214         {
 215                 btAABB transbox = box;
 216                 transbox.appy_transform(transform);
 217                 return boxQuery(transbox, collided_results);
 218         }
 219
 220         //! returns the indices of the primitives in the m_primitive_manager
 221         bool rayQuery(
 222                 const btVector3& ray_dir, const btVector3& ray_origin,
 223                 btAlignedObjectArray<int>& collided_results) const;
 224
 225         //! tells if this set has hierarcht
 226         SIMD_FORCE_INLINE bool hasHierarchy() const
 227         {
 228                 return true;
 229         }
 230
 231         //! tells if this set is a trimesh
 232         SIMD_FORCE_INLINE bool isTrimesh() const
 233         {
 234                 return m_primitive_manager->is_trimesh();
 235         }
 236
 237         //! node count
 238         SIMD_FORCE_INLINE int getNodeCount() const
 239         {
 240                 return m_box_tree.getNodeCount();
 241         }
 242
 243         //! tells if the node is a leaf
 244         SIMD_FORCE_INLINE bool isLeafNode(int nodeindex) const
 245         {
 246                 return m_box_tree.isLeafNode(nodeindex);
 247         }
 248
 249         SIMD_FORCE_INLINE int getNodeData(int nodeindex) const
 250         {
 251                 return m_box_tree.getNodeData(nodeindex);
 252         }
 253
 254         SIMD_FORCE_INLINE void getNodeBound(int nodeindex, btAABB& bound) const
 255         {
 256                 m_box_tree.getNodeBound(nodeindex, bound);
 257         }
 258
 259         SIMD_FORCE_INLINE void setNodeBound(int nodeindex, const btAABB& bound)
 260         {
 261                 m_box_tree.setNodeBound(nodeindex, bound);
 262         }
 263
 264         SIMD_FORCE_INLINE int getLeftNode(int nodeindex) const
 265         {
 266                 return m_box_tree.getLeftNode(nodeindex);
 267         }
 268
 269         SIMD_FORCE_INLINE int getRightNode(int nodeindex) const
 270         {
 271                 return m_box_tree.getRightNode(nodeindex);
 272         }
 273
 274         SIMD_FORCE_INLINE int getEscapeNodeIndex(int nodeindex) const
 275         {
 276                 return m_box_tree.getEscapeNodeIndex(nodeindex);
 277         }
 278
 279         SIMD_FORCE_INLINE void getNodeTriangle(int nodeindex, btPrimitiveTriangle& triangle) const
 280         {
 281                 m_primitive_manager->get_primitive_triangle(getNodeData(nodeindex), triangle);
 282         }
 283
 284         SIMD_FORCE_INLINE const BT_QUANTIZED_BVH_NODE* get_node_pointer(int index = 0) const
 285         {
 286                 return m_box_tree.get_node_pointer(index);
 287         }
 288
 289 #ifdef TRI_COLLISION_PROFILING
 290         static float getAverageTreeCollisionTime();
 291 #endif  //TRI_COLLISION_PROFILING
 292
 293         static void find_collision(const btGImpactQuantizedBvh* boxset1, const btTransform& trans1,
 294                                                            const btGImpactQuantizedBvh* boxset2, const btTransform& trans2,
 295                                                            btPairSet& collision_pairs);
 296 };
 297
 298 #endif  // GIM_BOXPRUNING_H_INCLUDED