Export function symbols.

include/hpp/fcl/BV/AABB.h

@@ -245,12 +245,12 @@ static inline AABB rotate(const AABB& aabb, const Matrix3f& R)
 }
 
 /// @brief Check collision between two aabbs, b1 is in configuration (R0, T0) and b2 is in identity.
-bool overlap(const Matrix3f& R0, const Vec3f& T0, const AABB& b1, const AABB& b2);
+bool overlap(const Matrix3f& R0, const Vec3f& T0, const AABB& b1, const AABB& b2) HPP_FCL_DLLAPI;
 
 /// @brief Check collision between two aabbs, b1 is in configuration (R0, T0) and b2 is in identity.
 bool overlap(const Matrix3f& R0, const Vec3f& T0, const AABB& b1,
 	     const AABB& b2, const CollisionRequest& request,
-             FCL_REAL& sqrDistLowerBound);
+             FCL_REAL& sqrDistLowerBound) HPP_FCL_DLLAPI;
 }
 
 } // namespace hpp

include/hpp/fcl/BV/OBB.h

@@ -133,15 +133,15 @@ public:
 
 
 /// @brief Translate the OBB bv
-OBB translate(const OBB& bv, const Vec3f& t);
+OBB translate(const OBB& bv, const Vec3f& t) HPP_FCL_DLLAPI;
 
 /// @brief Check collision between two obbs, b1 is in configuration (R0, T0) and b2 is in identity.
-bool overlap(const Matrix3f& R0, const Vec3f& T0, const OBB& b1, const OBB& b2);
+bool overlap(const Matrix3f& R0, const Vec3f& T0, const OBB& b1, const OBB& b2) HPP_FCL_DLLAPI;
 
 /// @brief Check collision between two obbs, b1 is in configuration (R0, T0) and b2 is in identity.
 bool overlap(const Matrix3f& R0, const Vec3f& T0, const OBB& b1,
 	     const OBB& b2, const CollisionRequest& request,
-             FCL_REAL& sqrDistLowerBound);
+             FCL_REAL& sqrDistLowerBound) HPP_FCL_DLLAPI;
 
 
 /// Check collision between two boxes
@@ -149,7 +149,7 @@ bool overlap(const Matrix3f& R0, const Vec3f& T0, const OBB& b1,
 /// @param a half dimensions of first box,
 /// @param b half dimensions of second box.
 /// The second box is in identity configuration.
-bool obbDisjoint(const Matrix3f& B, const Vec3f& T, const Vec3f& a, const Vec3f& b);
+bool obbDisjoint(const Matrix3f& B, const Vec3f& T, const Vec3f& a, const Vec3f& b) HPP_FCL_DLLAPI;
 }
 
 } // namespace hpp

include/hpp/fcl/BV/RSS.h

@@ -148,16 +148,16 @@ public:
 /// @brief distance between two RSS bounding volumes
 /// P and Q (optional return values) are the closest points in the rectangles, not the RSS. But the direction P - Q is the correct direction for cloest points
 /// Notice that P and Q are both in the local frame of the first RSS (not global frame and not even the local frame of object 1)
-FCL_REAL distance(const Matrix3f& R0, const Vec3f& T0, const RSS& b1, const RSS& b2, Vec3f* P = NULL, Vec3f* Q = NULL);
+FCL_REAL distance(const Matrix3f& R0, const Vec3f& T0, const RSS& b1, const RSS& b2, Vec3f* P = NULL, Vec3f* Q = NULL) HPP_FCL_DLLAPI;
 
 
 /// @brief Check collision between two RSSs, b1 is in configuration (R0, T0) and b2 is in identity.
-bool overlap(const Matrix3f& R0, const Vec3f& T0, const RSS& b1, const RSS& b2);
+bool overlap(const Matrix3f& R0, const Vec3f& T0, const RSS& b1, const RSS& b2) HPP_FCL_DLLAPI;
 
 /// @brief Check collision between two RSSs, b1 is in configuration (R0, T0) and b2 is in identity.
 bool overlap(const Matrix3f& R0, const Vec3f& T0, const RSS& b1, const RSS& b2,
              const CollisionRequest& request,
-             FCL_REAL& sqrDistLowerBound);
+             FCL_REAL& sqrDistLowerBound) HPP_FCL_DLLAPI;
 
 }
 

include/hpp/fcl/BV/kDOP.h

