Namespaces | Classes | Typedefs | Functions | Variables
fcl::details Namespace Reference

FCL internals. More...

Namespaces

 internal
 

Classes

struct  eigen_m3
 
struct  eigen_v3
 
struct  eigen_wrapper_m3
 
struct  eigen_wrapper_v3
 
struct  eigen_wrapper_v4
 
struct  EPA
 class for EPA algorithm More...
 
struct  GJK
 class for GJK algorithm More...
 
class  GJKInitializer
 initialize GJK stuffs More...
 
class  GJKInitializer< Box >
 initialize GJK Box More...
 
class  GJKInitializer< Capsule >
 initialize GJK Capsule More...
 
class  GJKInitializer< Cone >
 initialize GJK Cone More...
 
class  GJKInitializer< Convex >
 initialize GJK Convex More...
 
class  GJKInitializer< Cylinder >
 initialize GJK Cylinder More...
 
class  GJKInitializer< Sphere >
 initialize GJK Sphere More...
 
struct  Matrix3Data
 
struct  MinkowskiDiff
 Minkowski difference class of two shapes. More...
 
struct  sse_meta_d4
 
struct  sse_meta_f12
 
struct  sse_meta_f16
 
struct  sse_meta_f4
 
struct  Vec3Data
 

Typedefs

typedef void(* GJKSupportFunction) (const void *obj, const ccd_vec3_t *dir_, ccd_vec3_t *v)
 callback function used by GJK algorithm More...
 
typedef void(* GJKCenterFunction) (const void *obj, ccd_vec3_t *c)
 

Functions

template<typename T >
static eigen_wrapper_v3< T > cross_prod (const eigen_wrapper_v3< T > &l, const eigen_wrapper_v3< T > &r)
 
template<typename T >
static T dot_prod3 (const eigen_wrapper_v3< T > &l, const eigen_wrapper_v3< T > &r)
 
template<typename T >
static eigen_wrapper_v3< T > min (const eigen_wrapper_v3< T > &x, const eigen_wrapper_v3< T > &y)
 
template<typename T >
static eigen_wrapper_v3< T > max (const eigen_wrapper_v3< T > &x, const eigen_wrapper_v3< T > &y)
 
template<typename T >
static eigen_wrapper_v3< T > abs (const eigen_wrapper_v3< T > &x)
 
template<typename T >
static bool equal (const eigen_wrapper_v3< T > &x, const eigen_wrapper_v3< T > &y, T epsilon)
 
template<typename T >
struct fcl::details::eigen_wrapper_v4 __attribute__ ((aligned))
 
template<typename T >
static eigen_wrapper_v4< T > cross_prod (const eigen_wrapper_v4< T > &l, const eigen_wrapper_v4< T > &r)
 
template<typename T >
static T dot_prod3 (const eigen_wrapper_v4< T > &l, const eigen_wrapper_v4< T > &r)
 
template<typename T >
static eigen_wrapper_v4< T > min (const eigen_wrapper_v4< T > &x, const eigen_wrapper_v4< T > &y)
 
template<typename T >
static eigen_wrapper_v4< T > max (const eigen_wrapper_v4< T > &x, const eigen_wrapper_v4< T > &y)
 
template<typename T >
static eigen_wrapper_v4< T > abs (const eigen_wrapper_v4< T > &x)
 
template<typename T >
static bool equal (const eigen_wrapper_v4< T > &x, const eigen_wrapper_v4< T > &y, T epsilon)
 
template<typename T >
static eigen_v3< T > cross_prod (const eigen_v3< T > &l, const eigen_v3< T > &r)
 
template<typename T >
static T dot_prod3 (const eigen_v3< T > &l, const eigen_v3< T > &r)
 
template<typename T >
static eigen_v3< T > min (const eigen_v3< T > &x, const eigen_v3< T > &y)
 
template<typename T >
static eigen_v3< T > max (const eigen_v3< T > &x, const eigen_v3< T > &y)
 
template<typename T >
static eigen_v3< T > abs (const eigen_v3< T > &x)
 
