GCC Code Coverage Report


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