@@ -198,7 +198,7 @@ bool overlap(const Matrix3f& /*R0*/, const Vec3f& /*T0*/,
 
 /// @brief translate the KDOP BV
 template<short N>
-KDOP<N> translate(const KDOP<N>& bv, const Vec3f& t);
+KDOP<N> translate(const KDOP<N>& bv, const Vec3f& t) HPP_FCL_DLLAPI;
 
 }
 

include/hpp/fcl/BV/kIOS.h

@@ -147,21 +147,21 @@ public:
 
 
 /// @brief Translate the kIOS BV
-kIOS translate(const kIOS& bv, const Vec3f& t);
+kIOS translate(const kIOS& bv, const Vec3f& t) HPP_FCL_DLLAPI;
 
 /// @brief Check collision between two kIOSs, b1 is in configuration (R0, T0) and b2 is in identity.
 /// @todo Not efficient
-bool overlap(const Matrix3f& R0, const Vec3f& T0, const kIOS& b1, const kIOS& b2);
+bool overlap(const Matrix3f& R0, const Vec3f& T0, const kIOS& b1, const kIOS& b2) HPP_FCL_DLLAPI;
 
 /// @brief Check collision between two kIOSs, b1 is in configuration (R0, T0) and b2 is in identity.
 /// @todo Not efficient
 bool overlap(const Matrix3f& R0, const Vec3f& T0, const kIOS& b1, const kIOS& b2,
              const CollisionRequest& request,
-             FCL_REAL& sqrDistLowerBound);
+             FCL_REAL& sqrDistLowerBound) HPP_FCL_DLLAPI;
 
 /// @brief Approximate distance between two kIOS bounding volumes
 /// @todo P and Q is not returned, need implementation
-FCL_REAL distance(const Matrix3f& R0, const Vec3f& T0, const kIOS& b1, const kIOS& b2, Vec3f* P = NULL, Vec3f* Q = NULL);
+FCL_REAL distance(const Matrix3f& R0, const Vec3f& T0, const kIOS& b1, const kIOS& b2, Vec3f* P = NULL, Vec3f* Q = NULL) HPP_FCL_DLLAPI;
 
 }
 

include/hpp/fcl/BVH/BVH_utility.h

@@ -49,22 +49,22 @@ namespace fcl
 /// @brief Extract the part of the BVHModel that is inside an AABB.
 /// A triangle in collision with the AABB is considered inside.
 template<typename BV>
-BVHModel<BV>* BVHExtract(const BVHModel<BV>& model, const Transform3f& pose, const AABB& aabb);
+BVHModel<BV>* BVHExtract(const BVHModel<BV>& model, const Transform3f& pose, const AABB& aabb) HPP_FCL_DLLAPI;
 
 /// @brief Compute the covariance matrix for a set or subset of points. if ts = null, then indices refer to points directly; otherwise refer to triangles
-void getCovariance(Vec3f* ps, Vec3f* ps2, Triangle* ts, unsigned int* indices, int n, Matrix3f& M);
+void getCovariance(Vec3f* ps, Vec3f* ps2, Triangle* ts, unsigned int* indices, int n, Matrix3f& M) HPP_FCL_DLLAPI;
 
 /// @brief Compute the RSS bounding volume parameters: radius, rectangle size and the origin, given the BV axises.
-void getRadiusAndOriginAndRectangleSize(Vec3f* ps, Vec3f* ps2, Triangle* ts, unsigned int* indices, int n, const Matrix3f& axes, Vec3f& origin, FCL_REAL l[2], FCL_REAL& r);
+void getRadiusAndOriginAndRectangleSize(Vec3f* ps, Vec3f* ps2, Triangle* ts, unsigned int* indices, int n, const Matrix3f& axes, Vec3f& origin, FCL_REAL l[2], FCL_REAL& r) HPP_FCL_DLLAPI;
 
 /// @brief Compute the bounding volume extent and center for a set or subset of points, given the BV axises.
-void getExtentAndCenter(Vec3f* ps, Vec3f* ps2, Triangle* ts, unsigned int* indices, int n, Matrix3f& axes, Vec3f& center, Vec3f& extent);
+void getExtentAndCenter(Vec3f* ps, Vec3f* ps2, Triangle* ts, unsigned int* indices, int n, Matrix3f& axes, Vec3f& center, Vec3f& extent) HPP_FCL_DLLAPI;
 
 /// @brief Compute the center and radius for a triangle's circumcircle