template<typename T >
static bool equal (const eigen_v3< T > &x, const eigen_v3< T > &y, T epsilon)
 
template<typename T >
eigen_wrapper_m3< T > abs (const eigen_wrapper_m3< T > &m)
 
template<typename T >
eigen_wrapper_m3< T > transpose (const eigen_wrapper_m3< T > &m)
 
template<typename T >
eigen_wrapper_m3< T > inverse (const eigen_wrapper_m3< T > &m)
 
template<typename T >
eigen_m3< T > abs (const eigen_m3< T > &m)
 
template<typename T >
eigen_m3< T > transpose (const eigen_m3< T > &m)
 
template<typename T >
eigen_m3< T > inverse (const eigen_m3< T > &m)
 
template<typename T >
static Vec3Data< T > cross_prod (const Vec3Data< T > &l, const Vec3Data< T > &r)
 
template<typename T >
static T dot_prod3 (const Vec3Data< T > &l, const Vec3Data< T > &r)
 
template<typename T >
static Vec3Data< T > min (const Vec3Data< T > &x, const Vec3Data< T > &y)
 
template<typename T >
static Vec3Data< T > max (const Vec3Data< T > &x, const Vec3Data< T > &y)
 
template<typename T >
static Vec3Data< T > abs (const Vec3Data< T > &x)
 
template<typename T >
static bool equal (const Vec3Data< T > &x, const Vec3Data< T > &y, T epsilon)
 
template<typename T >
Matrix3Data< T > abs (const Matrix3Data< T > &m)
 
template<typename T >
Matrix3Data< T > transpose (const Matrix3Data< T > &m)
 
template<typename T >
Matrix3Data< T > inverse (const Matrix3Data< T > &m)
 
Vec3f getSupport (const ShapeBase *shape, const Vec3f &dir)
 the support function for shape More...
 
GJKSupportFunction triGetSupportFunction ()
 initialize GJK Triangle More...
 
GJKCenterFunction triGetCenterFunction ()
 
void * triCreateGJKObject (const Vec3f &P1, const Vec3f &P2, const Vec3f &P3)
 
void * triCreateGJKObject (const Vec3f &P1, const Vec3f &P2, const Vec3f &P3, const Transform3f &tf)
 
void triDeleteGJKObject (void *o)
 
bool GJKCollide (void *obj1, ccd_support_fn supp1, ccd_center_fn cen1, void *obj2, ccd_support_fn supp2, ccd_center_fn cen2, unsigned int max_iterations, FCL_REAL tolerance, Vec3f *contact_points, FCL_REAL *penetration_depth, Vec3f *normal)
 GJK collision algorithm. More...
 
bool GJKDistance (void *obj1, ccd_support_fn supp1, void *obj2, ccd_support_fn supp2, unsigned int max_iterations, FCL_REAL tolerance, FCL_REAL *dist, Vec3f *p1, Vec3f *p2)
 Distance computation between objects using GJK algorithm. More...
 
static __m128 vec_sel (__m128 a, __m128 b, __m128 mask)
 
static __m128 vec_sel (__m128 a, __m128 b, const unsigned int *mask)
 
static __m128 vec_sel (__m128 a, __m128 b, unsigned int mask)
 
static __m128 newtonraphson_rsqrt4 (const __m128 v)
 
struct fcl::details::sse_meta_f4 __attribute__ ((aligned(16)))
 
static __m128 cross_prod (__m128 x, __m128 y)
 
static sse_meta_f4 cross_prod (const sse_meta_f4 &x, const sse_meta_f4 &y)
 
static void cross_prod (__m128d x0, __m128d x1, __m128d y0, __m128d y1, __m128d *z0, __m128d *z1)
 
static sse_meta_d4 cross_prod (const sse_meta_d4 &x, const sse_meta_d4 &y)
 
static __m128 dot_prod3 (__m128 x, __m128 y)
 
static float dot_prod3 (const sse_meta_f4 &x, const sse_meta_f4 &y)
 
static __m128d dot_prod3 (__m128d x0, __m128d x1, __m128d y0, __m128d y1)
 
