1 |
|
|
/* |
2 |
|
|
* Software License Agreement (BSD License) |
3 |
|
|
* |
4 |
|
|
* Copyright (c) 2011-2014, Willow Garage, Inc. |
5 |
|
|
* Copyright (c) 2014-2015, Open Source Robotics Foundation |
6 |
|
|
* All rights reserved. |
7 |
|
|
* |
8 |
|
|
* Redistribution and use in source and binary forms, with or without |
9 |
|
|
* modification, are permitted provided that the following conditions |
10 |
|
|
* are met: |
11 |
|
|
* |
12 |
|
|
* * Redistributions of source code must retain the above copyright |
13 |
|
|
* notice, this list of conditions and the following disclaimer. |
14 |
|
|
* * Redistributions in binary form must reproduce the above |
15 |
|
|
* copyright notice, this list of conditions and the following |
16 |
|
|
* disclaimer in the documentation and/or other materials provided |
17 |
|
|
* with the distribution. |
18 |
|
|
* * Neither the name of Open Source Robotics Foundation nor the names of its |
19 |
|
|
* contributors may be used to endorse or promote products derived |
20 |
|
|
* from this software without specific prior written permission. |
21 |
|
|
* |
22 |
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
23 |
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
24 |
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
25 |
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
26 |
|
|
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
27 |
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
28 |
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
29 |
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
30 |
|
|
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
31 |
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN |
32 |
|
|
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
33 |
|
|
* POSSIBILITY OF SUCH DAMAGE. |
34 |
|
|
*/ |
35 |
|
|
|
36 |
|
|
/** \author Jia Pan */ |
37 |
|
|
|
38 |
|
|
#include <hpp/fcl/collision_func_matrix.h> |
39 |
|
|
|
40 |
|
|
#include <hpp/fcl/internal/traversal_node_setup.h> |
41 |
|
|
#include <../src/collision_node.h> |
42 |
|
|
#include <hpp/fcl/narrowphase/narrowphase.h> |
43 |
|
|
#include <hpp/fcl/internal/shape_shape_func.h> |
44 |
|
|
#include <hpp/fcl/shape/geometric_shapes_traits.h> |
45 |
|
|
#include <../src/traits_traversal.h> |
46 |
|
|
|
47 |
|
|
namespace hpp { |
48 |
|
|
namespace fcl { |
49 |
|
|
|
50 |
|
|
#ifdef HPP_FCL_HAS_OCTOMAP |
51 |
|
|
|
52 |
|
|
template <typename TypeA, typename TypeB> |
53 |
|
200 |
std::size_t OctreeCollide(const CollisionGeometry* o1, const Transform3f& tf1, |
54 |
|
|
const CollisionGeometry* o2, const Transform3f& tf2, |
55 |
|
|
const GJKSolver* nsolver, |
56 |
|
|
const CollisionRequest& request, |
57 |
|
|
CollisionResult& result) { |
58 |
✓✗✗✓
|
200 |
if (request.isSatisfied(result)) return result.numContacts(); |
59 |
|
|
|
60 |
✗✓ |
200 |
if (request.security_margin < 0) |
61 |
|
|
HPP_FCL_THROW_PRETTY( |
62 |
|
|
"Negative security margin are not handled yet for Octree", |
63 |
|
|
std::invalid_argument); |
64 |
|
|
|
65 |
✓✗ |
400 |
typename TraversalTraitsCollision<TypeA, TypeB>::CollisionTraversal_t node( |
66 |
|
|
request); |
67 |
✓✗ |
200 |
const TypeA* obj1 = dynamic_cast<const TypeA*>(o1); |
68 |
✓✗ |
200 |
const TypeB* obj2 = dynamic_cast<const TypeB*>(o2); |
69 |
|
200 |
OcTreeSolver otsolver(nsolver); |
70 |
|
|
|
71 |
✓✗ |
200 |
initialize(node, *obj1, tf1, *obj2, tf2, &otsolver, result); |
72 |
✓✗ |
200 |
collide(&node, request, result); |
73 |
|
|
|
74 |
|
200 |
return result.numContacts(); |
75 |
|
|
} |
76 |
|
|
|
77 |
|
|
#endif |
78 |
|
|
|
79 |
|
|
namespace details { |
80 |
|
|
template <typename T_BVH, typename T_SH> |
81 |
|
|
struct bvh_shape_traits { |
82 |
|
|
enum { Options = RelativeTransformationIsIdentity }; |
83 |
|
|
}; |
84 |
|
|
#define BVH_SHAPE_DEFAULT_TO_ORIENTED(bv) \ |
85 |
|
|
template <typename T_SH> \ |
86 |
|
|
struct bvh_shape_traits<bv, T_SH> { \ |
87 |
|
|
enum { Options = 0 }; \ |
88 |
|
|
} |
89 |
|
|
BVH_SHAPE_DEFAULT_TO_ORIENTED(OBB); |
90 |
|
|
BVH_SHAPE_DEFAULT_TO_ORIENTED(RSS); |
91 |
|
|
BVH_SHAPE_DEFAULT_TO_ORIENTED(kIOS); |
92 |
|
|
BVH_SHAPE_DEFAULT_TO_ORIENTED(OBBRSS); |
93 |
|
|
#undef BVH_SHAPE_DEFAULT_TO_ORIENTED |
94 |
|
|
} // namespace details |
95 |
|
|
|
96 |
|
|
/// \tparam _Options takes two values. |
97 |
|
|
/// - RelativeTransformationIsIdentity if object 1 should be moved |
98 |
|
|
/// into the frame of object 2 before computing collisions. |
99 |
|
|
/// - 0 if the query should be made with non-aligned object frames. |
100 |
|
|
template <typename T_BVH, typename T_SH, |
101 |
|
|
int _Options = details::bvh_shape_traits<T_BVH, T_SH>::Options> |
102 |
|
|
struct HPP_FCL_LOCAL BVHShapeCollider { |
103 |
|
248 |
static std::size_t collide(const CollisionGeometry* o1, |
104 |
|
|
const Transform3f& tf1, |
105 |
|
|
const CollisionGeometry* o2, |
106 |
|
|
const Transform3f& tf2, const GJKSolver* nsolver, |
107 |
|
|
const CollisionRequest& request, |
108 |
|
|
CollisionResult& result) { |
109 |
✗✓ |
248 |
if (request.isSatisfied(result)) return result.numContacts(); |
110 |
|
|
|
111 |
✗✓ |
248 |
if (request.security_margin < 0) |
112 |
|
|
HPP_FCL_THROW_PRETTY( |
113 |
|
|
"Negative security margin are not handled yet for BVHModel", |
114 |
|
|
std::invalid_argument); |
115 |
|
|
|
116 |
|
|
if (_Options & RelativeTransformationIsIdentity) |
117 |
|
|
return aligned(o1, tf1, o2, tf2, nsolver, request, result); |
118 |
|
|
else |
119 |
|
248 |
return oriented(o1, tf1, o2, tf2, nsolver, request, result); |
120 |
|
|
} |
121 |
|
|
|
122 |
|
|
static std::size_t aligned(const CollisionGeometry* o1, |
123 |
|
|
const Transform3f& tf1, |
124 |
|
|
const CollisionGeometry* o2, |
125 |
|
|
const Transform3f& tf2, const GJKSolver* nsolver, |
126 |
|
|
const CollisionRequest& request, |
127 |
|
|
CollisionResult& result) { |
128 |
|
|
if (request.isSatisfied(result)) return result.numContacts(); |
129 |
|
|
|
130 |
|
|
MeshShapeCollisionTraversalNode<T_BVH, T_SH, |
131 |
|
|
RelativeTransformationIsIdentity> |
132 |
|
|
node(request); |
133 |
|
|
const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1); |
134 |
|
|
BVHModel<T_BVH>* obj1_tmp = new BVHModel<T_BVH>(*obj1); |
135 |
|
|
Transform3f tf1_tmp = tf1; |
136 |
|
|
const T_SH* obj2 = static_cast<const T_SH*>(o2); |
137 |
|
|
|
138 |
|
|
initialize(node, *obj1_tmp, tf1_tmp, *obj2, tf2, nsolver, result); |
139 |
|
|
fcl::collide(&node, request, result); |
140 |
|
|
|
141 |
|
|
delete obj1_tmp; |
142 |
|
|
return result.numContacts(); |
143 |
|
|
} |
144 |
|
|
|
145 |
|
248 |
static std::size_t oriented(const CollisionGeometry* o1, |
146 |
|
|
const Transform3f& tf1, |
147 |
|
|
const CollisionGeometry* o2, |
148 |
|
|
const Transform3f& tf2, const GJKSolver* nsolver, |
149 |
|
|
const CollisionRequest& request, |
150 |
|
|
CollisionResult& result) { |
151 |
✓✗✗✓
|
248 |
if (request.isSatisfied(result)) return result.numContacts(); |
152 |
|
|
|
153 |
✓✗ |
496 |
MeshShapeCollisionTraversalNode<T_BVH, T_SH, 0> node(request); |
154 |
|
248 |
const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1); |
155 |
|
248 |
const T_SH* obj2 = static_cast<const T_SH*>(o2); |
156 |
|
|
|
157 |
✓✗ |
248 |
initialize(node, *obj1, tf1, *obj2, tf2, nsolver, result); |
158 |
✓✗ |
248 |
fcl::collide(&node, request, result); |
159 |
|
248 |
return result.numContacts(); |
160 |
|
|
} |
161 |
|
|
}; |
162 |
|
|
|
163 |
|
|
/// @brief Collider functor for HeightField data structure |
164 |
|
|
/// \tparam _Options takes two values. |
165 |
|
|
/// - RelativeTransformationIsIdentity if object 1 should be moved |
166 |
|
|
/// into the frame of object 2 before computing collisions. |
167 |
|
|
/// - 0 if the query should be made with non-aligned object frames. |
168 |
|
|
template <typename BV, typename Shape> |
169 |
|
|
struct HPP_FCL_LOCAL HeightFieldShapeCollider { |
170 |
|
|
typedef HeightField<BV> HF; |
171 |
|
|
|
172 |
|
80 |
static std::size_t collide(const CollisionGeometry* o1, |
173 |
|
|
const Transform3f& tf1, |
174 |
|
|
const CollisionGeometry* o2, |
175 |
|
|
const Transform3f& tf2, const GJKSolver* nsolver, |
176 |
|
|
const CollisionRequest& request, |
177 |
|
|
CollisionResult& result) { |
178 |
✓✗✗✓
|
80 |
if (request.isSatisfied(result)) return result.numContacts(); |
179 |
|
|
|
180 |
|
80 |
const HF& height_field = static_cast<const HF&>(*o1); |
181 |
|
80 |
const Shape& shape = static_cast<const Shape&>(*o2); |
182 |
|
|
|
183 |
✓✗ |
160 |
HeightFieldShapeCollisionTraversalNode<BV, Shape, 0> node(request); |
184 |
|
|
|
185 |
✓✗ |
80 |
initialize(node, height_field, tf1, shape, tf2, nsolver, result); |
186 |
✓✗ |
80 |
fcl::collide(&node, request, result); |
187 |
|
80 |
return result.numContacts(); |
188 |
|
|
} |
189 |
|
|
}; |
190 |
|
|
|
191 |
|
|
namespace details { |
192 |
|
|
template <typename OrientedMeshCollisionTraversalNode, typename T_BVH> |
193 |
|
20356 |
std::size_t orientedMeshCollide(const CollisionGeometry* o1, |
194 |
|
|
const Transform3f& tf1, |
195 |
|
|
const CollisionGeometry* o2, |
196 |
|
|
const Transform3f& tf2, |
197 |
|
|
const CollisionRequest& request, |
198 |
|
|
CollisionResult& result) { |
199 |
✓✗✗✓
|
20356 |
if (request.isSatisfied(result)) return result.numContacts(); |
200 |
|
|
|
201 |
✓✗ |
40712 |
OrientedMeshCollisionTraversalNode node(request); |
202 |
|
20356 |
const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1); |
203 |
|
20356 |
const BVHModel<T_BVH>* obj2 = static_cast<const BVHModel<T_BVH>*>(o2); |
204 |
|
|
|
205 |
✓✗ |
20356 |
initialize(node, *obj1, tf1, *obj2, tf2, result); |
206 |
✓✗ |
20356 |
collide(&node, request, result); |
207 |
|
|
|
208 |
|
20356 |
return result.numContacts(); |
209 |
|
|
} |
210 |
|
|
|
211 |
|
|
} // namespace details |
212 |
|
|
|
213 |
|
|
template <typename T_BVH> |
214 |
|
|
std::size_t BVHCollide(const CollisionGeometry* o1, const Transform3f& tf1, |
215 |
|
|
const CollisionGeometry* o2, const Transform3f& tf2, |
216 |
|
|
const CollisionRequest& request, |
217 |
|
|
CollisionResult& result) { |
218 |
|
|
if (request.isSatisfied(result)) return result.numContacts(); |
219 |
|
|
|
220 |
|
|
MeshCollisionTraversalNode<T_BVH> node(request); |
221 |
|
|
const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1); |
222 |
|
|
const BVHModel<T_BVH>* obj2 = static_cast<const BVHModel<T_BVH>*>(o2); |
223 |
|
|
BVHModel<T_BVH>* obj1_tmp = new BVHModel<T_BVH>(*obj1); |
224 |
|
|
Transform3f tf1_tmp = tf1; |
225 |
|
|
BVHModel<T_BVH>* obj2_tmp = new BVHModel<T_BVH>(*obj2); |
226 |
|
|
Transform3f tf2_tmp = tf2; |
227 |
|
|
|
228 |
|
|
initialize(node, *obj1_tmp, tf1_tmp, *obj2_tmp, tf2_tmp, result); |
229 |
|
|
fcl::collide(&node, request, result); |
230 |
|
|
|
231 |
|
|
delete obj1_tmp; |
232 |
|
|
delete obj2_tmp; |
233 |
|
|
|
234 |
|
|
return result.numContacts(); |
235 |
|
|
} |
236 |
|
|
|
237 |
|
|
template <> |
238 |
|
3 |
std::size_t BVHCollide<OBB>(const CollisionGeometry* o1, const Transform3f& tf1, |
239 |
|
|
const CollisionGeometry* o2, const Transform3f& tf2, |
240 |
|
|
const CollisionRequest& request, |
241 |
|
|
CollisionResult& result) { |
242 |
|
3 |
return details::orientedMeshCollide<MeshCollisionTraversalNodeOBB, OBB>( |
243 |
|
3 |
o1, tf1, o2, tf2, request, result); |
244 |
|
|
} |
245 |
|
|
|
246 |
|
|
template <> |
247 |
|
10175 |
std::size_t BVHCollide<OBBRSS>(const CollisionGeometry* o1, |
248 |
|
|
const Transform3f& tf1, |
249 |
|
|
const CollisionGeometry* o2, |
250 |
|
|
const Transform3f& tf2, |
251 |
|
|
const CollisionRequest& request, |
252 |
|
|
CollisionResult& result) { |
253 |
|
10175 |
return details::orientedMeshCollide<MeshCollisionTraversalNodeOBBRSS, OBBRSS>( |
254 |
|
10175 |
o1, tf1, o2, tf2, request, result); |
255 |
|
|
} |
256 |
|
|
|
257 |
|
|
template <> |
258 |
|
|
std::size_t BVHCollide<kIOS>(const CollisionGeometry* o1, |
259 |
|
|
const Transform3f& tf1, |
260 |
|
|
const CollisionGeometry* o2, |
261 |
|
|
const Transform3f& tf2, |
262 |
|
|
const CollisionRequest& request, |
263 |
|
|
CollisionResult& result) { |
264 |
|
|
return details::orientedMeshCollide<MeshCollisionTraversalNodekIOS, kIOS>( |
265 |
|
|
o1, tf1, o2, tf2, request, result); |
266 |
|
|
} |
267 |
|
|
|
268 |
|
|
template <typename T_BVH> |
269 |
|
20356 |
std::size_t BVHCollide(const CollisionGeometry* o1, const Transform3f& tf1, |
270 |
|
|
const CollisionGeometry* o2, const Transform3f& tf2, |
271 |
|
|
const GJKSolver* /*nsolver*/, |
272 |
|
|
const CollisionRequest& request, |
273 |
|
|
CollisionResult& result) { |
274 |
|
20356 |
return BVHCollide<T_BVH>(o1, tf1, o2, tf2, request, result); |
275 |
|
|
} |
276 |
|
|
|
277 |
|
17 |
CollisionFunctionMatrix::CollisionFunctionMatrix() { |
278 |
✓✓ |
391 |
for (int i = 0; i < NODE_COUNT; ++i) { |
279 |
✓✓ |
8602 |
for (int j = 0; j < NODE_COUNT; ++j) collision_matrix[i][j] = NULL; |
280 |
|
|
} |
281 |
|
|
|
282 |
|
17 |
collision_matrix[GEOM_BOX][GEOM_BOX] = &ShapeShapeCollide<Box, Box>; |
283 |
|
17 |
collision_matrix[GEOM_BOX][GEOM_SPHERE] = &ShapeShapeCollide<Box, Sphere>; |
284 |
|
17 |
collision_matrix[GEOM_BOX][GEOM_CAPSULE] = &ShapeShapeCollide<Box, Capsule>; |
285 |
|
17 |
collision_matrix[GEOM_BOX][GEOM_CONE] = &ShapeShapeCollide<Box, Cone>; |
286 |
|
17 |
collision_matrix[GEOM_BOX][GEOM_CYLINDER] = &ShapeShapeCollide<Box, Cylinder>; |
287 |
|
17 |
collision_matrix[GEOM_BOX][GEOM_CONVEX] = &ShapeShapeCollide<Box, ConvexBase>; |
288 |
|
17 |
collision_matrix[GEOM_BOX][GEOM_PLANE] = &ShapeShapeCollide<Box, Plane>; |
289 |
|
17 |
collision_matrix[GEOM_BOX][GEOM_HALFSPACE] = |
290 |
|
|
&ShapeShapeCollide<Box, Halfspace>; |
291 |
|
17 |
collision_matrix[GEOM_BOX][GEOM_ELLIPSOID] = |
292 |
|
|
&ShapeShapeCollide<Box, Ellipsoid>; |
293 |
|
|
|
294 |
|
17 |
collision_matrix[GEOM_SPHERE][GEOM_BOX] = &ShapeShapeCollide<Sphere, Box>; |
295 |
|
17 |
collision_matrix[GEOM_SPHERE][GEOM_SPHERE] = |
296 |
|
|
&ShapeShapeCollide<Sphere, Sphere>; |
297 |
|
17 |
collision_matrix[GEOM_SPHERE][GEOM_CAPSULE] = |
298 |
|
|
&ShapeShapeCollide<Sphere, Capsule>; |
299 |
|
17 |
collision_matrix[GEOM_SPHERE][GEOM_CONE] = &ShapeShapeCollide<Sphere, Cone>; |
300 |
|
17 |
collision_matrix[GEOM_SPHERE][GEOM_CYLINDER] = |
301 |
|
|
&ShapeShapeCollide<Sphere, Cylinder>; |
302 |
|
17 |
collision_matrix[GEOM_SPHERE][GEOM_CONVEX] = |
303 |
|
|
&ShapeShapeCollide<Sphere, ConvexBase>; |
304 |
|
17 |
collision_matrix[GEOM_SPHERE][GEOM_PLANE] = &ShapeShapeCollide<Sphere, Plane>; |
305 |
|
17 |
collision_matrix[GEOM_SPHERE][GEOM_HALFSPACE] = |
306 |
|
|
&ShapeShapeCollide<Sphere, Halfspace>; |
307 |
|
17 |
collision_matrix[GEOM_SPHERE][GEOM_ELLIPSOID] = |
308 |
|
|
&ShapeShapeCollide<Sphere, Ellipsoid>; |
309 |
|
|
|
310 |
|
17 |
collision_matrix[GEOM_ELLIPSOID][GEOM_BOX] = |
311 |
|
|
&ShapeShapeCollide<Ellipsoid, Box>; |
312 |
|
17 |
collision_matrix[GEOM_ELLIPSOID][GEOM_SPHERE] = |
313 |
|
|
&ShapeShapeCollide<Ellipsoid, Sphere>; |
314 |
|
17 |
collision_matrix[GEOM_ELLIPSOID][GEOM_CAPSULE] = |
315 |
|
|
&ShapeShapeCollide<Ellipsoid, Capsule>; |
316 |
|
17 |
collision_matrix[GEOM_ELLIPSOID][GEOM_CONE] = |
317 |
|
|
&ShapeShapeCollide<Ellipsoid, Cone>; |
318 |
|
17 |
collision_matrix[GEOM_ELLIPSOID][GEOM_CYLINDER] = |
319 |
|
|
&ShapeShapeCollide<Ellipsoid, Cylinder>; |
320 |
|
17 |
collision_matrix[GEOM_ELLIPSOID][GEOM_CONVEX] = |
321 |
|
|
&ShapeShapeCollide<Ellipsoid, ConvexBase>; |
322 |
|
|
// TODO Louis: Ellipsoid - Plane |
323 |
|
|
// TODO Louis: Ellipsoid - Halfspace |
324 |
|
17 |
collision_matrix[GEOM_ELLIPSOID][GEOM_ELLIPSOID] = |
325 |
|
|
&ShapeShapeCollide<Ellipsoid, Ellipsoid>; |
326 |
|
|
|
327 |
|
17 |
collision_matrix[GEOM_CAPSULE][GEOM_BOX] = &ShapeShapeCollide<Capsule, Box>; |
328 |
|
17 |
collision_matrix[GEOM_CAPSULE][GEOM_SPHERE] = |
329 |
|
|
&ShapeShapeCollide<Capsule, Sphere>; |
330 |
|
17 |
collision_matrix[GEOM_CAPSULE][GEOM_CAPSULE] = |
331 |
|
|
&ShapeShapeCollide<Capsule, Capsule>; |
332 |
|
17 |
collision_matrix[GEOM_CAPSULE][GEOM_CONE] = &ShapeShapeCollide<Capsule, Cone>; |
333 |
|
17 |
collision_matrix[GEOM_CAPSULE][GEOM_CYLINDER] = |
334 |
|
|
&ShapeShapeCollide<Capsule, Cylinder>; |
335 |
|
17 |
collision_matrix[GEOM_CAPSULE][GEOM_CONVEX] = |
336 |
|
|
&ShapeShapeCollide<Capsule, ConvexBase>; |
337 |
|
17 |
collision_matrix[GEOM_CAPSULE][GEOM_PLANE] = |
338 |
|
|
&ShapeShapeCollide<Capsule, Plane>; |
339 |
|
17 |
collision_matrix[GEOM_CAPSULE][GEOM_HALFSPACE] = |
340 |
|
|
&ShapeShapeCollide<Capsule, Halfspace>; |
341 |
|
17 |
collision_matrix[GEOM_CAPSULE][GEOM_ELLIPSOID] = |
342 |
|
|
&ShapeShapeCollide<Capsule, Ellipsoid>; |
343 |
|
|
|
344 |
|
17 |
collision_matrix[GEOM_CONE][GEOM_BOX] = &ShapeShapeCollide<Cone, Box>; |
345 |
|
17 |
collision_matrix[GEOM_CONE][GEOM_SPHERE] = &ShapeShapeCollide<Cone, Sphere>; |
346 |
|
17 |
collision_matrix[GEOM_CONE][GEOM_CAPSULE] = &ShapeShapeCollide<Cone, Capsule>; |
347 |
|
17 |
collision_matrix[GEOM_CONE][GEOM_CONE] = &ShapeShapeCollide<Cone, Cone>; |
348 |
|
17 |
collision_matrix[GEOM_CONE][GEOM_CYLINDER] = |
349 |
|
|
&ShapeShapeCollide<Cone, Cylinder>; |
350 |
|
17 |
collision_matrix[GEOM_CONE][GEOM_CONVEX] = |
351 |
|
|
&ShapeShapeCollide<Cone, ConvexBase>; |
352 |
|
17 |
collision_matrix[GEOM_CONE][GEOM_PLANE] = &ShapeShapeCollide<Cone, Plane>; |
353 |
|
17 |
collision_matrix[GEOM_CONE][GEOM_HALFSPACE] = |
354 |
|
|
&ShapeShapeCollide<Cone, Halfspace>; |
355 |
|
17 |
collision_matrix[GEOM_CONE][GEOM_ELLIPSOID] = |
356 |
|
|
&ShapeShapeCollide<Cone, Ellipsoid>; |
357 |
|
|
|
358 |
|
17 |
collision_matrix[GEOM_CYLINDER][GEOM_BOX] = &ShapeShapeCollide<Cylinder, Box>; |
359 |
|
17 |
collision_matrix[GEOM_CYLINDER][GEOM_SPHERE] = |
360 |
|
|
&ShapeShapeCollide<Cylinder, Sphere>; |
361 |
|
17 |
collision_matrix[GEOM_CYLINDER][GEOM_CAPSULE] = |
362 |
|
|
&ShapeShapeCollide<Cylinder, Capsule>; |
363 |
|
17 |
collision_matrix[GEOM_CYLINDER][GEOM_CONE] = |
364 |
|
|
&ShapeShapeCollide<Cylinder, Cone>; |
365 |
|
17 |
collision_matrix[GEOM_CYLINDER][GEOM_CYLINDER] = |
366 |
|
|
&ShapeShapeCollide<Cylinder, Cylinder>; |
367 |
|
17 |
collision_matrix[GEOM_CYLINDER][GEOM_CONVEX] = |
368 |
|
|
&ShapeShapeCollide<Cylinder, ConvexBase>; |
369 |
|
17 |
collision_matrix[GEOM_CYLINDER][GEOM_PLANE] = |
370 |
|
|
&ShapeShapeCollide<Cylinder, Plane>; |
371 |
|
17 |
collision_matrix[GEOM_CYLINDER][GEOM_HALFSPACE] = |
372 |
|
|
&ShapeShapeCollide<Cylinder, Halfspace>; |
373 |
|
17 |
collision_matrix[GEOM_CYLINDER][GEOM_ELLIPSOID] = |
374 |
|
|
&ShapeShapeCollide<Cylinder, Ellipsoid>; |
375 |
|
|
|
376 |
|
17 |
collision_matrix[GEOM_CONVEX][GEOM_BOX] = &ShapeShapeCollide<ConvexBase, Box>; |
377 |
|
17 |
collision_matrix[GEOM_CONVEX][GEOM_SPHERE] = |
378 |
|
|
&ShapeShapeCollide<ConvexBase, Sphere>; |
379 |
|
17 |
collision_matrix[GEOM_CONVEX][GEOM_CAPSULE] = |
380 |
|
|
&ShapeShapeCollide<ConvexBase, Capsule>; |
381 |
|
17 |
collision_matrix[GEOM_CONVEX][GEOM_CONE] = |
382 |
|
|
&ShapeShapeCollide<ConvexBase, Cone>; |
383 |
|
17 |
collision_matrix[GEOM_CONVEX][GEOM_CYLINDER] = |
384 |
|
|
&ShapeShapeCollide<ConvexBase, Cylinder>; |
385 |
|
17 |
collision_matrix[GEOM_CONVEX][GEOM_CONVEX] = |
386 |
|
|
&ShapeShapeCollide<ConvexBase, ConvexBase>; |
387 |
|
17 |
collision_matrix[GEOM_CONVEX][GEOM_PLANE] = |
388 |
|
|
&ShapeShapeCollide<ConvexBase, Plane>; |
389 |
|
17 |
collision_matrix[GEOM_CONVEX][GEOM_HALFSPACE] = |
390 |
|
|
&ShapeShapeCollide<ConvexBase, Halfspace>; |
391 |
|
17 |
collision_matrix[GEOM_CONVEX][GEOM_ELLIPSOID] = |
392 |
|
|
&ShapeShapeCollide<ConvexBase, Ellipsoid>; |
393 |
|
|
|
394 |
|
17 |
collision_matrix[GEOM_PLANE][GEOM_BOX] = &ShapeShapeCollide<Plane, Box>; |
395 |
|
17 |
collision_matrix[GEOM_PLANE][GEOM_SPHERE] = &ShapeShapeCollide<Plane, Sphere>; |
396 |
|
17 |
collision_matrix[GEOM_PLANE][GEOM_CAPSULE] = |
397 |
|
|
&ShapeShapeCollide<Plane, Capsule>; |
398 |
|
17 |
collision_matrix[GEOM_PLANE][GEOM_CONE] = &ShapeShapeCollide<Plane, Cone>; |
399 |
|
17 |
collision_matrix[GEOM_PLANE][GEOM_CYLINDER] = |
400 |
|
|
&ShapeShapeCollide<Plane, Cylinder>; |
401 |
|
17 |
collision_matrix[GEOM_PLANE][GEOM_CONVEX] = |
402 |
|
|
&ShapeShapeCollide<Plane, ConvexBase>; |
403 |
|
17 |
collision_matrix[GEOM_PLANE][GEOM_PLANE] = &ShapeShapeCollide<Plane, Plane>; |
404 |
|
17 |
collision_matrix[GEOM_PLANE][GEOM_HALFSPACE] = |
405 |
|
|
&ShapeShapeCollide<Plane, Halfspace>; |
406 |
|
|
// TODO Louis: Ellipsoid - Plane |
407 |
|
|
|
408 |
|
17 |
collision_matrix[GEOM_HALFSPACE][GEOM_BOX] = |
409 |
|
|
&ShapeShapeCollide<Halfspace, Box>; |
410 |
|
17 |
collision_matrix[GEOM_HALFSPACE][GEOM_SPHERE] = |
411 |
|
|
&ShapeShapeCollide<Halfspace, Sphere>; |
412 |
|
17 |
collision_matrix[GEOM_HALFSPACE][GEOM_CAPSULE] = |
413 |
|
|
&ShapeShapeCollide<Halfspace, Capsule>; |
414 |
|
17 |
collision_matrix[GEOM_HALFSPACE][GEOM_CONE] = |
415 |
|
|
&ShapeShapeCollide<Halfspace, Cone>; |
416 |
|
17 |
collision_matrix[GEOM_HALFSPACE][GEOM_CYLINDER] = |
417 |
|
|
&ShapeShapeCollide<Halfspace, Cylinder>; |
418 |
|
17 |
collision_matrix[GEOM_HALFSPACE][GEOM_CONVEX] = |
419 |
|
|
&ShapeShapeCollide<Halfspace, ConvexBase>; |
420 |
|
17 |
collision_matrix[GEOM_HALFSPACE][GEOM_PLANE] = |
421 |
|
|
&ShapeShapeCollide<Halfspace, Plane>; |
422 |
|
17 |
collision_matrix[GEOM_HALFSPACE][GEOM_HALFSPACE] = |
423 |
|
|
&ShapeShapeCollide<Halfspace, Halfspace>; |
424 |
|
|
// TODO Louis: Ellipsoid - Halfspace |
425 |
|
|
|
426 |
|
17 |
collision_matrix[BV_AABB][GEOM_BOX] = &BVHShapeCollider<AABB, Box>::collide; |
427 |
|
17 |
collision_matrix[BV_AABB][GEOM_SPHERE] = |
428 |
|
|
&BVHShapeCollider<AABB, Sphere>::collide; |
429 |
|
17 |
collision_matrix[BV_AABB][GEOM_CAPSULE] = |
430 |
|
|
&BVHShapeCollider<AABB, Capsule>::collide; |
431 |
|
17 |
collision_matrix[BV_AABB][GEOM_CONE] = &BVHShapeCollider<AABB, Cone>::collide; |
432 |
|
17 |
collision_matrix[BV_AABB][GEOM_CYLINDER] = |
433 |
|
|
&BVHShapeCollider<AABB, Cylinder>::collide; |
434 |
|
17 |
collision_matrix[BV_AABB][GEOM_CONVEX] = |
435 |
|
|
&BVHShapeCollider<AABB, ConvexBase>::collide; |
436 |
|
17 |
collision_matrix[BV_AABB][GEOM_PLANE] = |
437 |
|
|
&BVHShapeCollider<AABB, Plane>::collide; |
438 |
|
17 |
collision_matrix[BV_AABB][GEOM_HALFSPACE] = |
439 |
|
|
&BVHShapeCollider<AABB, Halfspace>::collide; |
440 |
|
17 |
collision_matrix[BV_AABB][GEOM_ELLIPSOID] = |
441 |
|
|
&BVHShapeCollider<AABB, Ellipsoid>::collide; |
442 |
|
|
|
443 |
|
17 |
collision_matrix[BV_OBB][GEOM_BOX] = &BVHShapeCollider<OBB, Box>::collide; |
444 |
|
17 |
collision_matrix[BV_OBB][GEOM_SPHERE] = |
445 |
|
|
&BVHShapeCollider<OBB, Sphere>::collide; |
446 |
|
17 |
collision_matrix[BV_OBB][GEOM_CAPSULE] = |
447 |
|
|
&BVHShapeCollider<OBB, Capsule>::collide; |
448 |
|
17 |
collision_matrix[BV_OBB][GEOM_CONE] = &BVHShapeCollider<OBB, Cone>::collide; |
449 |
|
17 |
collision_matrix[BV_OBB][GEOM_CYLINDER] = |
450 |
|
|
&BVHShapeCollider<OBB, Cylinder>::collide; |
451 |
|
17 |
collision_matrix[BV_OBB][GEOM_CONVEX] = |
452 |
|
|
&BVHShapeCollider<OBB, ConvexBase>::collide; |
453 |
|
17 |
collision_matrix[BV_OBB][GEOM_PLANE] = &BVHShapeCollider<OBB, Plane>::collide; |
454 |
|
17 |
collision_matrix[BV_OBB][GEOM_HALFSPACE] = |
455 |
|
|
&BVHShapeCollider<OBB, Halfspace>::collide; |
456 |
|
17 |
collision_matrix[BV_OBB][GEOM_ELLIPSOID] = |
457 |
|
|
&BVHShapeCollider<OBB, Ellipsoid>::collide; |
458 |
|
|
|
459 |
|
17 |
collision_matrix[BV_RSS][GEOM_BOX] = &BVHShapeCollider<RSS, Box>::collide; |
460 |
|
17 |
collision_matrix[BV_RSS][GEOM_SPHERE] = |
461 |
|
|
&BVHShapeCollider<RSS, Sphere>::collide; |
462 |
|
17 |
collision_matrix[BV_RSS][GEOM_CAPSULE] = |
463 |
|
|
&BVHShapeCollider<RSS, Capsule>::collide; |
464 |
|
17 |
collision_matrix[BV_RSS][GEOM_CONE] = &BVHShapeCollider<RSS, Cone>::collide; |
465 |
|
17 |
collision_matrix[BV_RSS][GEOM_CYLINDER] = |
466 |
|
|
&BVHShapeCollider<RSS, Cylinder>::collide; |
467 |
|
17 |
collision_matrix[BV_RSS][GEOM_CONVEX] = |
468 |
|
|
&BVHShapeCollider<RSS, ConvexBase>::collide; |
469 |
|
17 |
collision_matrix[BV_RSS][GEOM_PLANE] = &BVHShapeCollider<RSS, Plane>::collide; |
470 |
|
17 |
collision_matrix[BV_RSS][GEOM_HALFSPACE] = |
471 |
|
|
&BVHShapeCollider<RSS, Halfspace>::collide; |
472 |
|
17 |
collision_matrix[BV_RSS][GEOM_ELLIPSOID] = |
473 |
|
|
&BVHShapeCollider<RSS, Ellipsoid>::collide; |
474 |
|
|
|
475 |
|
17 |
collision_matrix[BV_KDOP16][GEOM_BOX] = |
476 |
|
|
&BVHShapeCollider<KDOP<16>, Box>::collide; |
477 |
|
17 |
collision_matrix[BV_KDOP16][GEOM_SPHERE] = |
478 |
|
|
&BVHShapeCollider<KDOP<16>, Sphere>::collide; |
479 |
|
17 |
collision_matrix[BV_KDOP16][GEOM_CAPSULE] = |
480 |
|
|
&BVHShapeCollider<KDOP<16>, Capsule>::collide; |
481 |
|
17 |
collision_matrix[BV_KDOP16][GEOM_CONE] = |
482 |
|
|
&BVHShapeCollider<KDOP<16>, Cone>::collide; |
483 |
|
17 |
collision_matrix[BV_KDOP16][GEOM_CYLINDER] = |
484 |
|
|
&BVHShapeCollider<KDOP<16>, Cylinder>::collide; |
485 |
|
17 |
collision_matrix[BV_KDOP16][GEOM_CONVEX] = |
486 |
|
|
&BVHShapeCollider<KDOP<16>, ConvexBase>::collide; |
487 |
|
17 |
collision_matrix[BV_KDOP16][GEOM_PLANE] = |
488 |
|
|
&BVHShapeCollider<KDOP<16>, Plane>::collide; |
489 |
|
17 |
collision_matrix[BV_KDOP16][GEOM_HALFSPACE] = |
490 |
|
|
&BVHShapeCollider<KDOP<16>, Halfspace>::collide; |
491 |
|
17 |
collision_matrix[BV_KDOP16][GEOM_ELLIPSOID] = |
492 |
|
|
&BVHShapeCollider<KDOP<16>, Ellipsoid>::collide; |
493 |
|
|
|
494 |
|
17 |
collision_matrix[BV_KDOP18][GEOM_BOX] = |
495 |
|
|
&BVHShapeCollider<KDOP<18>, Box>::collide; |
496 |
|
17 |
collision_matrix[BV_KDOP18][GEOM_SPHERE] = |
497 |
|
|
&BVHShapeCollider<KDOP<18>, Sphere>::collide; |
498 |
|
17 |
collision_matrix[BV_KDOP18][GEOM_CAPSULE] = |
499 |
|
|
&BVHShapeCollider<KDOP<18>, Capsule>::collide; |
500 |
|
17 |
collision_matrix[BV_KDOP18][GEOM_CONE] = |
501 |
|
|
&BVHShapeCollider<KDOP<18>, Cone>::collide; |
502 |
|
17 |
collision_matrix[BV_KDOP18][GEOM_CYLINDER] = |
503 |
|
|
&BVHShapeCollider<KDOP<18>, Cylinder>::collide; |
504 |
|
17 |
collision_matrix[BV_KDOP18][GEOM_CONVEX] = |
505 |
|
|
&BVHShapeCollider<KDOP<18>, ConvexBase>::collide; |
506 |
|
17 |
collision_matrix[BV_KDOP18][GEOM_PLANE] = |
507 |
|
|
&BVHShapeCollider<KDOP<18>, Plane>::collide; |
508 |
|
17 |
collision_matrix[BV_KDOP18][GEOM_HALFSPACE] = |
509 |
|
|
&BVHShapeCollider<KDOP<18>, Halfspace>::collide; |
510 |
|
17 |
collision_matrix[BV_KDOP18][GEOM_ELLIPSOID] = |
511 |
|
|
&BVHShapeCollider<KDOP<18>, Ellipsoid>::collide; |
512 |
|
|
|
513 |
|
17 |
collision_matrix[BV_KDOP24][GEOM_BOX] = |
514 |
|
|
&BVHShapeCollider<KDOP<24>, Box>::collide; |
515 |
|
17 |
collision_matrix[BV_KDOP24][GEOM_SPHERE] = |
516 |
|
|
&BVHShapeCollider<KDOP<24>, Sphere>::collide; |
517 |
|
17 |
collision_matrix[BV_KDOP24][GEOM_CAPSULE] = |
518 |
|
|
&BVHShapeCollider<KDOP<24>, Capsule>::collide; |
519 |
|
17 |
collision_matrix[BV_KDOP24][GEOM_CONE] = |
520 |
|
|
&BVHShapeCollider<KDOP<24>, Cone>::collide; |
521 |
|
17 |
collision_matrix[BV_KDOP24][GEOM_CYLINDER] = |
522 |
|
|
&BVHShapeCollider<KDOP<24>, Cylinder>::collide; |
523 |
|
17 |
collision_matrix[BV_KDOP24][GEOM_CONVEX] = |
524 |
|
|
&BVHShapeCollider<KDOP<24>, ConvexBase>::collide; |
525 |
|
17 |
collision_matrix[BV_KDOP24][GEOM_PLANE] = |
526 |
|
|
&BVHShapeCollider<KDOP<24>, Plane>::collide; |
527 |
|
17 |
collision_matrix[BV_KDOP24][GEOM_HALFSPACE] = |
528 |
|
|
&BVHShapeCollider<KDOP<24>, Halfspace>::collide; |
529 |
|
17 |
collision_matrix[BV_KDOP24][GEOM_ELLIPSOID] = |
530 |
|
|
&BVHShapeCollider<KDOP<24>, Ellipsoid>::collide; |
531 |
|
|
|
532 |
|
17 |
collision_matrix[BV_kIOS][GEOM_BOX] = &BVHShapeCollider<kIOS, Box>::collide; |
533 |
|
17 |
collision_matrix[BV_kIOS][GEOM_SPHERE] = |
534 |
|
|
&BVHShapeCollider<kIOS, Sphere>::collide; |
535 |
|
17 |
collision_matrix[BV_kIOS][GEOM_CAPSULE] = |
536 |
|
|
&BVHShapeCollider<kIOS, Capsule>::collide; |
537 |
|
17 |
collision_matrix[BV_kIOS][GEOM_CONE] = &BVHShapeCollider<kIOS, Cone>::collide; |
538 |
|
17 |
collision_matrix[BV_kIOS][GEOM_CYLINDER] = |
539 |
|
|
&BVHShapeCollider<kIOS, Cylinder>::collide; |
540 |
|
17 |
collision_matrix[BV_kIOS][GEOM_CONVEX] = |
541 |
|
|
&BVHShapeCollider<kIOS, ConvexBase>::collide; |
542 |
|
17 |
collision_matrix[BV_kIOS][GEOM_PLANE] = |
543 |
|
|
&BVHShapeCollider<kIOS, Plane>::collide; |
544 |
|
17 |
collision_matrix[BV_kIOS][GEOM_HALFSPACE] = |
545 |
|
|
&BVHShapeCollider<kIOS, Halfspace>::collide; |
546 |
|
17 |
collision_matrix[BV_kIOS][GEOM_ELLIPSOID] = |
547 |
|
|
&BVHShapeCollider<kIOS, Ellipsoid>::collide; |
548 |
|
|
|
549 |
|
17 |
collision_matrix[BV_OBBRSS][GEOM_BOX] = |
550 |
|
|
&BVHShapeCollider<OBBRSS, Box>::collide; |
551 |
|
17 |
collision_matrix[BV_OBBRSS][GEOM_SPHERE] = |
552 |
|
|
&BVHShapeCollider<OBBRSS, Sphere>::collide; |
553 |
|
17 |
collision_matrix[BV_OBBRSS][GEOM_CAPSULE] = |
554 |
|
|
&BVHShapeCollider<OBBRSS, Capsule>::collide; |
555 |
|
17 |
collision_matrix[BV_OBBRSS][GEOM_CONE] = |
556 |
|
|
&BVHShapeCollider<OBBRSS, Cone>::collide; |
557 |
|
17 |
collision_matrix[BV_OBBRSS][GEOM_CYLINDER] = |
558 |
|
|
&BVHShapeCollider<OBBRSS, Cylinder>::collide; |
559 |
|
17 |
collision_matrix[BV_OBBRSS][GEOM_CONVEX] = |
560 |
|
|
&BVHShapeCollider<OBBRSS, ConvexBase>::collide; |
561 |
|
17 |
collision_matrix[BV_OBBRSS][GEOM_PLANE] = |
562 |
|
|
&BVHShapeCollider<OBBRSS, Plane>::collide; |
563 |
|
17 |
collision_matrix[BV_OBBRSS][GEOM_HALFSPACE] = |
564 |
|
|
&BVHShapeCollider<OBBRSS, Halfspace>::collide; |
565 |
|
17 |
collision_matrix[BV_OBBRSS][GEOM_ELLIPSOID] = |
566 |
|
|
&BVHShapeCollider<OBBRSS, Ellipsoid>::collide; |
567 |
|
|
|
568 |
|
17 |
collision_matrix[HF_AABB][GEOM_BOX] = |
569 |
|
|
&HeightFieldShapeCollider<AABB, Box>::collide; |
570 |
|
17 |
collision_matrix[HF_AABB][GEOM_SPHERE] = |
571 |
|
|
&HeightFieldShapeCollider<AABB, Sphere>::collide; |
572 |
|
17 |
collision_matrix[HF_AABB][GEOM_CAPSULE] = |
573 |
|
|
&HeightFieldShapeCollider<AABB, Capsule>::collide; |
574 |
|
17 |
collision_matrix[HF_AABB][GEOM_CONE] = |
575 |
|
|
&HeightFieldShapeCollider<AABB, Cone>::collide; |
576 |
|
17 |
collision_matrix[HF_AABB][GEOM_CYLINDER] = |
577 |
|
|
&HeightFieldShapeCollider<AABB, Cylinder>::collide; |
578 |
|
17 |
collision_matrix[HF_AABB][GEOM_CONVEX] = |
579 |
|
|
&HeightFieldShapeCollider<AABB, ConvexBase>::collide; |
580 |
|
17 |
collision_matrix[HF_AABB][GEOM_PLANE] = |
581 |
|
|
&HeightFieldShapeCollider<AABB, Plane>::collide; |
582 |
|
17 |
collision_matrix[HF_AABB][GEOM_HALFSPACE] = |
583 |
|
|
&HeightFieldShapeCollider<AABB, Halfspace>::collide; |
584 |
|
17 |
collision_matrix[HF_AABB][GEOM_ELLIPSOID] = |
585 |
|
|
&HeightFieldShapeCollider<AABB, Ellipsoid>::collide; |
586 |
|
|
|
587 |
|
17 |
collision_matrix[HF_OBBRSS][GEOM_BOX] = |
588 |
|
|
&HeightFieldShapeCollider<OBBRSS, Box>::collide; |
589 |
|
17 |
collision_matrix[HF_OBBRSS][GEOM_SPHERE] = |
590 |
|
|
&HeightFieldShapeCollider<OBBRSS, Sphere>::collide; |
591 |
|
17 |
collision_matrix[HF_OBBRSS][GEOM_CAPSULE] = |
592 |
|
|
&HeightFieldShapeCollider<OBBRSS, Capsule>::collide; |
593 |
|
17 |
collision_matrix[HF_OBBRSS][GEOM_CONE] = |
594 |
|
|
&HeightFieldShapeCollider<OBBRSS, Cone>::collide; |
595 |
|
17 |
collision_matrix[HF_OBBRSS][GEOM_CYLINDER] = |
596 |
|
|
&HeightFieldShapeCollider<OBBRSS, Cylinder>::collide; |
597 |
|
17 |
collision_matrix[HF_OBBRSS][GEOM_CONVEX] = |
598 |
|
|
&HeightFieldShapeCollider<OBBRSS, ConvexBase>::collide; |
599 |
|
17 |
collision_matrix[HF_OBBRSS][GEOM_PLANE] = |
600 |
|
|
&HeightFieldShapeCollider<OBBRSS, Plane>::collide; |
601 |
|
17 |
collision_matrix[HF_OBBRSS][GEOM_HALFSPACE] = |
602 |
|
|
&HeightFieldShapeCollider<OBBRSS, Halfspace>::collide; |
603 |
|
17 |
collision_matrix[HF_OBBRSS][GEOM_ELLIPSOID] = |
604 |
|
|
&HeightFieldShapeCollider<OBBRSS, Ellipsoid>::collide; |
605 |
|
|
|
606 |
|
17 |
collision_matrix[BV_AABB][BV_AABB] = &BVHCollide<AABB>; |
607 |
|
17 |
collision_matrix[BV_OBB][BV_OBB] = &BVHCollide<OBB>; |
608 |
|
17 |
collision_matrix[BV_RSS][BV_RSS] = &BVHCollide<RSS>; |
609 |
|
17 |
collision_matrix[BV_KDOP16][BV_KDOP16] = &BVHCollide<KDOP<16> >; |
610 |
|
17 |
collision_matrix[BV_KDOP18][BV_KDOP18] = &BVHCollide<KDOP<18> >; |
611 |
|
17 |
collision_matrix[BV_KDOP24][BV_KDOP24] = &BVHCollide<KDOP<24> >; |
612 |
|
17 |
collision_matrix[BV_kIOS][BV_kIOS] = &BVHCollide<kIOS>; |
613 |
|
17 |
collision_matrix[BV_OBBRSS][BV_OBBRSS] = &BVHCollide<OBBRSS>; |
614 |
|
|
|
615 |
|
|
#ifdef HPP_FCL_HAS_OCTOMAP |
616 |
|
17 |
collision_matrix[GEOM_OCTREE][GEOM_BOX] = &OctreeCollide<OcTree, Box>; |
617 |
|
17 |
collision_matrix[GEOM_OCTREE][GEOM_SPHERE] = &OctreeCollide<OcTree, Sphere>; |
618 |
|
17 |
collision_matrix[GEOM_OCTREE][GEOM_CAPSULE] = &OctreeCollide<OcTree, Capsule>; |
619 |
|
17 |
collision_matrix[GEOM_OCTREE][GEOM_CONE] = &OctreeCollide<OcTree, Cone>; |
620 |
|
17 |
collision_matrix[GEOM_OCTREE][GEOM_CYLINDER] = |
621 |
|
|
&OctreeCollide<OcTree, Cylinder>; |
622 |
|
17 |
collision_matrix[GEOM_OCTREE][GEOM_CONVEX] = |
623 |
|
|
&OctreeCollide<OcTree, ConvexBase>; |
624 |
|
17 |
collision_matrix[GEOM_OCTREE][GEOM_PLANE] = &OctreeCollide<OcTree, Plane>; |
625 |
|
17 |
collision_matrix[GEOM_OCTREE][GEOM_HALFSPACE] = |
626 |
|
|
&OctreeCollide<OcTree, Halfspace>; |
627 |
|
17 |
collision_matrix[GEOM_OCTREE][GEOM_ELLIPSOID] = |
628 |
|
|
&OctreeCollide<OcTree, Ellipsoid>; |
629 |
|
|
|
630 |
|
17 |
collision_matrix[GEOM_BOX][GEOM_OCTREE] = &OctreeCollide<Box, OcTree>; |
631 |
|
17 |
collision_matrix[GEOM_SPHERE][GEOM_OCTREE] = &OctreeCollide<Sphere, OcTree>; |
632 |
|
17 |
collision_matrix[GEOM_CAPSULE][GEOM_OCTREE] = &OctreeCollide<Capsule, OcTree>; |
633 |
|
17 |
collision_matrix[GEOM_CONE][GEOM_OCTREE] = &OctreeCollide<Cone, OcTree>; |
634 |
|
17 |
collision_matrix[GEOM_CYLINDER][GEOM_OCTREE] = |
635 |
|
|
&OctreeCollide<Cylinder, OcTree>; |
636 |
|
17 |
collision_matrix[GEOM_CONVEX][GEOM_OCTREE] = |
637 |
|
|
&OctreeCollide<ConvexBase, OcTree>; |
638 |
|
17 |
collision_matrix[GEOM_PLANE][GEOM_OCTREE] = &OctreeCollide<Plane, OcTree>; |
639 |
|
17 |
collision_matrix[GEOM_HALFSPACE][GEOM_OCTREE] = |
640 |
|
|
&OctreeCollide<Halfspace, OcTree>; |
641 |
|
|
|
642 |
|
17 |
collision_matrix[GEOM_OCTREE][GEOM_OCTREE] = &OctreeCollide<OcTree, OcTree>; |
643 |
|
|
|
644 |
|
17 |
collision_matrix[GEOM_OCTREE][BV_AABB] = |
645 |
|
|
&OctreeCollide<OcTree, BVHModel<AABB> >; |
646 |
|
17 |
collision_matrix[GEOM_OCTREE][BV_OBB] = |
647 |
|
|
&OctreeCollide<OcTree, BVHModel<OBB> >; |
648 |
|
17 |
collision_matrix[GEOM_OCTREE][BV_RSS] = |
649 |
|
|
&OctreeCollide<OcTree, BVHModel<RSS> >; |
650 |
|
17 |
collision_matrix[GEOM_OCTREE][BV_OBBRSS] = |
651 |
|
|
&OctreeCollide<OcTree, BVHModel<OBBRSS> >; |
652 |
|
17 |
collision_matrix[GEOM_OCTREE][BV_kIOS] = |
653 |
|
|
&OctreeCollide<OcTree, BVHModel<kIOS> >; |
654 |
|
17 |
collision_matrix[GEOM_OCTREE][BV_KDOP16] = |
655 |
|
|
&OctreeCollide<OcTree, BVHModel<KDOP<16> > >; |
656 |
|
17 |
collision_matrix[GEOM_OCTREE][BV_KDOP18] = |
657 |
|
|
&OctreeCollide<OcTree, BVHModel<KDOP<18> > >; |
658 |
|
17 |
collision_matrix[GEOM_OCTREE][BV_KDOP24] = |
659 |
|
|
&OctreeCollide<OcTree, BVHModel<KDOP<24> > >; |
660 |
|
|
|
661 |
|
17 |
collision_matrix[BV_AABB][GEOM_OCTREE] = |
662 |
|
|
&OctreeCollide<BVHModel<AABB>, OcTree>; |
663 |
|
17 |
collision_matrix[BV_OBB][GEOM_OCTREE] = &OctreeCollide<BVHModel<OBB>, OcTree>; |
664 |
|
17 |
collision_matrix[BV_RSS][GEOM_OCTREE] = &OctreeCollide<BVHModel<RSS>, OcTree>; |
665 |
|
17 |
collision_matrix[BV_OBBRSS][GEOM_OCTREE] = |
666 |
|
|
&OctreeCollide<BVHModel<OBBRSS>, OcTree>; |
667 |
|
17 |
collision_matrix[BV_kIOS][GEOM_OCTREE] = |
668 |
|
|
&OctreeCollide<BVHModel<kIOS>, OcTree>; |
669 |
|
17 |
collision_matrix[BV_KDOP16][GEOM_OCTREE] = |
670 |
|
|
&OctreeCollide<BVHModel<KDOP<16> >, OcTree>; |
671 |
|
17 |
collision_matrix[BV_KDOP18][GEOM_OCTREE] = |
672 |
|
|
&OctreeCollide<BVHModel<KDOP<18> >, OcTree>; |
673 |
|
17 |
collision_matrix[BV_KDOP24][GEOM_OCTREE] = |
674 |
|
|
&OctreeCollide<BVHModel<KDOP<24> >, OcTree>; |
675 |
|
|
#endif |
676 |
|
17 |
} |
677 |
|
|
// template struct CollisionFunctionMatrix; |
678 |
|
|
} // namespace fcl |
679 |
|
|
|
680 |
|
|
} // namespace hpp |