-void circumCircleComputation(const Vec3f& a, const Vec3f& b, const Vec3f& c, Vec3f& center, FCL_REAL& radius);
+void circumCircleComputation(const Vec3f& a, const Vec3f& b, const Vec3f& c, Vec3f& center, FCL_REAL& radius) HPP_FCL_DLLAPI;
 
 /// @brief Compute the maximum distance from a given center point to a point cloud
-FCL_REAL maximumDistance(Vec3f* ps, Vec3f* ps2, Triangle* ts, unsigned int* indices, int n, const Vec3f& query);
+FCL_REAL maximumDistance(Vec3f* ps, Vec3f* ps2, Triangle* ts, unsigned int* indices, int n, const Vec3f& query) HPP_FCL_DLLAPI;
 
 }
 

include/hpp/fcl/collision.h

@@ -53,12 +53,12 @@ namespace fcl
 /// performs the collision between them. 
 /// Return value is the number of contacts generated between the two objects.
 std::size_t collide(const CollisionObject* o1, const CollisionObject* o2,
-                    const CollisionRequest& request, CollisionResult& result);
+                    const CollisionRequest& request, CollisionResult& result) HPP_FCL_DLLAPI;
 
 /// @copydoc collide(const CollisionObject*, const CollisionObject*, const CollisionRequest&, CollisionResult&)
 std::size_t collide(const CollisionGeometry* o1, const Transform3f& tf1,
                     const CollisionGeometry* o2, const Transform3f& tf2,
-                    const CollisionRequest& request, CollisionResult& result);
+                    const CollisionRequest& request, CollisionResult& result) HPP_FCL_DLLAPI;
 
 /// @copydoc collide(const CollisionObject*, const CollisionObject*, const CollisionRequest&, CollisionResult&)
 /// \note this function update the initial guess of \c request if requested.

include/hpp/fcl/collision_utility.h

@@ -23,7 +23,7 @@ namespace hpp
 {
 namespace fcl
 {
-  CollisionGeometry* extract(const CollisionGeometry* model, const Transform3f& pose, const AABB& aabb);
+  CollisionGeometry* extract(const CollisionGeometry* model, const Transform3f& pose, const AABB& aabb) HPP_FCL_DLLAPI;
 }
 
 } // namespace hpp

include/hpp/fcl/distance.h

@@ -48,12 +48,12 @@ namespace fcl
 
 /// @brief Main distance interface: given two collision objects, and the requirements for contacts, including whether return the nearest points, this function performs the distance between them. 
 /// Return value is the minimum distance generated between the two objects.
-FCL_REAL distance(const CollisionObject* o1, const CollisionObject* o2, const DistanceRequest& request, DistanceResult& result);
+FCL_REAL distance(const CollisionObject* o1, const CollisionObject* o2, const DistanceRequest& request, DistanceResult& result) HPP_FCL_DLLAPI;
 
 /// @copydoc distance(const CollisionObject*, const CollisionObject*, const DistanceRequest&, DistanceResult&)
 FCL_REAL distance(const CollisionGeometry* o1, const Transform3f& tf1,
                   const CollisionGeometry* o2, const Transform3f& tf2,
-                  const DistanceRequest& request, DistanceResult& result);
+                  const DistanceRequest& request, DistanceResult& result) HPP_FCL_DLLAPI;
 
 /// @copydoc distance(const CollisionObject*, const CollisionObject*, const DistanceRequest&, DistanceResult&)
 /// \note this function update the initial guess of \c request if requested.

include/hpp/fcl/mesh_loader/assimp.h