static double dot_prod3 (const sse_meta_d4 &x, const sse_meta_d4 &y)
 
static __m128 dot_prod4 (__m128 x, __m128 y)
 
static float dot_prod4 (const sse_meta_f4 &x, const sse_meta_f4 &y)
 
static __m128d dot_prod4 (__m128d x0, __m128d x1, __m128d y0, __m128d y1)
 
static double dot_prod4 (const sse_meta_d4 &x, const sse_meta_d4 &y)
 
static sse_meta_f4 min (const sse_meta_f4 &x, const sse_meta_f4 &y)
 
static sse_meta_d4 min (const sse_meta_d4 &x, const sse_meta_d4 &y)
 
static sse_meta_f4 max (const sse_meta_f4 &x, const sse_meta_f4 &y)
 
static sse_meta_d4 max (const sse_meta_d4 &x, const sse_meta_d4 &y)
 
static sse_meta_f4 abs (const sse_meta_f4 &x)
 
static sse_meta_d4 abs (const sse_meta_d4 &x)
 
static bool equal (const sse_meta_f4 &x, const sse_meta_f4 &y, float epsilon)
 
static bool equal (const sse_meta_d4 &x, const sse_meta_d4 &y, double epsilon)
 
static sse_meta_f4 normalize3 (const sse_meta_f4 &x)
 
static sse_meta_f4 normalize3_approx (const sse_meta_f4 &x)
 
static void transpose (__m128 c0, __m128 c1, __m128 c2, __m128 *r0, __m128 *r1, __m128 *r2)
 
static void inverse (__m128 c0, __m128 c1, __m128 c2, __m128 *i0, __m128 *i1, __m128 *i2)
 
static sse_meta_f12 abs (const sse_meta_f12 &mat)
 
static sse_meta_f12 transpose (const sse_meta_f12 &mat)
 
static sse_meta_f12 inverse (const sse_meta_f12 &mat)
 
static void transpose (__m128 c0, __m128 c1, __m128 c2, __m128 c3, __m128 *r0, __m128 *r1, __m128 *r2, __m128 *r3)
 
static void inverse (__m128 c0, __m128 c1, __m128 c2, __m128 c3, __m128 *res0, __m128 *res1, __m128 *res2, __m128 *res3)
 
static sse_meta_f16 abs (const sse_meta_f16 &mat)
 
static sse_meta_f16 transpose (const sse_meta_f16 &mat)
 
static sse_meta_f16 inverse (const sse_meta_f16 &mat)
 
template<typename BV , typename S , typename NarrowPhaseSolver >
void meshShapeConservativeAdvancementOrientedNodeLeafTesting (int b1, int, const BVHModel< BV > *model1, const S &model2, const BV &model2_bv, Vec3f *vertices, Triangle *tri_indices, const Transform3f &tf1, const Transform3f &tf2, const MotionBase *motion1, const MotionBase *motion2, const NarrowPhaseSolver *nsolver, bool enable_statistics, FCL_REAL &min_distance, Vec3f &p1, Vec3f &p2, int &last_tri_id, FCL_REAL &delta_t, int &num_leaf_tests)
 
template<typename BV , typename S >
bool meshShapeConservativeAdvancementOrientedNodeCanStop (FCL_REAL c, FCL_REAL min_distance, FCL_REAL abs_err, FCL_REAL rel_err, FCL_REAL w, const BVHModel< BV > *model1, const S &model2, const BV &model2_bv, const MotionBase *motion1, const MotionBase *motion2, std::vector< ConservativeAdvancementStackData > &stack, FCL_REAL &delta_t)
 
template<typename BV >
const Vec3fgetBVAxis (const BV &bv, int i)
 
template<>
const Vec3fgetBVAxis< OBBRSS > (const OBBRSS &bv, int i)
 
template<typename BV >
bool meshConservativeAdvancementTraversalNodeCanStop (FCL_REAL c, FCL_REAL min_distance, FCL_REAL abs_err, FCL_REAL rel_err, FCL_REAL w, const BVHModel< BV > *model1, const BVHModel< BV > *model2, const MotionBase *motion1, const MotionBase *motion2, std::vector< ConservativeAdvancementStackData > &stack, FCL_REAL &delta_t)
 
