GCC Code Coverage Report

Directory: ./
File: src/collision_func_matrix.cpp
Date: 2025-05-02 10:16:21
Exec Total Coverage
Lines: 319 350 91.1%
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 529 times.
✓ Branch 1 taken 23 times.
 552 for (int i = 0; i < NODE_COUNT; ++i) {
284
2/2
✓ Branch 0 taken 12167 times.
✓ Branch 1 taken 529 times.
 12696 for (int j = 0; j < NODE_COUNT; ++j) collision_matrix[i][j] = NULL;
285 }
286
287 // clang-format off
288 23 collision_matrix[GEOM_BOX][GEOM_BOX] = &ShapeShapeCollide<Box, Box>;
289 23 collision_matrix[GEOM_BOX][GEOM_SPHERE] = &ShapeShapeCollide<Box, Sphere>;
290 23 collision_matrix[GEOM_BOX][GEOM_CAPSULE] = &ShapeShapeCollide<Box, Capsule>;
291 23 collision_matrix[GEOM_BOX][GEOM_CONE] = &ShapeShapeCollide<Box, Cone>;
292 23 collision_matrix[GEOM_BOX][GEOM_CYLINDER] = &ShapeShapeCollide<Box, Cylinder>;
293 23 collision_matrix[GEOM_BOX][GEOM_CONVEX16] = &ShapeShapeCollide<Box, ConvexBase16>;
294 23 collision_matrix[GEOM_BOX][GEOM_CONVEX32] = &ShapeShapeCollide<Box, ConvexBase32>;
295 23 collision_matrix[GEOM_BOX][GEOM_PLANE] = &ShapeShapeCollide<Box, Plane>;
296 23 collision_matrix[GEOM_BOX][GEOM_HALFSPACE] = &ShapeShapeCollide<Box, Halfspace>;
297 23 collision_matrix[GEOM_BOX][GEOM_ELLIPSOID] = &ShapeShapeCollide<Box, Ellipsoid>;
298 23 collision_matrix[GEOM_BOX][GEOM_TRIANGLE] = &ShapeShapeCollide<Box, TriangleP>;
299
300 23 collision_matrix[GEOM_SPHERE][GEOM_BOX] = &ShapeShapeCollide<Sphere, Box>;
301 23 collision_matrix[GEOM_SPHERE][GEOM_SPHERE] = &ShapeShapeCollide<Sphere, Sphere>;
302 23 collision_matrix[GEOM_SPHERE][GEOM_CAPSULE] = &ShapeShapeCollide<Sphere, Capsule>;
303 23 collision_matrix[GEOM_SPHERE][GEOM_CONE] = &ShapeShapeCollide<Sphere, Cone>;
304 23 collision_matrix[GEOM_SPHERE][GEOM_CYLINDER] = &ShapeShapeCollide<Sphere, Cylinder>;
305 23 collision_matrix[GEOM_SPHERE][GEOM_CONVEX16] = &ShapeShapeCollide<Sphere, ConvexBase16>;
306 23 collision_matrix[GEOM_SPHERE][GEOM_CONVEX32] = &ShapeShapeCollide<Sphere, ConvexBase32>;
307 23 collision_matrix[GEOM_SPHERE][GEOM_PLANE] = &ShapeShapeCollide<Sphere, Plane>;
308 23 collision_matrix[GEOM_SPHERE][GEOM_HALFSPACE] = &ShapeShapeCollide<Sphere, Halfspace>;
309 23 collision_matrix[GEOM_SPHERE][GEOM_ELLIPSOID] = &ShapeShapeCollide<Sphere, Ellipsoid>;
310 23 collision_matrix[GEOM_SPHERE][GEOM_TRIANGLE] = &ShapeShapeCollide<Sphere, TriangleP>;
311
312 23 collision_matrix[GEOM_ELLIPSOID][GEOM_BOX] = &ShapeShapeCollide<Ellipsoid, Box>;
313 23 collision_matrix[GEOM_ELLIPSOID][GEOM_SPHERE] = &ShapeShapeCollide<Ellipsoid, Sphere>;
314 23 collision_matrix[GEOM_ELLIPSOID][GEOM_CAPSULE] = &ShapeShapeCollide<Ellipsoid, Capsule>;
315 23 collision_matrix[GEOM_ELLIPSOID][GEOM_CONE] = &ShapeShapeCollide<Ellipsoid, Cone>;
316 23 collision_matrix[GEOM_ELLIPSOID][GEOM_CYLINDER] = &ShapeShapeCollide<Ellipsoid, Cylinder>;
317 23 collision_matrix[GEOM_ELLIPSOID][GEOM_CONVEX16] = &ShapeShapeCollide<Ellipsoid, ConvexBase16>;
318 23 collision_matrix[GEOM_ELLIPSOID][GEOM_CONVEX32] = &ShapeShapeCollide<Ellipsoid, ConvexBase32>;
319 23 collision_matrix[GEOM_ELLIPSOID][GEOM_PLANE] = &ShapeShapeCollide<Ellipsoid, Plane>;
320 23 collision_matrix[GEOM_ELLIPSOID][GEOM_HALFSPACE] = &ShapeShapeCollide<Ellipsoid, Halfspace>;
321 23 collision_matrix[GEOM_ELLIPSOID][GEOM_ELLIPSOID] = &ShapeShapeCollide<Ellipsoid, Ellipsoid>;
322 23 collision_matrix[GEOM_ELLIPSOID][GEOM_TRIANGLE] = &ShapeShapeCollide<Ellipsoid, TriangleP>;
323
324 23 collision_matrix[GEOM_CAPSULE][GEOM_BOX] = &ShapeShapeCollide<Capsule, Box>;
325 23 collision_matrix[GEOM_CAPSULE][GEOM_SPHERE] = &ShapeShapeCollide<Capsule, Sphere>;
326 23 collision_matrix[GEOM_CAPSULE][GEOM_CAPSULE] = &ShapeShapeCollide<Capsule, Capsule>;
327 23 collision_matrix[GEOM_CAPSULE][GEOM_CONE] = &ShapeShapeCollide<Capsule, Cone>;
328 23 collision_matrix[GEOM_CAPSULE][GEOM_CYLINDER] = &ShapeShapeCollide<Capsule, Cylinder>;
329 23 collision_matrix[GEOM_CAPSULE][GEOM_CONVEX16] = &ShapeShapeCollide<Capsule, ConvexBase16>;
330 23 collision_matrix[GEOM_CAPSULE][GEOM_CONVEX32] = &ShapeShapeCollide<Capsule, ConvexBase32>;
331 23 collision_matrix[GEOM_CAPSULE][GEOM_PLANE] = &ShapeShapeCollide<Capsule, Plane>;
332 23 collision_matrix[GEOM_CAPSULE][GEOM_HALFSPACE] = &ShapeShapeCollide<Capsule, Halfspace>;
333 23 collision_matrix[GEOM_CAPSULE][GEOM_ELLIPSOID] = &ShapeShapeCollide<Capsule, Ellipsoid>;
334 23 collision_matrix[GEOM_CAPSULE][GEOM_TRIANGLE] = &ShapeShapeCollide<Capsule, TriangleP>;
335
336 23 collision_matrix[GEOM_CONE][GEOM_BOX] = &ShapeShapeCollide<Cone, Box>;
337 23 collision_matrix[GEOM_CONE][GEOM_SPHERE] = &ShapeShapeCollide<Cone, Sphere>;
338 23 collision_matrix[GEOM_CONE][GEOM_CAPSULE] = &ShapeShapeCollide<Cone, Capsule>;
339 23 collision_matrix[GEOM_CONE][GEOM_CONE] = &ShapeShapeCollide<Cone, Cone>;
340 23 collision_matrix[GEOM_CONE][GEOM_CYLINDER] = &ShapeShapeCollide<Cone, Cylinder>;
341 23 collision_matrix[GEOM_CONE][GEOM_CONVEX16] = &ShapeShapeCollide<Cone, ConvexBase16>;
342 23 collision_matrix[GEOM_CONE][GEOM_CONVEX32] = &ShapeShapeCollide<Cone, ConvexBase32>;
343 23 collision_matrix[GEOM_CONE][GEOM_PLANE] = &ShapeShapeCollide<Cone, Plane>;
344 23 collision_matrix[GEOM_CONE][GEOM_HALFSPACE] = &ShapeShapeCollide<Cone, Halfspace>;
345 23 collision_matrix[GEOM_CONE][GEOM_ELLIPSOID] = &ShapeShapeCollide<Cone, Ellipsoid>;
346 23 collision_matrix[GEOM_CONE][GEOM_TRIANGLE] = &ShapeShapeCollide<Cone, TriangleP>;
347
348 23 collision_matrix[GEOM_CYLINDER][GEOM_BOX] = &ShapeShapeCollide<Cylinder, Box>;
349 23 collision_matrix[GEOM_CYLINDER][GEOM_SPHERE] = &ShapeShapeCollide<Cylinder, Sphere>;
350 23 collision_matrix[GEOM_CYLINDER][GEOM_CAPSULE] = &ShapeShapeCollide<Cylinder, Capsule>;
351 23 collision_matrix[GEOM_CYLINDER][GEOM_CONE] = &ShapeShapeCollide<Cylinder, Cone>;
352 23 collision_matrix[GEOM_CYLINDER][GEOM_CYLINDER] = &ShapeShapeCollide<Cylinder, Cylinder>;
353 23 collision_matrix[GEOM_CYLINDER][GEOM_CONVEX16] = &ShapeShapeCollide<Cylinder, ConvexBase16>;
354 23 collision_matrix[GEOM_CYLINDER][GEOM_CONVEX32] = &ShapeShapeCollide<Cylinder, ConvexBase32>;
355 23 collision_matrix[GEOM_CYLINDER][GEOM_PLANE] = &ShapeShapeCollide<Cylinder, Plane>;
356 23 collision_matrix[GEOM_CYLINDER][GEOM_HALFSPACE] = &ShapeShapeCollide<Cylinder, Halfspace>;
357 23 collision_matrix[GEOM_CYLINDER][GEOM_ELLIPSOID] = &ShapeShapeCollide<Cylinder, Ellipsoid>;
358 23 collision_matrix[GEOM_CYLINDER][GEOM_TRIANGLE] = &ShapeShapeCollide<Cylinder, TriangleP>;
359
360 23 collision_matrix[GEOM_CONVEX16][GEOM_BOX] = &ShapeShapeCollide<ConvexBase16, Box>;
361 23 collision_matrix[GEOM_CONVEX16][GEOM_SPHERE] = &ShapeShapeCollide<ConvexBase16, Sphere>;
362 23 collision_matrix[GEOM_CONVEX16][GEOM_CAPSULE] = &ShapeShapeCollide<ConvexBase16, Capsule>;
363 23 collision_matrix[GEOM_CONVEX16][GEOM_CONE] = &ShapeShapeCollide<ConvexBase16, Cone>;
364 23 collision_matrix[GEOM_CONVEX16][GEOM_CYLINDER] = &ShapeShapeCollide<ConvexBase16, Cylinder>;
365 23 collision_matrix[GEOM_CONVEX16][GEOM_CONVEX16] = &ShapeShapeCollide<ConvexBase16, ConvexBase16>;
366 23 collision_matrix[GEOM_CONVEX16][GEOM_CONVEX32] = &ShapeShapeCollide<ConvexBase16, ConvexBase32>;
367 23 collision_matrix[GEOM_CONVEX16][GEOM_PLANE] = &ShapeShapeCollide<ConvexBase16, Plane>;
368 23 collision_matrix[GEOM_CONVEX16][GEOM_HALFSPACE] = &ShapeShapeCollide<ConvexBase16, Halfspace>;
369 23 collision_matrix[GEOM_CONVEX16][GEOM_ELLIPSOID] = &ShapeShapeCollide<ConvexBase16, Ellipsoid>;
370 23 collision_matrix[GEOM_CONVEX16][GEOM_TRIANGLE] = &ShapeShapeCollide<ConvexBase16, TriangleP>;
371
372 23 collision_matrix[GEOM_CONVEX32][GEOM_BOX] = &ShapeShapeCollide<ConvexBase32, Box>;
373 23 collision_matrix[GEOM_CONVEX32][GEOM_SPHERE] = &ShapeShapeCollide<ConvexBase32, Sphere>;
374 23 collision_matrix[GEOM_CONVEX32][GEOM_CAPSULE] = &ShapeShapeCollide<ConvexBase32, Capsule>;
375 23 collision_matrix[GEOM_CONVEX32][GEOM_CONE] = &ShapeShapeCollide<ConvexBase32, Cone>;
376 23 collision_matrix[GEOM_CONVEX32][GEOM_CYLINDER] = &ShapeShapeCollide<ConvexBase32, Cylinder>;
377 23 collision_matrix[GEOM_CONVEX32][GEOM_CONVEX16] = &ShapeShapeCollide<ConvexBase32, ConvexBase16>;
378 23 collision_matrix[GEOM_CONVEX32][GEOM_CONVEX32] = &ShapeShapeCollide<ConvexBase32, ConvexBase32>;
379 23 collision_matrix[GEOM_CONVEX32][GEOM_PLANE] = &ShapeShapeCollide<ConvexBase32, Plane>;
380 23 collision_matrix[GEOM_CONVEX32][GEOM_HALFSPACE] = &ShapeShapeCollide<ConvexBase32, Halfspace>;
381 23 collision_matrix[GEOM_CONVEX32][GEOM_ELLIPSOID] = &ShapeShapeCollide<ConvexBase32, Ellipsoid>;
382 23 collision_matrix[GEOM_CONVEX32][GEOM_TRIANGLE] = &ShapeShapeCollide<ConvexBase32, TriangleP>;
383
384 23 collision_matrix[GEOM_PLANE][GEOM_BOX] = &ShapeShapeCollide<Plane, Box>;
385 23 collision_matrix[GEOM_PLANE][GEOM_SPHERE] = &ShapeShapeCollide<Plane, Sphere>;
386 23 collision_matrix[GEOM_PLANE][GEOM_CAPSULE] = &ShapeShapeCollide<Plane, Capsule>;
387 23 collision_matrix[GEOM_PLANE][GEOM_CONE] = &ShapeShapeCollide<Plane, Cone>;
388 23 collision_matrix[GEOM_PLANE][GEOM_CYLINDER] = &ShapeShapeCollide<Plane, Cylinder>;
389 23 collision_matrix[GEOM_PLANE][GEOM_CONVEX16] = &ShapeShapeCollide<Plane, ConvexBase16>;
390 23 collision_matrix[GEOM_PLANE][GEOM_CONVEX32] = &ShapeShapeCollide<Plane, ConvexBase32>;
391 23 collision_matrix[GEOM_PLANE][GEOM_PLANE] = &ShapeShapeCollide<Plane, Plane>;
392 23 collision_matrix[GEOM_PLANE][GEOM_HALFSPACE] = &ShapeShapeCollide<Plane, Halfspace>;
393 23 collision_matrix[GEOM_PLANE][GEOM_ELLIPSOID] = &ShapeShapeCollide<Plane, Ellipsoid>;
394 23 collision_matrix[GEOM_PLANE][GEOM_TRIANGLE] = &ShapeShapeCollide<Plane, TriangleP>;
395
396 23 collision_matrix[GEOM_HALFSPACE][GEOM_BOX] = &ShapeShapeCollide<Halfspace, Box>;
397 23 collision_matrix[GEOM_HALFSPACE][GEOM_SPHERE] = &ShapeShapeCollide<Halfspace, Sphere>;
398 23 collision_matrix[GEOM_HALFSPACE][GEOM_CAPSULE] = &ShapeShapeCollide<Halfspace, Capsule>;
399 23 collision_matrix[GEOM_HALFSPACE][GEOM_CONE] = &ShapeShapeCollide<Halfspace, Cone>;
400 23 collision_matrix[GEOM_HALFSPACE][GEOM_CYLINDER] = &ShapeShapeCollide<Halfspace, Cylinder>;
401 23 collision_matrix[GEOM_HALFSPACE][GEOM_CONVEX16] = &ShapeShapeCollide<Halfspace, ConvexBase16>;
402 23 collision_matrix[GEOM_HALFSPACE][GEOM_CONVEX32] = &ShapeShapeCollide<Halfspace, ConvexBase32>;
403 23 collision_matrix[GEOM_HALFSPACE][GEOM_PLANE] = &ShapeShapeCollide<Halfspace, Plane>;
404 23 collision_matrix[GEOM_HALFSPACE][GEOM_HALFSPACE] = &ShapeShapeCollide<Halfspace, Halfspace>;
405 23 collision_matrix[GEOM_HALFSPACE][GEOM_ELLIPSOID] = &ShapeShapeCollide<Halfspace, Ellipsoid>;
406 23 collision_matrix[GEOM_HALFSPACE][GEOM_TRIANGLE] = &ShapeShapeCollide<Halfspace, TriangleP>;
407
408 23 collision_matrix[GEOM_TRIANGLE][GEOM_BOX] = &ShapeShapeCollide<TriangleP, Box>;
409 23 collision_matrix[GEOM_TRIANGLE][GEOM_SPHERE] = &ShapeShapeCollide<TriangleP, Sphere>;
410 23 collision_matrix[GEOM_TRIANGLE][GEOM_CAPSULE] = &ShapeShapeCollide<TriangleP, Capsule>;
411 23 collision_matrix[GEOM_TRIANGLE][GEOM_CONE] = &ShapeShapeCollide<TriangleP, Cone>;
412 23 collision_matrix[GEOM_TRIANGLE][GEOM_CYLINDER] = &ShapeShapeCollide<TriangleP, Cylinder>;
413 23 collision_matrix[GEOM_TRIANGLE][GEOM_CONVEX16] = &ShapeShapeCollide<TriangleP, ConvexBase16>;
414 23 collision_matrix[GEOM_TRIANGLE][GEOM_CONVEX32] = &ShapeShapeCollide<TriangleP, ConvexBase32>;
415 23 collision_matrix[GEOM_TRIANGLE][GEOM_PLANE] = &ShapeShapeCollide<TriangleP, Plane>;
416 23 collision_matrix[GEOM_TRIANGLE][GEOM_HALFSPACE] = &ShapeShapeCollide<TriangleP, Halfspace>;
417 23 collision_matrix[GEOM_TRIANGLE][GEOM_ELLIPSOID] = &ShapeShapeCollide<TriangleP, Ellipsoid>;
418 23 collision_matrix[GEOM_TRIANGLE][GEOM_TRIANGLE] = &ShapeShapeCollide<TriangleP, TriangleP>;
419
420 23 collision_matrix[BV_AABB][GEOM_BOX] = &BVHShapeCollider<AABB, Box>::collide;
421 23 collision_matrix[BV_AABB][GEOM_SPHERE] = &BVHShapeCollider<AABB, Sphere>::collide;
422 23 collision_matrix[BV_AABB][GEOM_CAPSULE] = &BVHShapeCollider<AABB, Capsule>::collide;
423 23 collision_matrix[BV_AABB][GEOM_CONE] = &BVHShapeCollider<AABB, Cone>::collide;
424 23 collision_matrix[BV_AABB][GEOM_CYLINDER] = &BVHShapeCollider<AABB, Cylinder>::collide;
425 23 collision_matrix[BV_AABB][GEOM_CONVEX16] = &BVHShapeCollider<AABB, ConvexBase16>::collide;
426 23 collision_matrix[BV_AABB][GEOM_CONVEX32] = &BVHShapeCollider<AABB, ConvexBase32>::collide;
427 23 collision_matrix[BV_AABB][GEOM_PLANE] = &BVHShapeCollider<AABB, Plane>::collide;
428 23 collision_matrix[BV_AABB][GEOM_HALFSPACE] = &BVHShapeCollider<AABB, Halfspace>::collide;
429 23 collision_matrix[BV_AABB][GEOM_ELLIPSOID] = &BVHShapeCollider<AABB, Ellipsoid>::collide;
430
431 23 collision_matrix[BV_OBB][GEOM_BOX] = &BVHShapeCollider<OBB, Box>::collide;
432 23 collision_matrix[BV_OBB][GEOM_SPHERE] = &BVHShapeCollider<OBB, Sphere>::collide;
433 23 collision_matrix[BV_OBB][GEOM_CAPSULE] = &BVHShapeCollider<OBB, Capsule>::collide;
434 23 collision_matrix[BV_OBB][GEOM_CONE] = &BVHShapeCollider<OBB, Cone>::collide;
435 23 collision_matrix[BV_OBB][GEOM_CYLINDER] = &BVHShapeCollider<OBB, Cylinder>::collide;
436 23 collision_matrix[BV_OBB][GEOM_CONVEX16] = &BVHShapeCollider<OBB, ConvexBase16>::collide;
437 23 collision_matrix[BV_OBB][GEOM_CONVEX32] = &BVHShapeCollider<OBB, ConvexBase32>::collide;
438 23 collision_matrix[BV_OBB][GEOM_PLANE] = &BVHShapeCollider<OBB, Plane>::collide;
439 23 collision_matrix[BV_OBB][GEOM_HALFSPACE] = &BVHShapeCollider<OBB, Halfspace>::collide;
440 23 collision_matrix[BV_OBB][GEOM_ELLIPSOID] = &BVHShapeCollider<OBB, Ellipsoid>::collide;
441
442 23 collision_matrix[BV_RSS][GEOM_BOX] = &BVHShapeCollider<RSS, Box>::collide;
443 23 collision_matrix[BV_RSS][GEOM_SPHERE] = &BVHShapeCollider<RSS, Sphere>::collide;
444 23 collision_matrix[BV_RSS][GEOM_CAPSULE] = &BVHShapeCollider<RSS, Capsule>::collide;
445 23 collision_matrix[BV_RSS][GEOM_CONE] = &BVHShapeCollider<RSS, Cone>::collide;
446 23 collision_matrix[BV_RSS][GEOM_CYLINDER] = &BVHShapeCollider<RSS, Cylinder>::collide;
447 23 collision_matrix[BV_RSS][GEOM_CONVEX16] = &BVHShapeCollider<RSS, ConvexBase16>::collide;
448 23 collision_matrix[BV_RSS][GEOM_CONVEX32] = &BVHShapeCollider<RSS, ConvexBase32>::collide;
449 23 collision_matrix[BV_RSS][GEOM_PLANE] = &BVHShapeCollider<RSS, Plane>::collide;
450 23 collision_matrix[BV_RSS][GEOM_HALFSPACE] = &BVHShapeCollider<RSS, Halfspace>::collide;
451 23 collision_matrix[BV_RSS][GEOM_ELLIPSOID] = &BVHShapeCollider<RSS, Ellipsoid>::collide;
452
453 23 collision_matrix[BV_KDOP16][GEOM_BOX] = &BVHShapeCollider<KDOP<16>, Box>::collide;
454 23 collision_matrix[BV_KDOP16][GEOM_SPHERE] = &BVHShapeCollider<KDOP<16>, Sphere>::collide;
455 23 collision_matrix[BV_KDOP16][GEOM_CAPSULE] = &BVHShapeCollider<KDOP<16>, Capsule>::collide;
456 23 collision_matrix[BV_KDOP16][GEOM_CONE] = &BVHShapeCollider<KDOP<16>, Cone>::collide;
457 23 collision_matrix[BV_KDOP16][GEOM_CYLINDER] = &BVHShapeCollider<KDOP<16>, Cylinder>::collide;
458 23 collision_matrix[BV_KDOP16][GEOM_CONVEX16] = &BVHShapeCollider<KDOP<16>, ConvexBase16>::collide;
459 23 collision_matrix[BV_KDOP16][GEOM_CONVEX32] = &BVHShapeCollider<KDOP<16>, ConvexBase32>::collide;
460 23 collision_matrix[BV_KDOP16][GEOM_PLANE] = &BVHShapeCollider<KDOP<16>, Plane>::collide;
461 23 collision_matrix[BV_KDOP16][GEOM_HALFSPACE] = &BVHShapeCollider<KDOP<16>, Halfspace>::collide;
462 23 collision_matrix[BV_KDOP16][GEOM_ELLIPSOID] = &BVHShapeCollider<KDOP<16>, Ellipsoid>::collide;
463
464 23 collision_matrix[BV_KDOP18][GEOM_BOX] = &BVHShapeCollider<KDOP<18>, Box>::collide;
465 23 collision_matrix[BV_KDOP18][GEOM_SPHERE] = &BVHShapeCollider<KDOP<18>, Sphere>::collide;
466 23 collision_matrix[BV_KDOP18][GEOM_CAPSULE] = &BVHShapeCollider<KDOP<18>, Capsule>::collide;
467 23 collision_matrix[BV_KDOP18][GEOM_CONE] = &BVHShapeCollider<KDOP<18>, Cone>::collide;
468 23 collision_matrix[BV_KDOP18][GEOM_CYLINDER] = &BVHShapeCollider<KDOP<18>, Cylinder>::collide;
469 23 collision_matrix[BV_KDOP18][GEOM_CONVEX16] = &BVHShapeCollider<KDOP<18>, ConvexBase16>::collide;
470 23 collision_matrix[BV_KDOP18][GEOM_CONVEX32] = &BVHShapeCollider<KDOP<18>, ConvexBase32>::collide;
471 23 collision_matrix[BV_KDOP18][GEOM_PLANE] = &BVHShapeCollider<KDOP<18>, Plane>::collide;
472 23 collision_matrix[BV_KDOP18][GEOM_HALFSPACE] = &BVHShapeCollider<KDOP<18>, Halfspace>::collide;
473 23 collision_matrix[BV_KDOP18][GEOM_ELLIPSOID] = &BVHShapeCollider<KDOP<18>, Ellipsoid>::collide;
474
475 23 collision_matrix[BV_KDOP24][GEOM_BOX] = &BVHShapeCollider<KDOP<24>, Box>::collide;
476 23 collision_matrix[BV_KDOP24][GEOM_SPHERE] = &BVHShapeCollider<KDOP<24>, Sphere>::collide;
477 23 collision_matrix[BV_KDOP24][GEOM_CAPSULE] = &BVHShapeCollider<KDOP<24>, Capsule>::collide;
478 23 collision_matrix[BV_KDOP24][GEOM_CONE] = &BVHShapeCollider<KDOP<24>, Cone>::collide;
479 23 collision_matrix[BV_KDOP24][GEOM_CYLINDER] = &BVHShapeCollider<KDOP<24>, Cylinder>::collide;
480 23 collision_matrix[BV_KDOP24][GEOM_CONVEX16] = &BVHShapeCollider<KDOP<24>, ConvexBase16>::collide;
481 23 collision_matrix[BV_KDOP24][GEOM_CONVEX32] = &BVHShapeCollider<KDOP<24>, ConvexBase32>::collide;
482 23 collision_matrix[BV_KDOP24][GEOM_PLANE] = &BVHShapeCollider<KDOP<24>, Plane>::collide;
483 23 collision_matrix[BV_KDOP24][GEOM_HALFSPACE] = &BVHShapeCollider<KDOP<24>, Halfspace>::collide;
484 23 collision_matrix[BV_KDOP24][GEOM_ELLIPSOID] = &BVHShapeCollider<KDOP<24>, Ellipsoid>::collide;
485
486 23 collision_matrix[BV_kIOS][GEOM_BOX] = &BVHShapeCollider<kIOS, Box>::collide;
487 23 collision_matrix[BV_kIOS][GEOM_SPHERE] = &BVHShapeCollider<kIOS, Sphere>::collide;
488 23 collision_matrix[BV_kIOS][GEOM_CAPSULE] = &BVHShapeCollider<kIOS, Capsule>::collide;
489 23 collision_matrix[BV_kIOS][GEOM_CONE] = &BVHShapeCollider<kIOS, Cone>::collide;
490 23 collision_matrix[BV_kIOS][GEOM_CYLINDER] = &BVHShapeCollider<kIOS, Cylinder>::collide;
491 23 collision_matrix[BV_kIOS][GEOM_CONVEX16] = &BVHShapeCollider<kIOS, ConvexBase16>::collide;
492 23 collision_matrix[BV_kIOS][GEOM_CONVEX32] = &BVHShapeCollider<kIOS, ConvexBase32>::collide;
493 23 collision_matrix[BV_kIOS][GEOM_PLANE] = &BVHShapeCollider<kIOS, Plane>::collide;
494 23 collision_matrix[BV_kIOS][GEOM_HALFSPACE] = &BVHShapeCollider<kIOS, Halfspace>::collide;
495 23 collision_matrix[BV_kIOS][GEOM_ELLIPSOID] = &BVHShapeCollider<kIOS, Ellipsoid>::collide;
496
497 23 collision_matrix[BV_OBBRSS][GEOM_BOX] = &BVHShapeCollider<OBBRSS, Box>::collide;
498 23 collision_matrix[BV_OBBRSS][GEOM_SPHERE] = &BVHShapeCollider<OBBRSS, Sphere>::collide;
499 23 collision_matrix[BV_OBBRSS][GEOM_CAPSULE] = &BVHShapeCollider<OBBRSS, Capsule>::collide;
500 23 collision_matrix[BV_OBBRSS][GEOM_CONE] = &BVHShapeCollider<OBBRSS, Cone>::collide;
501 23 collision_matrix[BV_OBBRSS][GEOM_CYLINDER] = &BVHShapeCollider<OBBRSS, Cylinder>::collide;
502 23 collision_matrix[BV_OBBRSS][GEOM_CONVEX16] = &BVHShapeCollider<OBBRSS, ConvexBase16>::collide;
503 23 collision_matrix[BV_OBBRSS][GEOM_CONVEX32] = &BVHShapeCollider<OBBRSS, ConvexBase32>::collide;
504 23 collision_matrix[BV_OBBRSS][GEOM_PLANE] = &BVHShapeCollider<OBBRSS, Plane>::collide;
505 23 collision_matrix[BV_OBBRSS][GEOM_HALFSPACE] = &BVHShapeCollider<OBBRSS, Halfspace>::collide;
506 23 collision_matrix[BV_OBBRSS][GEOM_ELLIPSOID] = &BVHShapeCollider<OBBRSS, Ellipsoid>::collide;
507
508 23 collision_matrix[HF_AABB][GEOM_BOX] = &HeightFieldShapeCollider<AABB, Box>::collide;
509 23 collision_matrix[HF_AABB][GEOM_SPHERE] = &HeightFieldShapeCollider<AABB, Sphere>::collide;
510 23 collision_matrix[HF_AABB][GEOM_CAPSULE] = &HeightFieldShapeCollider<AABB, Capsule>::collide;
511 23 collision_matrix[HF_AABB][GEOM_CONE] = &HeightFieldShapeCollider<AABB, Cone>::collide;
512 23 collision_matrix[HF_AABB][GEOM_CYLINDER] = &HeightFieldShapeCollider<AABB, Cylinder>::collide;
513 23 collision_matrix[HF_AABB][GEOM_CONVEX16] = &HeightFieldShapeCollider<AABB, ConvexBase16>::collide;
514 23 collision_matrix[HF_AABB][GEOM_CONVEX32] = &HeightFieldShapeCollider<AABB, ConvexBase32>::collide;
515 23 collision_matrix[HF_AABB][GEOM_PLANE] = &HeightFieldShapeCollider<AABB, Plane>::collide;
516 23 collision_matrix[HF_AABB][GEOM_HALFSPACE] = &HeightFieldShapeCollider<AABB, Halfspace>::collide;
517 23 collision_matrix[HF_AABB][GEOM_ELLIPSOID] = &HeightFieldShapeCollider<AABB, Ellipsoid>::collide;
518
519 23 collision_matrix[HF_OBBRSS][GEOM_BOX] = &HeightFieldShapeCollider<OBBRSS, Box>::collide;
520 23 collision_matrix[HF_OBBRSS][GEOM_SPHERE] = &HeightFieldShapeCollider<OBBRSS, Sphere>::collide;
521 23 collision_matrix[HF_OBBRSS][GEOM_CAPSULE] = &HeightFieldShapeCollider<OBBRSS, Capsule>::collide;
522 23 collision_matrix[HF_OBBRSS][GEOM_CONE] = &HeightFieldShapeCollider<OBBRSS, Cone>::collide;
523 23 collision_matrix[HF_OBBRSS][GEOM_CYLINDER] = &HeightFieldShapeCollider<OBBRSS, Cylinder>::collide;
524 23 collision_matrix[HF_OBBRSS][GEOM_CONVEX16] = &HeightFieldShapeCollider<OBBRSS, ConvexBase16>::collide;
525 23 collision_matrix[HF_OBBRSS][GEOM_CONVEX32] = &HeightFieldShapeCollider<OBBRSS, ConvexBase32>::collide;
526 23 collision_matrix[HF_OBBRSS][GEOM_PLANE] = &HeightFieldShapeCollider<OBBRSS, Plane>::collide;
527 23 collision_matrix[HF_OBBRSS][GEOM_HALFSPACE] = &HeightFieldShapeCollider<OBBRSS, Halfspace>::collide;
528 23 collision_matrix[HF_OBBRSS][GEOM_ELLIPSOID] = &HeightFieldShapeCollider<OBBRSS, Ellipsoid>::collide;
529
530 23 collision_matrix[BV_AABB][BV_AABB] = &BVHCollide<AABB>;
531 23 collision_matrix[BV_OBB][BV_OBB] = &BVHCollide<OBB>;
532 23 collision_matrix[BV_RSS][BV_RSS] = &BVHCollide<RSS>;
533 23 collision_matrix[BV_KDOP16][BV_KDOP16] = &BVHCollide<KDOP<16> >;
534 23 collision_matrix[BV_KDOP18][BV_KDOP18] = &BVHCollide<KDOP<18> >;
535 23 collision_matrix[BV_KDOP24][BV_KDOP24] = &BVHCollide<KDOP<24> >;
536 23 collision_matrix[BV_kIOS][BV_kIOS] = &BVHCollide<kIOS>;
537 23 collision_matrix[BV_OBBRSS][BV_OBBRSS] = &BVHCollide<OBBRSS>;
538
539 #ifdef COAL_HAS_OCTOMAP
540 23 collision_matrix[GEOM_OCTREE][GEOM_BOX] = &OctreeCollide<OcTree, Box>;
541 23 collision_matrix[GEOM_OCTREE][GEOM_SPHERE] = &OctreeCollide<OcTree, Sphere>;
542 23 collision_matrix[GEOM_OCTREE][GEOM_CAPSULE] = &OctreeCollide<OcTree, Capsule>;
543 23 collision_matrix[GEOM_OCTREE][GEOM_CONE] = &OctreeCollide<OcTree, Cone>;
544 23 collision_matrix[GEOM_OCTREE][GEOM_CYLINDER] = &OctreeCollide<OcTree, Cylinder>;
545 23 collision_matrix[GEOM_OCTREE][GEOM_CONVEX16] = &OctreeCollide<OcTree, ConvexBase16>;
546 23 collision_matrix[GEOM_OCTREE][GEOM_CONVEX32] = &OctreeCollide<OcTree, ConvexBase32>;
547 23 collision_matrix[GEOM_OCTREE][GEOM_PLANE] = &OctreeCollide<OcTree, Plane>;
548 23 collision_matrix[GEOM_OCTREE][GEOM_HALFSPACE] = &OctreeCollide<OcTree, Halfspace>;
549 23 collision_matrix[GEOM_OCTREE][GEOM_ELLIPSOID] = &OctreeCollide<OcTree, Ellipsoid>;
550
551 23 collision_matrix[GEOM_BOX][GEOM_OCTREE] = &OctreeCollide<Box, OcTree>;
552 23 collision_matrix[GEOM_SPHERE][GEOM_OCTREE] = &OctreeCollide<Sphere, OcTree>;
553 23 collision_matrix[GEOM_CAPSULE][GEOM_OCTREE] = &OctreeCollide<Capsule, OcTree>;
554 23 collision_matrix[GEOM_CONE][GEOM_OCTREE] = &OctreeCollide<Cone, OcTree>;
555 23 collision_matrix[GEOM_CYLINDER][GEOM_OCTREE] = &OctreeCollide<Cylinder, OcTree>;
556 23 collision_matrix[GEOM_CONVEX16][GEOM_OCTREE] = &OctreeCollide<ConvexBase16, OcTree>;
557 23 collision_matrix[GEOM_CONVEX32][GEOM_OCTREE] = &OctreeCollide<ConvexBase32, OcTree>;
558 23 collision_matrix[GEOM_PLANE][GEOM_OCTREE] = &OctreeCollide<Plane, OcTree>;
559 23 collision_matrix[GEOM_HALFSPACE][GEOM_OCTREE] = &OctreeCollide<Halfspace, OcTree>;
560
561 23 collision_matrix[GEOM_OCTREE][GEOM_OCTREE] = &OctreeCollide<OcTree, OcTree>;
562
563 23 collision_matrix[GEOM_OCTREE][BV_AABB] = &OctreeCollide<OcTree, BVHModel<AABB> >;
564 23 collision_matrix[GEOM_OCTREE][BV_OBB] = &OctreeCollide<OcTree, BVHModel<OBB> >;
565 23 collision_matrix[GEOM_OCTREE][BV_RSS] = &OctreeCollide<OcTree, BVHModel<RSS> >;
566 23 collision_matrix[GEOM_OCTREE][BV_OBBRSS] = &OctreeCollide<OcTree, BVHModel<OBBRSS> >;
567 23 collision_matrix[GEOM_OCTREE][BV_kIOS] = &OctreeCollide<OcTree, BVHModel<kIOS> >;
568 23 collision_matrix[GEOM_OCTREE][BV_KDOP16] = &OctreeCollide<OcTree, BVHModel<KDOP<16> > >;
569 23 collision_matrix[GEOM_OCTREE][BV_KDOP18] = &OctreeCollide<OcTree, BVHModel<KDOP<18> > >;
570 23 collision_matrix[GEOM_OCTREE][BV_KDOP24] = &OctreeCollide<OcTree, BVHModel<KDOP<24> > >;
571 23 collision_matrix[GEOM_OCTREE][HF_AABB] = &OctreeCollide<OcTree, HeightField<AABB> >;
572 23 collision_matrix[GEOM_OCTREE][HF_OBBRSS] = &OctreeCollide<OcTree, HeightField<OBBRSS> >;
573
574 23 collision_matrix[BV_AABB][GEOM_OCTREE] = &OctreeCollide<BVHModel<AABB>, OcTree>;
575 23 collision_matrix[BV_OBB][GEOM_OCTREE] = &OctreeCollide<BVHModel<OBB>, OcTree>;
576 23 collision_matrix[BV_RSS][GEOM_OCTREE] = &OctreeCollide<BVHModel<RSS>, OcTree>;
577 23 collision_matrix[BV_OBBRSS][GEOM_OCTREE] = &OctreeCollide<BVHModel<OBBRSS>, OcTree>;
578 23 collision_matrix[BV_kIOS][GEOM_OCTREE] = &OctreeCollide<BVHModel<kIOS>, OcTree>;
579 23 collision_matrix[BV_KDOP16][GEOM_OCTREE] = &OctreeCollide<BVHModel<KDOP<16> >, OcTree>;
580 23 collision_matrix[BV_KDOP18][GEOM_OCTREE] = &OctreeCollide<BVHModel<KDOP<18> >, OcTree>;
581 23 collision_matrix[BV_KDOP24][GEOM_OCTREE] = &OctreeCollide<BVHModel<KDOP<24> >, OcTree>;
582 23 collision_matrix[HF_AABB][GEOM_OCTREE] = &OctreeCollide<HeightField<AABB>, OcTree>;
583 23 collision_matrix[HF_OBBRSS][GEOM_OCTREE] = &OctreeCollide<HeightField<OBBRSS>, OcTree>;
584 // clang-format on
585 #endif
586 23 }
587 // template struct CollisionFunctionMatrix;
588 } // namespace coal
589