@@ -81,7 +81,7 @@ struct HPP_FCL_DLLAPI Loader {
 void buildMesh (const fcl::Vec3f & scale,
                 const aiScene* scene,
                 unsigned vertices_offset,
-                TriangleAndVertices & tv);
+                TriangleAndVertices & tv) HPP_FCL_DLLAPI;
 
 /**
  * @brief      Convert an assimp scene to a mesh

include/hpp/fcl/shape/geometric_shapes_utility.h

@@ -53,151 +53,151 @@ namespace fcl
 namespace details
 {
 /// @brief get the vertices of some convex shape which can bound the given shape in a specific configuration
-std::vector<Vec3f> getBoundVertices(const Box& box, const Transform3f& tf);
-std::vector<Vec3f> getBoundVertices(const Sphere& sphere, const Transform3f& tf);
-std::vector<Vec3f> getBoundVertices(const Capsule& capsule, const Transform3f& tf);
-std::vector<Vec3f> getBoundVertices(const Cone& cone, const Transform3f& tf);
-std::vector<Vec3f> getBoundVertices(const Cylinder& cylinder, const Transform3f& tf);
-std::vector<Vec3f> getBoundVertices(const ConvexBase& convex, const Transform3f& tf);
-std::vector<Vec3f> getBoundVertices(const TriangleP& triangle, const Transform3f& tf);
+std::vector<Vec3f> getBoundVertices(const Box& box, const Transform3f& tf) HPP_FCL_DLLAPI;
+std::vector<Vec3f> getBoundVertices(const Sphere& sphere, const Transform3f& tf) HPP_FCL_DLLAPI;
+std::vector<Vec3f> getBoundVertices(const Capsule& capsule, const Transform3f& tf) HPP_FCL_DLLAPI;
+std::vector<Vec3f> getBoundVertices(const Cone& cone, const Transform3f& tf) HPP_FCL_DLLAPI;
+std::vector<Vec3f> getBoundVertices(const Cylinder& cylinder, const Transform3f& tf) HPP_FCL_DLLAPI;
+std::vector<Vec3f> getBoundVertices(const ConvexBase& convex, const Transform3f& tf) HPP_FCL_DLLAPI;
+std::vector<Vec3f> getBoundVertices(const TriangleP& triangle, const Transform3f& tf) HPP_FCL_DLLAPI;
 } 
 /// @endcond
 
 
 /// @brief calculate a bounding volume for a shape in a specific configuration
 template<typename BV, typename S>
-void computeBV(const S& s, const Transform3f& tf, BV& bv)
+inline void computeBV(const S& s, const Transform3f& tf, BV& bv)
 {
   std::vector<Vec3f> convex_bound_vertices = details::getBoundVertices(s, tf);
   fit(&convex_bound_vertices[0], (int)convex_bound_vertices.size(), bv);
 }
 
 template<>
-void computeBV<AABB, Box>(const Box& s, const Transform3f& tf, AABB& bv);
+void computeBV<AABB, Box>(const Box& s, const Transform3f& tf, AABB& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<AABB, Sphere>(const Sphere& s, const Transform3f& tf, AABB& bv);
+void computeBV<AABB, Sphere>(const Sphere& s, const Transform3f& tf, AABB& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<AABB, Capsule>(const Capsule& s, const Transform3f& tf, AABB& bv);
+void computeBV<AABB, Capsule>(const Capsule& s, const Transform3f& tf, AABB& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<AABB, Cone>(const Cone& s, const Transform3f& tf, AABB& bv);
+void computeBV<AABB, Cone>(const Cone& s, const Transform3f& tf, AABB& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<AABB, Cylinder>(const Cylinder& s, const Transform3f& tf, AABB& bv);
+void computeBV<AABB, Cylinder>(const Cylinder& s, const Transform3f& tf, AABB& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<AABB, ConvexBase>(const ConvexBase& s, const Transform3f& tf, AABB& bv);
+void computeBV<AABB, ConvexBase>(const ConvexBase& s, const Transform3f& tf, AABB& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<AABB, TriangleP>(const TriangleP& s, const Transform3f& tf, AABB& bv);
+void computeBV<AABB, TriangleP>(const TriangleP& s, const Transform3f& tf, AABB& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<AABB, Halfspace>(const Halfspace& s, const Transform3f& tf, AABB& bv);
+void computeBV<AABB, Halfspace>(const Halfspace& s, const Transform3f& tf, AABB& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<AABB, Plane>(const Plane& s, const Transform3f& tf, AABB& bv);
+void computeBV<AABB, Plane>(const Plane& s, const Transform3f& tf, AABB& bv) HPP_FCL_DLLAPI;
 
 
 
 template<>
-void computeBV<OBB, Box>(const Box& s, const Transform3f& tf, OBB& bv);
+void computeBV<OBB, Box>(const Box& s, const Transform3f& tf, OBB& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<OBB, Sphere>(const Sphere& s, const Transform3f& tf, OBB& bv);
+void computeBV<OBB, Sphere>(const Sphere& s, const Transform3f& tf, OBB& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<OBB, Capsule>(const Capsule& s, const Transform3f& tf, OBB& bv);
+void computeBV<OBB, Capsule>(const Capsule& s, const Transform3f& tf, OBB& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<OBB, Cone>(const Cone& s, const Transform3f& tf, OBB& bv);
+void computeBV<OBB, Cone>(const Cone& s, const Transform3f& tf, OBB& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<OBB, Cylinder>(const Cylinder& s, const Transform3f& tf, OBB& bv);
+void computeBV<OBB, Cylinder>(const Cylinder& s, const Transform3f& tf, OBB& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<OBB, ConvexBase>(const ConvexBase& s, const Transform3f& tf, OBB& bv);
+void computeBV<OBB, ConvexBase>(const ConvexBase& s, const Transform3f& tf, OBB& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<OBB, Halfspace>(const Halfspace& s, const Transform3f& tf, OBB& bv);
+void computeBV<OBB, Halfspace>(const Halfspace& s, const Transform3f& tf, OBB& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<RSS, Halfspace>(const Halfspace& s, const Transform3f& tf, RSS& bv);
+void computeBV<RSS, Halfspace>(const Halfspace& s, const Transform3f& tf, RSS& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<OBBRSS, Halfspace>(const Halfspace& s, const Transform3f& tf, OBBRSS& bv);
+void computeBV<OBBRSS, Halfspace>(const Halfspace& s, const Transform3f& tf, OBBRSS& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<kIOS, Halfspace>(const Halfspace& s, const Transform3f& tf, kIOS& bv);
+void computeBV<kIOS, Halfspace>(const Halfspace& s, const Transform3f& tf, kIOS& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<KDOP<16>, Halfspace>(const Halfspace& s, const Transform3f& tf, KDOP<16>& bv);
+void computeBV<KDOP<16>, Halfspace>(const Halfspace& s, const Transform3f& tf, KDOP<16>& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<KDOP<18>, Halfspace>(const Halfspace& s, const Transform3f& tf, KDOP<18>& bv);
+void computeBV<KDOP<18>, Halfspace>(const Halfspace& s, const Transform3f& tf, KDOP<18>& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<KDOP<24>, Halfspace>(const Halfspace& s, const Transform3f& tf, KDOP<24>& bv);
+void computeBV<KDOP<24>, Halfspace>(const Halfspace& s, const Transform3f& tf, KDOP<24>& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<OBB, Plane>(const Plane& s, const Transform3f& tf, OBB& bv);
+void computeBV<OBB, Plane>(const Plane& s, const Transform3f& tf, OBB& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<RSS, Plane>(const Plane& s, const Transform3f& tf, RSS& bv);
+void computeBV<RSS, Plane>(const Plane& s, const Transform3f& tf, RSS& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<OBBRSS, Plane>(const Plane& s, const Transform3f& tf, OBBRSS& bv);
+void computeBV<OBBRSS, Plane>(const Plane& s, const Transform3f& tf, OBBRSS& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<kIOS, Plane>(const Plane& s, const Transform3f& tf, kIOS& bv);
+void computeBV<kIOS, Plane>(const Plane& s, const Transform3f& tf, kIOS& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<KDOP<16>, Plane>(const Plane& s, const Transform3f& tf, KDOP<16>& bv);
+void computeBV<KDOP<16>, Plane>(const Plane& s, const Transform3f& tf, KDOP<16>& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<KDOP<18>, Plane>(const Plane& s, const Transform3f& tf, KDOP<18>& bv);
+void computeBV<KDOP<18>, Plane>(const Plane& s, const Transform3f& tf, KDOP<18>& bv) HPP_FCL_DLLAPI;
 
 template<>
-void computeBV<KDOP<24>, Plane>(const Plane& s, const Transform3f& tf, KDOP<24>& bv);
+void computeBV<KDOP<24>, Plane>(const Plane& s, const Transform3f& tf, KDOP<24>& bv) HPP_FCL_DLLAPI;
 
 
 /// @brief construct a box shape (with a configuration) from a given bounding volume
-void constructBox(const AABB& bv, Box& box, Transform3f& tf);
+void constructBox(const AABB& bv, Box& box, Transform3f& tf) HPP_FCL_DLLAPI;
 
-void constructBox(const OBB& bv, Box& box, Transform3f& tf);
+void constructBox(const OBB& bv, Box& box, Transform3f& tf) HPP_FCL_DLLAPI;
 
-void constructBox(const OBBRSS& bv, Box& box, Transform3f& tf);
+void constructBox(const OBBRSS& bv, Box& box, Transform3f& tf) HPP_FCL_DLLAPI;
 
-void constructBox(const kIOS& bv, Box& box, Transform3f& tf);
+void constructBox(const kIOS& bv, Box& box, Transform3f& tf) HPP_FCL_DLLAPI;
 
-void constructBox(const RSS& bv, Box& box, Transform3f& tf);
+void constructBox(const RSS& bv, Box& box, Transform3f& tf) HPP_FCL_DLLAPI;
 
-void constructBox(const KDOP<16>& bv, Box& box, Transform3f& tf);
+void constructBox(const KDOP<16>& bv, Box& box, Transform3f& tf) HPP_FCL_DLLAPI;
 
-void constructBox(const KDOP<18>& bv, Box& box, Transform3f& tf);
+void constructBox(const KDOP<18>& bv, Box& box, Transform3f& tf) HPP_FCL_DLLAPI;
 
-void constructBox(const KDOP<24>& bv, Box& box, Transform3f& tf);
+void constructBox(const KDOP<24>& bv, Box& box, Transform3f& tf) HPP_FCL_DLLAPI;
 
-void constructBox(const AABB& bv, const Transform3f& tf_bv, Box& box, Transform3f& tf);
+void constructBox(const AABB& bv, const Transform3f& tf_bv, Box& box, Transform3f& tf) HPP_FCL_DLLAPI;
 
-void constructBox(const OBB& bv, const Transform3f& tf_bv, Box& box, Transform3f& tf);
+void constructBox(const OBB& bv, const Transform3f& tf_bv, Box& box, Transform3f& tf) HPP_FCL_DLLAPI;
 
-void constructBox(const OBBRSS& bv, const Transform3f& tf_bv, Box& box, Transform3f& tf);
+void constructBox(const OBBRSS& bv, const Transform3f& tf_bv, Box& box, Transform3f& tf) HPP_FCL_DLLAPI;
 
-void constructBox(const kIOS& bv, const Transform3f& tf_bv, Box& box, Transform3f& tf);
+void constructBox(const kIOS& bv, const Transform3f& tf_bv, Box& box, Transform3f& tf) HPP_FCL_DLLAPI;
 
-void constructBox(const RSS& bv, const Transform3f& tf_bv, Box& box, Transform3f& tf);
+void constructBox(const RSS& bv, const Transform3f& tf_bv, Box& box, Transform3f& tf) HPP_FCL_DLLAPI;
 
-void constructBox(const KDOP<16>& bv, const Transform3f& tf_bv, Box& box, Transform3f& tf);
+void constructBox(const KDOP<16>& bv, const Transform3f& tf_bv, Box& box, Transform3f& tf) HPP_FCL_DLLAPI;
 
-void constructBox(const KDOP<18>& bv, const Transform3f& tf_bv, Box& box, Transform3f& tf);
+void constructBox(const KDOP<18>& bv, const Transform3f& tf_bv, Box& box, Transform3f& tf) HPP_FCL_DLLAPI;
 
-void constructBox(const KDOP<24>& bv, const Transform3f& tf_bv, Box& box, Transform3f& tf);
+void constructBox(const KDOP<24>& bv, const Transform3f& tf_bv, Box& box, Transform3f& tf) HPP_FCL_DLLAPI;
 
-Halfspace transform(const Halfspace& a, const Transform3f& tf);
+Halfspace transform(const Halfspace& a, const Transform3f& tf) HPP_FCL_DLLAPI;
 
-Plane transform(const Plane& a, const Transform3f& tf);
+Plane transform(const Plane& a, const Transform3f& tf) HPP_FCL_DLLAPI;
 
 }
 

src/collision_node.h

@@ -58,12 +58,14 @@ namespace fcl
 ///         do not collide.
 /// @param front_list list of nodes visited by the query, can be used to
 ///        accelerate computation
+/// \todo should be HPP_FCL_LOCAL but used in unit test.
 void collide(CollisionTraversalNodeBase* node, const CollisionRequest& request,
              CollisionResult& result, BVHFrontList* front_list = NULL,
-             bool recursive = true);
+             bool recursive = true) HPP_FCL_DLLAPI;
 
 /// @brief distance computation on distance traversal node; can use front list to accelerate
-void distance(DistanceTraversalNodeBase* node, BVHFrontList* front_list = NULL, int qsize = 2);
+/// \todo should be HPP_FCL_LOCAL but used in unit test.
+void distance(DistanceTraversalNodeBase* node, BVHFrontList* front_list = NULL, int qsize = 2) HPP_FCL_DLLAPI;
 }
 
 } // namespace hpp