template<typename S , typename BV , typename NarrowPhaseSolver , template< typename, typename > class OrientedNode>
static bool setupShapeMeshDistanceOrientedNode (OrientedNode< S, NarrowPhaseSolver > &node, const S &model1, const Transform3f &tf1, const BVHModel< BV > &model2, const Transform3f &tf2, const NarrowPhaseSolver *nsolver, const DistanceRequest &request, DistanceResult &result)
 

Variables

fcl::details::eigen_v3 __attribute__
 
static const size_t EPA_MAX_FACES = 128
 
static const size_t EPA_MAX_VERTICES = 64
 
static const FCL_REAL EPA_EPS = 0.000001
 
static const size_t EPA_MAX_ITERATIONS = 255
 
const __m128 xmms_0 = {0.f, 0.f, 0.f, 0.f}
 
const __m128d xmmd_0 = {0, 0}
 

Detailed Description

FCL internals.

for OBB and RSS, there is local coordinate of BV, so normal need to be transformed

Ignore this :) unless you are God

Typedef Documentation

◆ GJKCenterFunction

typedef void(* fcl::details::GJKCenterFunction) (const void *obj, ccd_vec3_t *c)

◆ GJKSupportFunction

typedef void(* fcl::details::GJKSupportFunction) (const void *obj, const ccd_vec3_t *dir_, ccd_vec3_t *v)

callback function used by GJK algorithm

Function Documentation

◆ __attribute__() [1/2]

struct fcl::details::sse_meta_f4 fcl::details::__attribute__ ( (aligned(16))  )

◆ __attribute__() [2/2]

template<typename T >
struct fcl::details::eigen_wrapper_v4 fcl::details::__attribute__ ( (aligned)  )

◆ abs() [1/11]

template<typename T >
static eigen_wrapper_v3<T> fcl::details::abs ( const eigen_wrapper_v3< T > &  x)
inlinestatic

◆ abs() [2/11]

template<typename T >
static Vec3Data<T> fcl::details::abs ( const Vec3Data< T > &  x)
inlinestatic

◆ abs() [3/11]

template<typename T >
static eigen_wrapper_v4<T> fcl::details::abs ( const eigen_wrapper_v4< T > &  x)
inlinestatic

◆ abs() [4/11]

static sse_meta_f4 fcl::details::abs ( const sse_meta_f4 x)
inlinestatic

◆ abs() [5/11]

static sse_meta_d4 fcl::details::abs ( const sse_meta_d4 x)
inlinestatic

◆ abs() [6/11]

template<typename T >
static eigen_v3<T> fcl::details::abs ( const eigen_v3< T > &  x)
inlinestatic

◆ abs() [7/11]

template<typename T >
Matrix3Data<T> fcl::details::abs ( const Matrix3Data< T > &  m)

References abs(), and fcl::details::Matrix3Data< T >::rs.

Referenced by abs().

◆ abs() [8/11]

template<typename T >
eigen_wrapper_m3<T> fcl::details::abs ( const eigen_wrapper_m3< T > &  m)

◆ abs() [9/11]

static sse_meta_f12 fcl::details::abs ( const sse_meta_f12 mat)
inlinestatic

◆ abs() [10/11]

template<typename T >
eigen_m3<T> fcl::details::abs ( const eigen_m3< T > &  m)

◆ abs() [11/11]

static sse_meta_f16 fcl::details::abs ( const sse_meta_f16 mat)
inlinestatic

◆ cross_prod() [1/8]

template<typename T >
static eigen_wrapper_v3<T> fcl::details::cross_prod ( const eigen_wrapper_v3< T > &  l,
const eigen_wrapper_v3< T > &  r 
)
inlinestatic

◆ cross_prod() [2/8]

template<typename T >
static Vec3Data<T> fcl::details::cross_prod ( const Vec3Data< T > &  l,
const Vec3Data< T > &  r 
)
inlinestatic

