GCC Code Coverage Report


Directory: ./
File: src/collision_func_matrix.cpp
Date: 2025-04-13 14:25:19
Exec Total Coverage
Lines: 286 317 90.2%
Branches: 29 158 18.4%

Line Branch Exec Source
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 "coal/collision_func_matrix.h"
39
40 #include "coal/internal/traversal_node_setup.h"
41 #include <../src/collision_node.h>
42 #include "coal/narrowphase/narrowphase.h"
43 #include "coal/internal/shape_shape_func.h"
44 #include "coal/shape/geometric_shapes_traits.h"
45 #include <../src/traits_traversal.h>
46
47 namespace coal {
48
49 #ifdef COAL_HAS_OCTOMAP
50
51 template <typename TypeA, typename TypeB>
52 6200 std::size_t OctreeCollide(const CollisionGeometry* o1, const Transform3s& tf1,
53 const CollisionGeometry* o2, const Transform3s& tf2,
54 const GJKSolver* nsolver,
55 const CollisionRequest& request,
56 CollisionResult& result) {
57
2/4
✓ Branch 1 taken 3100 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 3100 times.
6200 if (request.isSatisfied(result)) return result.numContacts();
58
59
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3100 times.
6200 if (request.security_margin < 0)
60 COAL_THROW_PRETTY("Negative security margin are not handled yet for Octree",
61 std::invalid_argument);
62
63
1/2
✓ Branch 1 taken 3100 times.
✗ Branch 2 not taken.
6200 typename TraversalTraitsCollision<TypeA, TypeB>::CollisionTraversal_t node(
64 request);
65
1/2
✓ Branch 0 taken 3100 times.
✗ Branch 1 not taken.
6200 const TypeA* obj1 = dynamic_cast<const TypeA*>(o1);
66
1/2
✓ Branch 0 taken 3100 times.
✗ Branch 1 not taken.
6200 const TypeB* obj2 = dynamic_cast<const TypeB*>(o2);
67 6200 OcTreeSolver otsolver(nsolver);
68
69
1/2
✓ Branch 1 taken 3100 times.
✗ Branch 2 not taken.
6200 initialize(node, *obj1, tf1, *obj2, tf2, &otsolver, result);
70
1/2
✓ Branch 1 taken 3100 times.
✗ Branch 2 not taken.
6200 collide(&node, request, result);
71
72 6200 return result.numContacts();
73 }
74
75 #endif
76
77 namespace details {
78 template <typename T_BVH, typename T_SH>
79 struct bvh_shape_traits {
80 enum { Options = RelativeTransformationIsIdentity };
81 };
82 #define BVH_SHAPE_DEFAULT_TO_ORIENTED(bv) \
83 template <typename T_SH> \
84 struct bvh_shape_traits<bv, T_SH> { \
85 enum { Options = 0 }; \
86 }
87 BVH_SHAPE_DEFAULT_TO_ORIENTED(OBB);
88 BVH_SHAPE_DEFAULT_TO_ORIENTED(RSS);
89 BVH_SHAPE_DEFAULT_TO_ORIENTED(kIOS);
90 BVH_SHAPE_DEFAULT_TO_ORIENTED(OBBRSS);
91 #undef BVH_SHAPE_DEFAULT_TO_ORIENTED
92 } // namespace details
93
94 /// \tparam _Options takes two values.
95 /// - RelativeTransformationIsIdentity if object 1 should be moved
96 /// into the frame of object 2 before computing collisions.
97 /// - 0 if the query should be made with non-aligned object frames.
98 template <typename T_BVH, typename T_SH,
99 int _Options = details::bvh_shape_traits<T_BVH, T_SH>::Options>
100 struct COAL_LOCAL BVHShapeCollider {
101 252 static std::size_t collide(const CollisionGeometry* o1,
102 const Transform3s& tf1,
103 const CollisionGeometry* o2,
104 const Transform3s& tf2, const GJKSolver* nsolver,
105 const CollisionRequest& request,
106 CollisionResult& result) {
107
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 126 times.
252 if (request.isSatisfied(result)) return result.numContacts();
108
109
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 126 times.
252 if (request.security_margin < 0)
110 COAL_THROW_PRETTY(
111 "Negative security margin are not handled yet for BVHModel",
112 std::invalid_argument);
113
114 if (_Options & RelativeTransformationIsIdentity)
115 return aligned(o1, tf1, o2, tf2, nsolver, request, result);
116 else
117 252 return oriented(o1, tf1, o2, tf2, nsolver, request, result);
118 } // namespace coal
119
120 static std::size_t aligned(const CollisionGeometry* o1,
121 const Transform3s& tf1,
122 const CollisionGeometry* o2,
123 const Transform3s& tf2, const GJKSolver* nsolver,
124 const CollisionRequest& request,
125 CollisionResult& result) {
126 if (request.isSatisfied(result)) return result.numContacts();
127
128 MeshShapeCollisionTraversalNode<T_BVH, T_SH,
129 RelativeTransformationIsIdentity>
130 node(request);
131 const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
132 BVHModel<T_BVH>* obj1_tmp = new BVHModel<T_BVH>(*obj1);
133 Transform3s tf1_tmp = tf1;
134 const T_SH* obj2 = static_cast<const T_SH*>(o2);
135
136 initialize(node, *obj1_tmp, tf1_tmp, *obj2, tf2, nsolver, result);
137 coal::collide(&node, request, result);
138
139 delete obj1_tmp;
140 return result.numContacts();
141 }
142
143 252 static std::size_t oriented(const CollisionGeometry* o1,
144 const Transform3s& tf1,
145 const CollisionGeometry* o2,
146 const Transform3s& tf2, const GJKSolver* nsolver,
147 const CollisionRequest& request,
148 CollisionResult& result) {
149
2/4
✓ Branch 1 taken 126 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 126 times.
252 if (request.isSatisfied(result)) return result.numContacts();
150
151
1/2
✓ Branch 1 taken 126 times.
✗ Branch 2 not taken.
252 MeshShapeCollisionTraversalNode<T_BVH, T_SH, 0> node(request);
152 252 const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
153 252 const T_SH* obj2 = static_cast<const T_SH*>(o2);
154
155
1/2
✓ Branch 1 taken 126 times.
✗ Branch 2 not taken.
252 initialize(node, *obj1, tf1, *obj2, tf2, nsolver, result);
156
1/2
✓ Branch 1 taken 126 times.
✗ Branch 2 not taken.
252 coal::collide(&node, request, result);
157 252 return result.numContacts();
158 }
159 };
160
161 /// @brief Collider functor for HeightField data structure
162 /// \tparam _Options takes two values.
163 /// - RelativeTransformationIsIdentity if object 1 should be moved
164 /// into the frame of object 2 before computing collisions.
165 /// - 0 if the query should be made with non-aligned object frames.
166 template <typename BV, typename Shape>
167 struct COAL_LOCAL HeightFieldShapeCollider {
168 typedef HeightField<BV> HF;
169
170 110 static std::size_t collide(const CollisionGeometry* o1,
171 const Transform3s& tf1,
172 const CollisionGeometry* o2,
173 const Transform3s& tf2, const GJKSolver* nsolver,
174 const CollisionRequest& request,
175 CollisionResult& result) {
176
2/4
✓ Branch 1 taken 55 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 55 times.
110 if (request.isSatisfied(result)) return result.numContacts();
177
178 110 const HF& height_field = static_cast<const HF&>(*o1);
179 110 const Shape& shape = static_cast<const Shape&>(*o2);
180
181
1/2
✓ Branch 1 taken 55 times.
✗ Branch 2 not taken.
110 HeightFieldShapeCollisionTraversalNode<BV, Shape, 0> node(request);
182
183
1/2
✓ Branch 1 taken 55 times.
✗ Branch 2 not taken.
110 initialize(node, height_field, tf1, shape, tf2, nsolver, result);
184
1/2
✓ Branch 1 taken 55 times.
✗ Branch 2 not taken.
110 coal::collide(&node, request, result);
185 110 return result.numContacts();
186 }
187 };
188
189 namespace details {
190 template <typename OrientedMeshCollisionTraversalNode, typename T_BVH>
191 21320 std::size_t orientedMeshCollide(const CollisionGeometry* o1,
192 const Transform3s& tf1,
193 const CollisionGeometry* o2,
194 const Transform3s& tf2,
195 const CollisionRequest& request,
196 CollisionResult& result) {
197
2/4
✓ Branch 1 taken 10660 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 10660 times.
21320 if (request.isSatisfied(result)) return result.numContacts();
198
199
1/2
✓ Branch 1 taken 10660 times.
✗ Branch 2 not taken.
21320 OrientedMeshCollisionTraversalNode node(request);
200 21320 const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
201 21320 const BVHModel<T_BVH>* obj2 = static_cast<const BVHModel<T_BVH>*>(o2);
202
203
1/2
✓ Branch 1 taken 10660 times.
✗ Branch 2 not taken.
21320 initialize(node, *obj1, tf1, *obj2, tf2, result);
204
1/2
✓ Branch 1 taken 10660 times.
✗ Branch 2 not taken.
21320 collide(&node, request, result);
205
206 21320 return result.numContacts();
207 }
208
209 } // namespace details
210
211 template <typename T_BVH>
212 std::size_t BVHCollide(const CollisionGeometry* o1, const Transform3s& tf1,
213 const CollisionGeometry* o2, const Transform3s& tf2,
214 const CollisionRequest& request,
215 CollisionResult& result) {
216 if (request.isSatisfied(result)) return result.numContacts();
217
218 // TODO(louis): each time we call collide on BVH-BVH, we:
219 // - Allocate 2 new BVHs
220 // - Copy and transform the vertices in both BVHs so that they are in the
221 // same frame
222 // - Recompute BVs of the BVH structure
223 // -> all that just to avoid doing (a few) rotations/translations of AABBs.
224 // Is it really worth it?
225 MeshCollisionTraversalNode<T_BVH> node(request);
226 const BVHModel<T_BVH>* obj1 = static_cast<const BVHModel<T_BVH>*>(o1);
227 const BVHModel<T_BVH>* obj2 = static_cast<const BVHModel<T_BVH>*>(o2);
228 BVHModel<T_BVH>* obj1_tmp = new BVHModel<T_BVH>(*obj1);
229 Transform3s tf1_tmp = tf1;
230 BVHModel<T_BVH>* obj2_tmp = new BVHModel<T_BVH>(*obj2);
231 Transform3s tf2_tmp = tf2;
232
233 initialize(node, *obj1_tmp, tf1_tmp, *obj2_tmp, tf2_tmp, result);
234 coal::collide(&node, request, result);
235
236 delete obj1_tmp;
237 delete obj2_tmp;
238
239 return result.numContacts();
240 }
241
242 template <>
243 3 std::size_t BVHCollide<OBB>(const CollisionGeometry* o1, const Transform3s& tf1,
244 const CollisionGeometry* o2, const Transform3s& tf2,
245 const CollisionRequest& request,
246 CollisionResult& result) {
247 3 return details::orientedMeshCollide<MeshCollisionTraversalNodeOBB, OBB>(
248 3 o1, tf1, o2, tf2, request, result);
249 }
250
251 template <>
252 10657 std::size_t BVHCollide<OBBRSS>(const CollisionGeometry* o1,
253 const Transform3s& tf1,
254 const CollisionGeometry* o2,
255 const Transform3s& tf2,
256 const CollisionRequest& request,
257 CollisionResult& result) {
258 10657 return details::orientedMeshCollide<MeshCollisionTraversalNodeOBBRSS, OBBRSS>(
259 10657 o1, tf1, o2, tf2, request, result);
260 }
261
262 template <>
263 std::size_t BVHCollide<kIOS>(const CollisionGeometry* o1,
264 const Transform3s& tf1,
265 const CollisionGeometry* o2,
266 const Transform3s& tf2,
267 const CollisionRequest& request,
268 CollisionResult& result) {
269 return details::orientedMeshCollide<MeshCollisionTraversalNodekIOS, kIOS>(
270 o1, tf1, o2, tf2, request, result);
271 }
272
273 template <typename T_BVH>
274 21320 std::size_t BVHCollide(const CollisionGeometry* o1, const Transform3s& tf1,
275 const CollisionGeometry* o2, const Transform3s& tf2,
276 const GJKSolver* /*nsolver*/,
277 const CollisionRequest& request,
278 CollisionResult& result) {
279 21320 return BVHCollide<T_BVH>(o1, tf1, o2, tf2, request, result);
280 }
281
282 23 CollisionFunctionMatrix::CollisionFunctionMatrix() {
283
2/2
✓ Branch 0 taken 506 times.
✓ Branch 1 taken 23 times.
529 for (int i = 0; i < NODE_COUNT; ++i) {
284
2/2
✓ Branch 0 taken 11132 times.
✓ Branch 1 taken 506 times.
11638 for (int j = 0; j < NODE_COUNT; ++j) collision_matrix[i][j] = NULL;
285 }
286
287 23 collision_matrix[GEOM_BOX][GEOM_BOX] = &ShapeShapeCollide<Box, Box>;
288 23 collision_matrix[GEOM_BOX][GEOM_SPHERE] = &ShapeShapeCollide<Box, Sphere>;
289 23 collision_matrix[GEOM_BOX][GEOM_CAPSULE] = &ShapeShapeCollide<Box, Capsule>;
290 23 collision_matrix[GEOM_BOX][GEOM_CONE] = &ShapeShapeCollide<Box, Cone>;
291 23 collision_matrix[GEOM_BOX][GEOM_CYLINDER] = &ShapeShapeCollide<Box, Cylinder>;
292 23 collision_matrix[GEOM_BOX][GEOM_CONVEX] = &ShapeShapeCollide<Box, ConvexBase>;
293 23 collision_matrix[GEOM_BOX][GEOM_PLANE] = &ShapeShapeCollide<Box, Plane>;
294 23 collision_matrix[GEOM_BOX][GEOM_HALFSPACE] =
295 &ShapeShapeCollide<Box, Halfspace>;
296 23 collision_matrix[GEOM_BOX][GEOM_ELLIPSOID] =
297 &ShapeShapeCollide<Box, Ellipsoid>;
298 23 collision_matrix[GEOM_BOX][GEOM_TRIANGLE] =
299 &ShapeShapeCollide<Box, TriangleP>;
300
301 23 collision_matrix[GEOM_SPHERE][GEOM_BOX] = &ShapeShapeCollide<Sphere, Box>;
302 23 collision_matrix[GEOM_SPHERE][GEOM_SPHERE] =
303 &ShapeShapeCollide<Sphere, Sphere>;
304 23 collision_matrix[GEOM_SPHERE][GEOM_CAPSULE] =
305 &ShapeShapeCollide<Sphere, Capsule>;
306 23 collision_matrix[GEOM_SPHERE][GEOM_CONE] = &ShapeShapeCollide<Sphere, Cone>;
307 23 collision_matrix[GEOM_SPHERE][GEOM_CYLINDER] =
308 &ShapeShapeCollide<Sphere, Cylinder>;
309 23 collision_matrix[GEOM_SPHERE][GEOM_CONVEX] =
310 &ShapeShapeCollide<Sphere, ConvexBase>;
311 23 collision_matrix[GEOM_SPHERE][GEOM_PLANE] = &ShapeShapeCollide<Sphere, Plane>;
312 23 collision_matrix[GEOM_SPHERE][GEOM_HALFSPACE] =
313 &ShapeShapeCollide<Sphere, Halfspace>;
314 23 collision_matrix[GEOM_SPHERE][GEOM_ELLIPSOID] =
315 &ShapeShapeCollide<Sphere, Ellipsoid>;
316 23 collision_matrix[GEOM_SPHERE][GEOM_TRIANGLE] =
317 &ShapeShapeCollide<Sphere, TriangleP>;
318
319 23 collision_matrix[GEOM_ELLIPSOID][GEOM_BOX] =
320 &ShapeShapeCollide<Ellipsoid, Box>;
321 23 collision_matrix[GEOM_ELLIPSOID][GEOM_SPHERE] =
322 &ShapeShapeCollide<Ellipsoid, Sphere>;
323 23 collision_matrix[GEOM_ELLIPSOID][GEOM_CAPSULE] =
324 &ShapeShapeCollide<Ellipsoid, Capsule>;
325 23 collision_matrix[GEOM_ELLIPSOID][GEOM_CONE] =
326 &ShapeShapeCollide<Ellipsoid, Cone>;
327 23 collision_matrix[GEOM_ELLIPSOID][GEOM_CYLINDER] =
328 &ShapeShapeCollide<Ellipsoid, Cylinder>;
329 23 collision_matrix[GEOM_ELLIPSOID][GEOM_CONVEX] =
330 &ShapeShapeCollide<Ellipsoid, ConvexBase>;
331 23 collision_matrix[GEOM_ELLIPSOID][GEOM_PLANE] =
332 &ShapeShapeCollide<Ellipsoid, Plane>;
333 23 collision_matrix[GEOM_ELLIPSOID][GEOM_HALFSPACE] =
334 &ShapeShapeCollide<Ellipsoid, Halfspace>;
335 23 collision_matrix[GEOM_ELLIPSOID][GEOM_ELLIPSOID] =
336 &ShapeShapeCollide<Ellipsoid, Ellipsoid>;
337 23 collision_matrix[GEOM_ELLIPSOID][GEOM_TRIANGLE] =
338 &ShapeShapeCollide<Ellipsoid, TriangleP>;
339
340 23 collision_matrix[GEOM_CAPSULE][GEOM_BOX] = &ShapeShapeCollide<Capsule, Box>;
341 23 collision_matrix[GEOM_CAPSULE][GEOM_SPHERE] =
342 &ShapeShapeCollide<Capsule, Sphere>;
343 23 collision_matrix[GEOM_CAPSULE][GEOM_CAPSULE] =
344 &ShapeShapeCollide<Capsule, Capsule>;
345 23 collision_matrix[GEOM_CAPSULE][GEOM_CONE] = &ShapeShapeCollide<Capsule, Cone>;
346 23 collision_matrix[GEOM_CAPSULE][GEOM_CYLINDER] =
347 &ShapeShapeCollide<Capsule, Cylinder>;
348 23 collision_matrix[GEOM_CAPSULE][GEOM_CONVEX] =
349 &ShapeShapeCollide<Capsule, ConvexBase>;
350 23 collision_matrix[GEOM_CAPSULE][GEOM_PLANE] =
351 &ShapeShapeCollide<Capsule, Plane>;
352 23 collision_matrix[GEOM_CAPSULE][GEOM_HALFSPACE] =
353 &ShapeShapeCollide<Capsule, Halfspace>;
354 23 collision_matrix[GEOM_CAPSULE][GEOM_ELLIPSOID] =
355 &ShapeShapeCollide<Capsule, Ellipsoid>;
356 23 collision_matrix[GEOM_CAPSULE][GEOM_TRIANGLE] =
357 &ShapeShapeCollide<Capsule, TriangleP>;
358
359 23 collision_matrix[GEOM_CONE][GEOM_BOX] = &ShapeShapeCollide<Cone, Box>;
360 23 collision_matrix[GEOM_CONE][GEOM_SPHERE] = &ShapeShapeCollide<Cone, Sphere>;
361 23 collision_matrix[GEOM_CONE][GEOM_CAPSULE] = &ShapeShapeCollide<Cone, Capsule>;
362 23 collision_matrix[GEOM_CONE][GEOM_CONE] = &ShapeShapeCollide<Cone, Cone>;
363 23 collision_matrix[GEOM_CONE][GEOM_CYLINDER] =
364 &ShapeShapeCollide<Cone, Cylinder>;
365 23 collision_matrix[GEOM_CONE][GEOM_CONVEX] =
366 &ShapeShapeCollide<Cone, ConvexBase>;
367 23 collision_matrix[GEOM_CONE][GEOM_PLANE] = &ShapeShapeCollide<Cone, Plane>;
368 23 collision_matrix[GEOM_CONE][GEOM_HALFSPACE] =
369 &ShapeShapeCollide<Cone, Halfspace>;
370 23 collision_matrix[GEOM_CONE][GEOM_ELLIPSOID] =
371 &ShapeShapeCollide<Cone, Ellipsoid>;
372 23 collision_matrix[GEOM_CONE][GEOM_TRIANGLE] =
373 &ShapeShapeCollide<Cone, TriangleP>;
374
375 23 collision_matrix[GEOM_CYLINDER][GEOM_BOX] = &ShapeShapeCollide<Cylinder, Box>;
376 23 collision_matrix[GEOM_CYLINDER][GEOM_SPHERE] =
377 &ShapeShapeCollide<Cylinder, Sphere>;
378 23 collision_matrix[GEOM_CYLINDER][GEOM_CAPSULE] =
379 &ShapeShapeCollide<Cylinder, Capsule>;
380 23 collision_matrix[GEOM_CYLINDER][GEOM_CONE] =
381 &ShapeShapeCollide<Cylinder, Cone>;
382 23 collision_matrix[GEOM_CYLINDER][GEOM_CYLINDER] =
383 &ShapeShapeCollide<Cylinder, Cylinder>;
384 23 collision_matrix[GEOM_CYLINDER][GEOM_CONVEX] =
385 &ShapeShapeCollide<Cylinder, ConvexBase>;
386 23 collision_matrix[GEOM_CYLINDER][GEOM_PLANE] =
387 &ShapeShapeCollide<Cylinder, Plane>;
388 23 collision_matrix[GEOM_CYLINDER][GEOM_HALFSPACE] =
389 &ShapeShapeCollide<Cylinder, Halfspace>;
390 23 collision_matrix[GEOM_CYLINDER][GEOM_ELLIPSOID] =
391 &ShapeShapeCollide<Cylinder, Ellipsoid>;
392 23 collision_matrix[GEOM_CYLINDER][GEOM_TRIANGLE] =
393 &ShapeShapeCollide<Cylinder, TriangleP>;
394
395 23 collision_matrix[GEOM_CONVEX][GEOM_BOX] = &ShapeShapeCollide<ConvexBase, Box>;
396 23 collision_matrix[GEOM_CONVEX][GEOM_SPHERE] =
397 &ShapeShapeCollide<ConvexBase, Sphere>;
398 23 collision_matrix[GEOM_CONVEX][GEOM_CAPSULE] =
399 &ShapeShapeCollide<ConvexBase, Capsule>;
400 23 collision_matrix[GEOM_CONVEX][GEOM_CONE] =
401 &ShapeShapeCollide<ConvexBase, Cone>;
402 23 collision_matrix[GEOM_CONVEX][GEOM_CYLINDER] =
403 &ShapeShapeCollide<ConvexBase, Cylinder>;
404 23 collision_matrix[GEOM_CONVEX][GEOM_CONVEX] =
405 &ShapeShapeCollide<ConvexBase, ConvexBase>;
406 23 collision_matrix[GEOM_CONVEX][GEOM_PLANE] =
407 &ShapeShapeCollide<ConvexBase, Plane>;
408 23 collision_matrix[GEOM_CONVEX][GEOM_HALFSPACE] =
409 &ShapeShapeCollide<ConvexBase, Halfspace>;
410 23 collision_matrix[GEOM_CONVEX][GEOM_ELLIPSOID] =
411 &ShapeShapeCollide<ConvexBase, Ellipsoid>;
412 23 collision_matrix[GEOM_CONVEX][GEOM_TRIANGLE] =
413 &ShapeShapeCollide<ConvexBase, TriangleP>;
414
415 23 collision_matrix[GEOM_PLANE][GEOM_BOX] = &ShapeShapeCollide<Plane, Box>;
416 23 collision_matrix[GEOM_PLANE][GEOM_SPHERE] = &ShapeShapeCollide<Plane, Sphere>;
417 23 collision_matrix[GEOM_PLANE][GEOM_CAPSULE] =
418 &ShapeShapeCollide<Plane, Capsule>;
419 23 collision_matrix[GEOM_PLANE][GEOM_CONE] = &ShapeShapeCollide<Plane, Cone>;
420 23 collision_matrix[GEOM_PLANE][GEOM_CYLINDER] =
421 &ShapeShapeCollide<Plane, Cylinder>;
422 23 collision_matrix[GEOM_PLANE][GEOM_CONVEX] =
423 &ShapeShapeCollide<Plane, ConvexBase>;
424 23 collision_matrix[GEOM_PLANE][GEOM_PLANE] = &ShapeShapeCollide<Plane, Plane>;
425 23 collision_matrix[GEOM_PLANE][GEOM_HALFSPACE] =
426 &ShapeShapeCollide<Plane, Halfspace>;
427 23 collision_matrix[GEOM_PLANE][GEOM_ELLIPSOID] =
428 &ShapeShapeCollide<Plane, Ellipsoid>;
429 23 collision_matrix[GEOM_PLANE][GEOM_TRIANGLE] =
430 &ShapeShapeCollide<Plane, TriangleP>;
431
432 23 collision_matrix[GEOM_HALFSPACE][GEOM_BOX] =
433 &ShapeShapeCollide<Halfspace, Box>;
434 23 collision_matrix[GEOM_HALFSPACE][GEOM_SPHERE] =
435 &ShapeShapeCollide<Halfspace, Sphere>;
436 23 collision_matrix[GEOM_HALFSPACE][GEOM_CAPSULE] =
437 &ShapeShapeCollide<Halfspace, Capsule>;
438 23 collision_matrix[GEOM_HALFSPACE][GEOM_CONE] =
439 &ShapeShapeCollide<Halfspace, Cone>;
440 23 collision_matrix[GEOM_HALFSPACE][GEOM_CYLINDER] =
441 &ShapeShapeCollide<Halfspace, Cylinder>;
442 23 collision_matrix[GEOM_HALFSPACE][GEOM_CONVEX] =
443 &ShapeShapeCollide<Halfspace, ConvexBase>;
444 23 collision_matrix[GEOM_HALFSPACE][GEOM_PLANE] =
445 &ShapeShapeCollide<Halfspace, Plane>;
446 23 collision_matrix[GEOM_HALFSPACE][GEOM_HALFSPACE] =
447 &ShapeShapeCollide<Halfspace, Halfspace>;
448 23 collision_matrix[GEOM_HALFSPACE][GEOM_ELLIPSOID] =
449 &ShapeShapeCollide<Halfspace, Ellipsoid>;
450 23 collision_matrix[GEOM_HALFSPACE][GEOM_TRIANGLE] =
451 &ShapeShapeCollide<Halfspace, TriangleP>;
452
453 23 collision_matrix[GEOM_TRIANGLE][GEOM_BOX] =
454 &ShapeShapeCollide<TriangleP, Box>;
455 23 collision_matrix[GEOM_TRIANGLE][GEOM_SPHERE] =
456 &ShapeShapeCollide<TriangleP, Sphere>;
457 23 collision_matrix[GEOM_TRIANGLE][GEOM_CAPSULE] =
458 &ShapeShapeCollide<TriangleP, Capsule>;
459 23 collision_matrix[GEOM_TRIANGLE][GEOM_CONE] =
460 &ShapeShapeCollide<TriangleP, Cone>;
461 23 collision_matrix[GEOM_TRIANGLE][GEOM_CYLINDER] =
462 &ShapeShapeCollide<TriangleP, Cylinder>;
463 23 collision_matrix[GEOM_TRIANGLE][GEOM_CONVEX] =
464 &ShapeShapeCollide<TriangleP, ConvexBase>;
465 23 collision_matrix[GEOM_TRIANGLE][GEOM_PLANE] =
466 &ShapeShapeCollide<TriangleP, Plane>;
467 23 collision_matrix[GEOM_TRIANGLE][GEOM_HALFSPACE] =
468 &ShapeShapeCollide<TriangleP, Halfspace>;
469 23 collision_matrix[GEOM_TRIANGLE][GEOM_ELLIPSOID] =
470 &ShapeShapeCollide<TriangleP, Ellipsoid>;
471 23 collision_matrix[GEOM_TRIANGLE][GEOM_TRIANGLE] =
472 &ShapeShapeCollide<TriangleP, TriangleP>;
473
474 23 collision_matrix[BV_AABB][GEOM_BOX] = &BVHShapeCollider<AABB, Box>::collide;
475 23 collision_matrix[BV_AABB][GEOM_SPHERE] =
476 &BVHShapeCollider<AABB, Sphere>::collide;
477 23 collision_matrix[BV_AABB][GEOM_CAPSULE] =
478 &BVHShapeCollider<AABB, Capsule>::collide;
479 23 collision_matrix[BV_AABB][GEOM_CONE] = &BVHShapeCollider<AABB, Cone>::collide;
480 23 collision_matrix[BV_AABB][GEOM_CYLINDER] =
481 &BVHShapeCollider<AABB, Cylinder>::collide;
482 23 collision_matrix[BV_AABB][GEOM_CONVEX] =
483 &BVHShapeCollider<AABB, ConvexBase>::collide;
484 23 collision_matrix[BV_AABB][GEOM_PLANE] =
485 &BVHShapeCollider<AABB, Plane>::collide;
486 23 collision_matrix[BV_AABB][GEOM_HALFSPACE] =
487 &BVHShapeCollider<AABB, Halfspace>::collide;
488 23 collision_matrix[BV_AABB][GEOM_ELLIPSOID] =
489 &BVHShapeCollider<AABB, Ellipsoid>::collide;
490
491 23 collision_matrix[BV_OBB][GEOM_BOX] = &BVHShapeCollider<OBB, Box>::collide;
492 23 collision_matrix[BV_OBB][GEOM_SPHERE] =
493 &BVHShapeCollider<OBB, Sphere>::collide;
494 23 collision_matrix[BV_OBB][GEOM_CAPSULE] =
495 &BVHShapeCollider<OBB, Capsule>::collide;
496 23 collision_matrix[BV_OBB][GEOM_CONE] = &BVHShapeCollider<OBB, Cone>::collide;
497 23 collision_matrix[BV_OBB][GEOM_CYLINDER] =
498 &BVHShapeCollider<OBB, Cylinder>::collide;
499 23 collision_matrix[BV_OBB][GEOM_CONVEX] =
500 &BVHShapeCollider<OBB, ConvexBase>::collide;
501 23 collision_matrix[BV_OBB][GEOM_PLANE] = &BVHShapeCollider<OBB, Plane>::collide;
502 23 collision_matrix[BV_OBB][GEOM_HALFSPACE] =
503 &BVHShapeCollider<OBB, Halfspace>::collide;
504 23 collision_matrix[BV_OBB][GEOM_ELLIPSOID] =
505 &BVHShapeCollider<OBB, Ellipsoid>::collide;
506
507 23 collision_matrix[BV_RSS][GEOM_BOX] = &BVHShapeCollider<RSS, Box>::collide;
508 23 collision_matrix[BV_RSS][GEOM_SPHERE] =
509 &BVHShapeCollider<RSS, Sphere>::collide;
510 23 collision_matrix[BV_RSS][GEOM_CAPSULE] =
511 &BVHShapeCollider<RSS, Capsule>::collide;
512 23 collision_matrix[BV_RSS][GEOM_CONE] = &BVHShapeCollider<RSS, Cone>::collide;
513 23 collision_matrix[BV_RSS][GEOM_CYLINDER] =
514 &BVHShapeCollider<RSS, Cylinder>::collide;
515 23 collision_matrix[BV_RSS][GEOM_CONVEX] =
516 &BVHShapeCollider<RSS, ConvexBase>::collide;
517 23 collision_matrix[BV_RSS][GEOM_PLANE] = &BVHShapeCollider<RSS, Plane>::collide;
518 23 collision_matrix[BV_RSS][GEOM_HALFSPACE] =
519 &BVHShapeCollider<RSS, Halfspace>::collide;
520 23 collision_matrix[BV_RSS][GEOM_ELLIPSOID] =
521 &BVHShapeCollider<RSS, Ellipsoid>::collide;
522
523 23 collision_matrix[BV_KDOP16][GEOM_BOX] =
524 &BVHShapeCollider<KDOP<16>, Box>::collide;
525 23 collision_matrix[BV_KDOP16][GEOM_SPHERE] =
526 &BVHShapeCollider<KDOP<16>, Sphere>::collide;
527 23 collision_matrix[BV_KDOP16][GEOM_CAPSULE] =
528 &BVHShapeCollider<KDOP<16>, Capsule>::collide;
529 23 collision_matrix[BV_KDOP16][GEOM_CONE] =
530 &BVHShapeCollider<KDOP<16>, Cone>::collide;
531 23 collision_matrix[BV_KDOP16][GEOM_CYLINDER] =
532 &BVHShapeCollider<KDOP<16>, Cylinder>::collide;
533 23 collision_matrix[BV_KDOP16][GEOM_CONVEX] =
534 &BVHShapeCollider<KDOP<16>, ConvexBase>::collide;
535 23 collision_matrix[BV_KDOP16][GEOM_PLANE] =
536 &BVHShapeCollider<KDOP<16>, Plane>::collide;
537 23 collision_matrix[BV_KDOP16][GEOM_HALFSPACE] =
538 &BVHShapeCollider<KDOP<16>, Halfspace>::collide;
539 23 collision_matrix[BV_KDOP16][GEOM_ELLIPSOID] =
540 &BVHShapeCollider<KDOP<16>, Ellipsoid>::collide;
541
542 23 collision_matrix[BV_KDOP18][GEOM_BOX] =
543 &BVHShapeCollider<KDOP<18>, Box>::collide;
544 23 collision_matrix[BV_KDOP18][GEOM_SPHERE] =
545 &BVHShapeCollider<KDOP<18>, Sphere>::collide;
546 23 collision_matrix[BV_KDOP18][GEOM_CAPSULE] =
547 &BVHShapeCollider<KDOP<18>, Capsule>::collide;
548 23 collision_matrix[BV_KDOP18][GEOM_CONE] =
549 &BVHShapeCollider<KDOP<18>, Cone>::collide;
550 23 collision_matrix[BV_KDOP18][GEOM_CYLINDER] =
551 &BVHShapeCollider<KDOP<18>, Cylinder>::collide;
552 23 collision_matrix[BV_KDOP18][GEOM_CONVEX] =
553 &BVHShapeCollider<KDOP<18>, ConvexBase>::collide;
554 23 collision_matrix[BV_KDOP18][GEOM_PLANE] =
555 &BVHShapeCollider<KDOP<18>, Plane>::collide;
556 23 collision_matrix[BV_KDOP18][GEOM_HALFSPACE] =
557 &BVHShapeCollider<KDOP<18>, Halfspace>::collide;
558 23 collision_matrix[BV_KDOP18][GEOM_ELLIPSOID] =
559 &BVHShapeCollider<KDOP<18>, Ellipsoid>::collide;
560
561 23 collision_matrix[BV_KDOP24][GEOM_BOX] =
562 &BVHShapeCollider<KDOP<24>, Box>::collide;
563 23 collision_matrix[BV_KDOP24][GEOM_SPHERE] =
564 &BVHShapeCollider<KDOP<24>, Sphere>::collide;
565 23 collision_matrix[BV_KDOP24][GEOM_CAPSULE] =
566 &BVHShapeCollider<KDOP<24>, Capsule>::collide;
567 23 collision_matrix[BV_KDOP24][GEOM_CONE] =
568 &BVHShapeCollider<KDOP<24>, Cone>::collide;
569 23 collision_matrix[BV_KDOP24][GEOM_CYLINDER] =
570 &BVHShapeCollider<KDOP<24>, Cylinder>::collide;
571 23 collision_matrix[BV_KDOP24][GEOM_CONVEX] =
572 &BVHShapeCollider<KDOP<24>, ConvexBase>::collide;
573 23 collision_matrix[BV_KDOP24][GEOM_PLANE] =
574 &BVHShapeCollider<KDOP<24>, Plane>::collide;
575 23 collision_matrix[BV_KDOP24][GEOM_HALFSPACE] =
576 &BVHShapeCollider<KDOP<24>, Halfspace>::collide;
577 23 collision_matrix[BV_KDOP24][GEOM_ELLIPSOID] =
578 &BVHShapeCollider<KDOP<24>, Ellipsoid>::collide;
579
580 23 collision_matrix[BV_kIOS][GEOM_BOX] = &BVHShapeCollider<kIOS, Box>::collide;
581 23 collision_matrix[BV_kIOS][GEOM_SPHERE] =
582 &BVHShapeCollider<kIOS, Sphere>::collide;
583 23 collision_matrix[BV_kIOS][GEOM_CAPSULE] =
584 &BVHShapeCollider<kIOS, Capsule>::collide;
585 23 collision_matrix[BV_kIOS][GEOM_CONE] = &BVHShapeCollider<kIOS, Cone>::collide;
586 23 collision_matrix[BV_kIOS][GEOM_CYLINDER] =
587 &BVHShapeCollider<kIOS, Cylinder>::collide;
588 23 collision_matrix[BV_kIOS][GEOM_CONVEX] =
589 &BVHShapeCollider<kIOS, ConvexBase>::collide;
590 23 collision_matrix[BV_kIOS][GEOM_PLANE] =
591 &BVHShapeCollider<kIOS, Plane>::collide;
592 23 collision_matrix[BV_kIOS][GEOM_HALFSPACE] =
593 &BVHShapeCollider<kIOS, Halfspace>::collide;
594 23 collision_matrix[BV_kIOS][GEOM_ELLIPSOID] =
595 &BVHShapeCollider<kIOS, Ellipsoid>::collide;
596
597 23 collision_matrix[BV_OBBRSS][GEOM_BOX] =
598 &BVHShapeCollider<OBBRSS, Box>::collide;
599 23 collision_matrix[BV_OBBRSS][GEOM_SPHERE] =
600 &BVHShapeCollider<OBBRSS, Sphere>::collide;
601 23 collision_matrix[BV_OBBRSS][GEOM_CAPSULE] =
602 &BVHShapeCollider<OBBRSS, Capsule>::collide;
603 23 collision_matrix[BV_OBBRSS][GEOM_CONE] =
604 &BVHShapeCollider<OBBRSS, Cone>::collide;
605 23 collision_matrix[BV_OBBRSS][GEOM_CYLINDER] =
606 &BVHShapeCollider<OBBRSS, Cylinder>::collide;
607 23 collision_matrix[BV_OBBRSS][GEOM_CONVEX] =
608 &BVHShapeCollider<OBBRSS, ConvexBase>::collide;
609 23 collision_matrix[BV_OBBRSS][GEOM_PLANE] =
610 &BVHShapeCollider<OBBRSS, Plane>::collide;
611 23 collision_matrix[BV_OBBRSS][GEOM_HALFSPACE] =
612 &BVHShapeCollider<OBBRSS, Halfspace>::collide;
613 23 collision_matrix[BV_OBBRSS][GEOM_ELLIPSOID] =
614 &BVHShapeCollider<OBBRSS, Ellipsoid>::collide;
615
616 23 collision_matrix[HF_AABB][GEOM_BOX] =
617 &HeightFieldShapeCollider<AABB, Box>::collide;
618 23 collision_matrix[HF_AABB][GEOM_SPHERE] =
619 &HeightFieldShapeCollider<AABB, Sphere>::collide;
620 23 collision_matrix[HF_AABB][GEOM_CAPSULE] =
621 &HeightFieldShapeCollider<AABB, Capsule>::collide;
622 23 collision_matrix[HF_AABB][GEOM_CONE] =
623 &HeightFieldShapeCollider<AABB, Cone>::collide;
624 23 collision_matrix[HF_AABB][GEOM_CYLINDER] =
625 &HeightFieldShapeCollider<AABB, Cylinder>::collide;
626 23 collision_matrix[HF_AABB][GEOM_CONVEX] =
627 &HeightFieldShapeCollider<AABB, ConvexBase>::collide;
628 23 collision_matrix[HF_AABB][GEOM_PLANE] =
629 &HeightFieldShapeCollider<AABB, Plane>::collide;
630 23 collision_matrix[HF_AABB][GEOM_HALFSPACE] =
631 &HeightFieldShapeCollider<AABB, Halfspace>::collide;
632 23 collision_matrix[HF_AABB][GEOM_ELLIPSOID] =
633 &HeightFieldShapeCollider<AABB, Ellipsoid>::collide;
634
635 23 collision_matrix[HF_OBBRSS][GEOM_BOX] =
636 &HeightFieldShapeCollider<OBBRSS, Box>::collide;
637 23 collision_matrix[HF_OBBRSS][GEOM_SPHERE] =
638 &HeightFieldShapeCollider<OBBRSS, Sphere>::collide;
639 23 collision_matrix[HF_OBBRSS][GEOM_CAPSULE] =
640 &HeightFieldShapeCollider<OBBRSS, Capsule>::collide;
641 23 collision_matrix[HF_OBBRSS][GEOM_CONE] =
642 &HeightFieldShapeCollider<OBBRSS, Cone>::collide;
643 23 collision_matrix[HF_OBBRSS][GEOM_CYLINDER] =
644 &HeightFieldShapeCollider<OBBRSS, Cylinder>::collide;
645 23 collision_matrix[HF_OBBRSS][GEOM_CONVEX] =
646 &HeightFieldShapeCollider<OBBRSS, ConvexBase>::collide;
647 23 collision_matrix[HF_OBBRSS][GEOM_PLANE] =
648 &HeightFieldShapeCollider<OBBRSS, Plane>::collide;
649 23 collision_matrix[HF_OBBRSS][GEOM_HALFSPACE] =
650 &HeightFieldShapeCollider<OBBRSS, Halfspace>::collide;
651 23 collision_matrix[HF_OBBRSS][GEOM_ELLIPSOID] =
652 &HeightFieldShapeCollider<OBBRSS, Ellipsoid>::collide;
653
654 23 collision_matrix[BV_AABB][BV_AABB] = &BVHCollide<AABB>;
655 23 collision_matrix[BV_OBB][BV_OBB] = &BVHCollide<OBB>;
656 23 collision_matrix[BV_RSS][BV_RSS] = &BVHCollide<RSS>;
657 23 collision_matrix[BV_KDOP16][BV_KDOP16] = &BVHCollide<KDOP<16> >;
658 23 collision_matrix[BV_KDOP18][BV_KDOP18] = &BVHCollide<KDOP<18> >;
659 23 collision_matrix[BV_KDOP24][BV_KDOP24] = &BVHCollide<KDOP<24> >;
660 23 collision_matrix[BV_kIOS][BV_kIOS] = &BVHCollide<kIOS>;
661 23 collision_matrix[BV_OBBRSS][BV_OBBRSS] = &BVHCollide<OBBRSS>;
662
663 #ifdef COAL_HAS_OCTOMAP
664 23 collision_matrix[GEOM_OCTREE][GEOM_BOX] = &OctreeCollide<OcTree, Box>;
665 23 collision_matrix[GEOM_OCTREE][GEOM_SPHERE] = &OctreeCollide<OcTree, Sphere>;
666 23 collision_matrix[GEOM_OCTREE][GEOM_CAPSULE] = &OctreeCollide<OcTree, Capsule>;
667 23 collision_matrix[GEOM_OCTREE][GEOM_CONE] = &OctreeCollide<OcTree, Cone>;
668 23 collision_matrix[GEOM_OCTREE][GEOM_CYLINDER] =
669 &OctreeCollide<OcTree, Cylinder>;
670 23 collision_matrix[GEOM_OCTREE][GEOM_CONVEX] =
671 &OctreeCollide<OcTree, ConvexBase>;
672 23 collision_matrix[GEOM_OCTREE][GEOM_PLANE] = &OctreeCollide<OcTree, Plane>;
673 23 collision_matrix[GEOM_OCTREE][GEOM_HALFSPACE] =
674 &OctreeCollide<OcTree, Halfspace>;
675 23 collision_matrix[GEOM_OCTREE][GEOM_ELLIPSOID] =
676 &OctreeCollide<OcTree, Ellipsoid>;
677
678 23 collision_matrix[GEOM_BOX][GEOM_OCTREE] = &OctreeCollide<Box, OcTree>;
679 23 collision_matrix[GEOM_SPHERE][GEOM_OCTREE] = &OctreeCollide<Sphere, OcTree>;
680 23 collision_matrix[GEOM_CAPSULE][GEOM_OCTREE] = &OctreeCollide<Capsule, OcTree>;
681 23 collision_matrix[GEOM_CONE][GEOM_OCTREE] = &OctreeCollide<Cone, OcTree>;
682 23 collision_matrix[GEOM_CYLINDER][GEOM_OCTREE] =
683 &OctreeCollide<Cylinder, OcTree>;
684 23 collision_matrix[GEOM_CONVEX][GEOM_OCTREE] =
685 &OctreeCollide<ConvexBase, OcTree>;
686 23 collision_matrix[GEOM_PLANE][GEOM_OCTREE] = &OctreeCollide<Plane, OcTree>;
687 23 collision_matrix[GEOM_HALFSPACE][GEOM_OCTREE] =
688 &OctreeCollide<Halfspace, OcTree>;
689
690 23 collision_matrix[GEOM_OCTREE][GEOM_OCTREE] = &OctreeCollide<OcTree, OcTree>;
691
692 23 collision_matrix[GEOM_OCTREE][BV_AABB] =
693 &OctreeCollide<OcTree, BVHModel<AABB> >;
694 23 collision_matrix[GEOM_OCTREE][BV_OBB] =
695 &OctreeCollide<OcTree, BVHModel<OBB> >;
696 23 collision_matrix[GEOM_OCTREE][BV_RSS] =
697 &OctreeCollide<OcTree, BVHModel<RSS> >;
698 23 collision_matrix[GEOM_OCTREE][BV_OBBRSS] =
699 &OctreeCollide<OcTree, BVHModel<OBBRSS> >;
700 23 collision_matrix[GEOM_OCTREE][BV_kIOS] =
701 &OctreeCollide<OcTree, BVHModel<kIOS> >;
702 23 collision_matrix[GEOM_OCTREE][BV_KDOP16] =
703 &OctreeCollide<OcTree, BVHModel<KDOP<16> > >;
704 23 collision_matrix[GEOM_OCTREE][BV_KDOP18] =
705 &OctreeCollide<OcTree, BVHModel<KDOP<18> > >;
706 23 collision_matrix[GEOM_OCTREE][BV_KDOP24] =
707 &OctreeCollide<OcTree, BVHModel<KDOP<24> > >;
708 23 collision_matrix[GEOM_OCTREE][HF_AABB] =
709 &OctreeCollide<OcTree, HeightField<AABB> >;
710 23 collision_matrix[GEOM_OCTREE][HF_OBBRSS] =
711 &OctreeCollide<OcTree, HeightField<OBBRSS> >;
712
713 23 collision_matrix[BV_AABB][GEOM_OCTREE] =
714 &OctreeCollide<BVHModel<AABB>, OcTree>;
715 23 collision_matrix[BV_OBB][GEOM_OCTREE] = &OctreeCollide<BVHModel<OBB>, OcTree>;
716 23 collision_matrix[BV_RSS][GEOM_OCTREE] = &OctreeCollide<BVHModel<RSS>, OcTree>;
717 23 collision_matrix[BV_OBBRSS][GEOM_OCTREE] =
718 &OctreeCollide<BVHModel<OBBRSS>, OcTree>;
719 23 collision_matrix[BV_kIOS][GEOM_OCTREE] =
720 &OctreeCollide<BVHModel<kIOS>, OcTree>;
721 23 collision_matrix[BV_KDOP16][GEOM_OCTREE] =
722 &OctreeCollide<BVHModel<KDOP<16> >, OcTree>;
723 23 collision_matrix[BV_KDOP18][GEOM_OCTREE] =
724 &OctreeCollide<BVHModel<KDOP<18> >, OcTree>;
725 23 collision_matrix[BV_KDOP24][GEOM_OCTREE] =
726 &OctreeCollide<BVHModel<KDOP<24> >, OcTree>;
727 23 collision_matrix[HF_AABB][GEOM_OCTREE] =
728 &OctreeCollide<HeightField<AABB>, OcTree>;
729 23 collision_matrix[HF_OBBRSS][GEOM_OCTREE] =
730 &OctreeCollide<HeightField<OBBRSS>, OcTree>;
731 #endif
732 23 }
733 // template struct CollisionFunctionMatrix;
734 } // namespace coal
735