◆ cross_prod() [3/8]

static __m128 fcl::details::cross_prod ( __m128  x,
__m128  y 
)
inlinestatic

◆ cross_prod() [4/8]

static sse_meta_f4 fcl::details::cross_prod ( const sse_meta_f4 x,
const sse_meta_f4 y 
)
inlinestatic

◆ cross_prod() [5/8]

template<typename T >
static eigen_wrapper_v4<T> fcl::details::cross_prod ( const eigen_wrapper_v4< T > &  l,
const eigen_wrapper_v4< T > &  r 
)
inlinestatic

◆ cross_prod() [6/8]

static void fcl::details::cross_prod ( __m128d  x0,
__m128d  x1,
__m128d  y0,
__m128d  y1,
__m128d *  z0,
__m128d *  z1 
)
inlinestatic

◆ cross_prod() [7/8]

static sse_meta_d4 fcl::details::cross_prod ( const sse_meta_d4 x,
const sse_meta_d4 y 
)
inlinestatic

◆ cross_prod() [8/8]

template<typename T >
static eigen_v3<T> fcl::details::cross_prod ( const eigen_v3< T > &  l,
const eigen_v3< T > &  r 
)
inlinestatic

◆ dot_prod3() [1/8]

template<typename T >
static T fcl::details::dot_prod3 ( const eigen_wrapper_v3< T > &  l,
const eigen_wrapper_v3< T > &  r 
)
inlinestatic

◆ dot_prod3() [2/8]

template<typename T >
static T fcl::details::dot_prod3 ( const Vec3Data< T > &  l,
const Vec3Data< T > &  r 
)
inlinestatic

◆ dot_prod3() [3/8]

template<typename T >
static T fcl::details::dot_prod3 ( const eigen_wrapper_v4< T > &  l,
const eigen_wrapper_v4< T > &  r 
)
inlinestatic

◆ dot_prod3() [4/8]

static __m128 fcl::details::dot_prod3 ( __m128  x,
__m128  y 
)
inlinestatic

References vec_splat.

◆ dot_prod3() [5/8]

static float fcl::details::dot_prod3 ( const sse_meta_f4 x,
const sse_meta_f4 y 
)
inlinestatic

References dot_prod3().

◆ dot_prod3() [6/8]

static __m128d fcl::details::dot_prod3 ( __m128d  x0,
__m128d  x1,
__m128d  y0,
__m128d  y1 
)
inlinestatic

References vec_splatd.

◆ dot_prod3() [7/8]

static double fcl::details::dot_prod3 ( const sse_meta_d4 x,
const sse_meta_d4 y 
)
inlinestatic

◆ dot_prod3() [8/8]

template<typename T >
static T fcl::details::dot_prod3 ( const eigen_v3< T > &  l,
const eigen_v3< T > &  r 
)
inlinestatic

◆ dot_prod4() [1/4]

static __m128 fcl::details::dot_prod4 ( __m128  x,
__m128  y 
)
inlinestatic

◆ dot_prod4() [2/4]

static float fcl::details::dot_prod4 ( const sse_meta_f4 x,
const sse_meta_f4 y 
)
inlinestatic

References dot_prod4().

◆ dot_prod4() [3/4]

static __m128d fcl::details::dot_prod4 ( __m128d  x0,
__m128d  x1,
__m128d  y0,
__m128d  y1 
)
inlinestatic

◆ dot_prod4() [4/4]

static double fcl::details::dot_prod4 ( const sse_meta_d4 x,
const sse_meta_d4 y 
)
inlinestatic

◆ equal() [1/6]

template<typename T >
static bool fcl::details::equal ( const eigen_wrapper_v3< T > &  x,
const eigen_wrapper_v3< T > &  y,
epsilon 
)
inlinestatic

◆ equal() [2/6]

template<typename T >
static bool fcl::details::equal ( const Vec3Data< T > &  x,
const Vec3Data< T > &  y,
epsilon 
)
inlinestatic

◆ equal() [3/6]

template<typename T >
static bool fcl::details::equal ( const eigen_wrapper_v4< T > &  x,
const eigen_wrapper_v4< T > &  y,
epsilon 
)
inlinestatic

◆ equal() [4/6]

static bool fcl::details::equal ( const sse_meta_f4 x,
const sse_meta_f4 y,
float  epsilon 
)
inlinestatic

References d().

◆ equal() [5/6]

static bool fcl::details::equal ( const sse_meta_d4 x,
const sse_meta_d4 y,
double  epsilon 
)
inlinestatic

◆ equal() [6/6]

template<typename T >
static bool fcl::details::equal ( const eigen_v3< T > &  x,
const eigen_v3< T > &  y,
epsilon 
)
inlinestatic

◆ getBVAxis()

template<typename BV >
const Vec3f& fcl::details::getBVAxis ( const BV &  bv,
int  i 
)

◆ getBVAxis< OBBRSS >()

template<>
const Vec3f& fcl::details::getBVAxis< OBBRSS > ( const OBBRSS bv,
int  i 
)
inline

◆ getSupport()

Vec3f fcl::details::getSupport ( const ShapeBase shape,
const Vec3f dir 
)

◆ GJKCollide()

bool fcl::details::GJKCollide ( void *  obj1,
ccd_support_fn  supp1,
ccd_center_fn  cen1,
void *  obj2,
ccd_support_fn  supp2,
ccd_center_fn  cen2,
unsigned int  max_iterations,
FCL_REAL  tolerance,
Vec3f contact_points,
FCL_REAL penetration_depth,
Vec3f normal 
)

◆ GJKDistance()

bool fcl::details::GJKDistance ( void *  obj1,
ccd_support_fn  supp1,
void *  obj2,
ccd_support_fn  supp2,
unsigned int  max_iterations,
FCL_REAL  tolerance,
FCL_REAL dist,
Vec3f p1,
Vec3f p2 
)

Distance computation between objects using GJK algorithm.

Parameters
obj1,obj2objects to compute the distance between,
supp1,supp2,supportfunctions of each object,
Return values
p1,p2closest points on objects in global frame,
distdistance between objects,
Returns
whether distance is non negative (no collision).

Referenced by fcl::GJKSolver_libccd::shapeDistance(), and fcl::GJKSolver_libccd::shapeTriangleDistance().

◆ inverse() [1/7]

static void fcl::details::inverse ( __m128  c0,
__m128  c1,
__m128  c2,
__m128 *  i0,
__m128 *  i1,
__m128 *  i2 
)
inlinestatic

◆ inverse() [2/7]

template<typename T >
Matrix3Data<T> fcl::details::inverse ( const Matrix3Data< T > &  m)

◆ inverse() [3/7]

template<typename T >
eigen_wrapper_m3<T> fcl::details::inverse ( const eigen_wrapper_m3< T > &  m)

◆ inverse() [4/7]

static sse_meta_f12 fcl::details::inverse ( const sse_meta_f12 mat)
inlinestatic

◆ inverse() [5/7]

static void fcl::details::inverse ( __m128  c0,
__m128  c1,
__m128  c2,
__m128  c3,
__m128 *  res0,
__m128 *  res1,
__m128 *  res2,
__m128 *  res3 
)
inlinestatic

References __attribute__, and _mm_ror_ps.

◆ inverse() [6/7]

template<typename T >
eigen_m3<T> fcl::details::inverse ( const eigen_m3< T > &  m)

◆ inverse() [7/7]

static sse_meta_f16 fcl::details::inverse ( const sse_meta_f16 mat)
inlinestatic

◆ max() [1/6]

template<typename T >
static eigen_wrapper_v3<T> fcl::details::max ( const eigen_wrapper_v3< T > &  x,
const eigen_wrapper_v3< T > &  y 
)
inlinestatic

◆ max() [2/6]

template<typename T >
static Vec3Data<T> fcl::details::max ( const Vec3Data< T > &  x,
const Vec3Data< T > &  y 
)
inlinestatic

◆ max() [3/6]

template<typename T >
static eigen_wrapper_v4<T> fcl::details::max ( const eigen_wrapper_v4< T > &  x,
const eigen_wrapper_v4< T > &  y 
)
inlinestatic

◆ max() [4/6]

static sse_meta_f4 fcl::details::max ( const sse_meta_f4 x,
const sse_meta_f4 y 
)
inlinestatic

◆ max() [5/6]

static sse_meta_d4 fcl::details::max ( const sse_meta_d4 x,
const sse_meta_d4 y 
)
inlinestatic

◆ max() [6/6]

template<typename T >
static eigen_v3<T> fcl::details::max ( const eigen_v3< T > &  x,
const eigen_v3< T > &  y 
)
inlinestatic

◆ meshConservativeAdvancementTraversalNodeCanStop()

template<typename BV >
bool fcl::details::meshConservativeAdvancementTraversalNodeCanStop ( FCL_REAL  c,
FCL_REAL  min_distance,
FCL_REAL  abs_err,
FCL_REAL  rel_err,
FCL_REAL  w,
const BVHModel< BV > *  model1,
const BVHModel< BV > *  model2,
const MotionBase motion1,
const MotionBase motion2,
std::vector< ConservativeAdvancementStackData > &  stack,
FCL_REAL delta_t 
)

◆ meshShapeConservativeAdvancementOrientedNodeCanStop()

template<typename BV , typename S >
bool fcl::details::meshShapeConservativeAdvancementOrientedNodeCanStop ( FCL_REAL  c,
FCL_REAL  min_distance,
FCL_REAL  abs_err,
FCL_REAL  rel_err,
FCL_REAL  w,
const BVHModel< BV > *  model1,
const S &  model2,
const BV &  model2_bv,
const MotionBase motion1,
const MotionBase motion2,
std::vector< ConservativeAdvancementStackData > &  stack,
FCL_REAL delta_t 
)

◆ meshShapeConservativeAdvancementOrientedNodeLeafTesting()

template<typename BV , typename S , typename NarrowPhaseSolver >
void fcl::details::meshShapeConservativeAdvancementOrientedNodeLeafTesting ( int  b1,
int  ,
const BVHModel< BV > *  model1,
const S &  model2,
const BV &  model2_bv,
Vec3f vertices,
Triangle tri_indices,
const Transform3f tf1,
const Transform3f tf2,
const MotionBase motion1,
const MotionBase motion2,
const NarrowPhaseSolver *  nsolver,
bool  enable_statistics,
FCL_REAL min_distance,
Vec3f p1,
Vec3f p2,
int &  last_tri_id,
FCL_REAL delta_t,
int &  num_leaf_tests 
)

◆ min() [1/6]

template<typename T >
static eigen_wrapper_v3<T> fcl::details::min ( const eigen_wrapper_v3< T > &  x,
const eigen_wrapper_v3< T > &  y 
)
inlinestatic

◆ min() [2/6]

template<typename T >
static Vec3Data<T> fcl::details::min ( const Vec3Data< T > &  x,
const Vec3Data< T > &  y 
)
inlinestatic

◆ min() [3/6]

template<typename T >
static eigen_wrapper_v4<T> fcl::details::min ( const eigen_wrapper_v4< T > &  x,
const eigen_wrapper_v4< T > &  y 
)
inlinestatic

◆ min() [4/6]

static sse_meta_f4 fcl::details::min ( const sse_meta_f4 x,
const sse_meta_f4 y 
)
inlinestatic

◆ min() [5/6]

static sse_meta_d4 fcl::details::min ( const sse_meta_d4 x,
const sse_meta_d4 y 
)
inlinestatic

◆ min() [6/6]

template<typename T >
static eigen_v3<T> fcl::details::min ( const eigen_v3< T > &  x,
const eigen_v3< T > &  y 
)
inlinestatic

◆ newtonraphson_rsqrt4()

static __m128 fcl::details::newtonraphson_rsqrt4 ( const __m128  v)
inlinestatic

Referenced by normalize3().

◆ normalize3()

static sse_meta_f4 fcl::details::normalize3 ( const sse_meta_f4 x)
inlinestatic

◆ normalize3_approx()

static sse_meta_f4 fcl::details::normalize3_approx ( const sse_meta_f4 x)
inlinestatic

◆ setupShapeMeshDistanceOrientedNode()

template<typename S , typename BV , typename NarrowPhaseSolver , template< typename, typename > class OrientedNode>
static bool fcl::details::setupShapeMeshDistanceOrientedNode ( OrientedNode< S, NarrowPhaseSolver > &  node,
const S &  model1,
const Transform3f tf1,
const BVHModel< BV > &  model2,
const Transform3f tf2,
const NarrowPhaseSolver *  nsolver,
const DistanceRequest request,
DistanceResult result 
)
inlinestatic

◆ transpose() [1/7]

static void fcl::details::transpose ( __m128  c0,
__m128  c1,
__m128  c2,
__m128 *  r0,
__m128 *  r1,
__m128 *  r2 
)
inlinestatic

References __attribute__, vec_sel(), and vec_splat.

◆ transpose() [2/7]

template<typename T >
Matrix3Data<T> fcl::details::transpose ( const Matrix3Data< T > &  m)

◆ transpose() [3/7]

template<typename T >
eigen_wrapper_m3<T> fcl::details::transpose ( const eigen_wrapper_m3< T > &  m)

◆ transpose() [4/7]

static sse_meta_f12 fcl::details::transpose ( const sse_meta_f12 mat)
inlinestatic

◆ transpose() [5/7]

static void fcl::details::transpose ( __m128  c0,
__m128  c1,
__m128  c2,
__m128  c3,
__m128 *  r0,
__m128 *  r1,
__m128 *  r2,
__m128 *  r3 
)
inlinestatic

◆ transpose() [6/7]

template<typename T >
eigen_m3<T> fcl::details::transpose ( const eigen_m3< T > &  m)

◆ transpose() [7/7]

static sse_meta_f16 fcl::details::transpose ( const sse_meta_f16 mat)
inlinestatic

◆ triCreateGJKObject() [1/2]

void* fcl::details::triCreateGJKObject ( const Vec3f P1,
const Vec3f P2,
const Vec3f P3 
)

◆ triCreateGJKObject() [2/2]

void* fcl::details::triCreateGJKObject ( const Vec3f P1,
const Vec3f P2,
const Vec3f P3,
const Transform3f tf 
)

◆ triDeleteGJKObject()

void fcl::details::triDeleteGJKObject ( void *  o)

◆ triGetCenterFunction()

GJKCenterFunction fcl::details::triGetCenterFunction ( )

◆ triGetSupportFunction()

GJKSupportFunction fcl::details::triGetSupportFunction ( )

◆ vec_sel() [1/3]

static __m128 fcl::details::vec_sel ( __m128  a,
__m128  b,
__m128  mask 
)
inlinestatic

Referenced by transpose(), and vec_sel().

◆ vec_sel() [2/3]

static __m128 fcl::details::vec_sel ( __m128  a,
__m128  b,
const unsigned int *  mask 
)
inlinestatic

References vec_sel().

◆ vec_sel() [3/3]

static __m128 fcl::details::vec_sel ( __m128  a,
__m128  b,
unsigned int  mask 
)
inlinestatic

References vec_sel().

Variable Documentation

◆ __attribute__

struct fcl::details::sse_meta_f12 fcl::details::__attribute__

◆ EPA_EPS

const FCL_REAL fcl::details::EPA_EPS = 0.000001
static

◆ EPA_MAX_FACES

const size_t fcl::details::EPA_MAX_FACES = 128
static

◆ EPA_MAX_ITERATIONS

const size_t fcl::details::EPA_MAX_ITERATIONS = 255
static

◆ EPA_MAX_VERTICES

const size_t fcl::details::EPA_MAX_VERTICES = 64
static

◆ xmmd_0

const __m128d fcl::details::xmmd_0 = {0, 0}

◆ xmms_0

const __m128 fcl::details::xmms_0 = {0.f, 0.f, 0.f, 0.f}