btGjkEpa3.h

Go to the documentation of this file.

/*
Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2003-2014 Erwin Coumans  http://continuousphysics.com/Bullet/

This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the
use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely,
subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software in a
product, an acknowledgment in the product documentation would be appreciated
but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/

/*
Initial GJK-EPA collision solver by Nathanael Presson, 2008
Improvements and refactoring by Erwin Coumans, 2008-2014
*/
#ifndef BT_GJK_EPA3_H
#define BT_GJK_EPA3_H

#include "LinearMath/btTransform.h"
#include "btGjkCollisionDescription.h"

struct btGjkEpaSolver3
{
        struct sResults
        {
                enum eStatus
                {
                        Separated,   /* Shapes doesnt penetrate                                                                                         */
                        Penetrating, /* Shapes are penetrating                                                                                          */
                        GJK_Failed,  /* GJK phase fail, no big issue, shapes are probably just 'touching'       */
                        EPA_Failed   /* EPA phase fail, bigger problem, need to save parameters, and debug      */
                } status;
                btVector3 witnesses[2];
                btVector3 normal;
                btScalar distance;
        };
};

#if defined(DEBUG) || defined(_DEBUG)
#include <stdio.h>  //for debug printf
#ifdef __SPU__
#include <spu_printf.h>
#define printf spu_printf
#endif  //__SPU__
#endif

// Config

/* GJK  */
#define GJK_MAX_ITERATIONS 128
#define GJK_ACCURARY ((btScalar)0.0001)
#define GJK_MIN_DISTANCE ((btScalar)0.0001)
#define GJK_DUPLICATED_EPS ((btScalar)0.0001)
#define GJK_SIMPLEX2_EPS ((btScalar)0.0)
#define GJK_SIMPLEX3_EPS ((btScalar)0.0)
#define GJK_SIMPLEX4_EPS ((btScalar)0.0)

/* EPA  */
#define EPA_MAX_VERTICES 64
#define EPA_MAX_FACES (EPA_MAX_VERTICES * 2)
#define EPA_MAX_ITERATIONS 255
#define EPA_ACCURACY ((btScalar)0.0001)
#define EPA_FALLBACK (10 * EPA_ACCURACY)
#define EPA_PLANE_EPS ((btScalar)0.00001)
#define EPA_INSIDE_EPS ((btScalar)0.01)

// Shorthands
typedef unsigned int U;
typedef unsigned char U1;

// MinkowskiDiff
template <typename btConvexTemplate>
struct MinkowskiDiff
{
        const btConvexTemplate* m_convexAPtr;
        const btConvexTemplate* m_convexBPtr;

        btMatrix3x3 m_toshape1;
        btTransform m_toshape0;

        bool m_enableMargin;

        MinkowskiDiff(const btConvexTemplate& a, const btConvexTemplate& b)
                : m_convexAPtr(&a),
                  m_convexBPtr(&b)
        {
        }

        void EnableMargin(bool enable)
        {
                m_enableMargin = enable;
        }
        inline btVector3 Support0(const btVector3& d) const
        {
                return m_convexAPtr->getLocalSupportWithMargin(d);
        }
        inline btVector3 Support1(const btVector3& d) const
        {
                return m_toshape0 * m_convexBPtr->getLocalSupportWithMargin(m_toshape1 * d);
        }

        inline btVector3 Support(const btVector3& d) const
        {
                return (Support0(d) - Support1(-d));
        }
        btVector3 Support(const btVector3& d, U index) const
        {
                if (index)
                        return (Support1(d));
                else
                        return (Support0(d));
        }
};

enum eGjkStatus
{
        eGjkValid,
        eGjkInside,
        eGjkFailed
};

// GJK
template <typename btConvexTemplate>
struct GJK
{
        /* Types                */
        struct sSV
        {
                btVector3 d, w;
        };
        struct sSimplex
        {
                sSV* c[4];
                btScalar p[4];
                U rank;
        };

        /* Fields               */

        MinkowskiDiff<btConvexTemplate> m_shape;
        btVector3 m_ray;
        btScalar m_distance;
        sSimplex m_simplices[2];
        sSV m_store[4];
        sSV* m_free[4];
        U m_nfree;
        U m_current;
        sSimplex* m_simplex;
        eGjkStatus m_status;
        /* Methods              */

        GJK(const btConvexTemplate& a, const btConvexTemplate& b)
                : m_shape(a, b)
        {
                Initialize();
        }
        void Initialize()
        {
                m_ray = btVector3(0, 0, 0);
                m_nfree = 0;
                m_status = eGjkFailed;
                m_current = 0;
                m_distance = 0;
        }
        eGjkStatus Evaluate(const MinkowskiDiff<btConvexTemplate>& shapearg, const btVector3& guess)
        {
                U iterations = 0;
                btScalar sqdist = 0;
                btScalar alpha = 0;
                btVector3 lastw[4];
                U clastw = 0;
                /* Initialize solver            */
                m_free[0] = &m_store[0];
                m_free[1] = &m_store[1];
                m_free[2] = &m_store[2];
                m_free[3] = &m_store[3];
                m_nfree = 4;
                m_current = 0;
                m_status = eGjkValid;
                m_shape = shapearg;
                m_distance = 0;
                /* Initialize simplex           */
                m_simplices[0].rank = 0;
                m_ray = guess;
                const btScalar sqrl = m_ray.length2();
                appendvertice(m_simplices[0], sqrl > 0 ? -m_ray : btVector3(1, 0, 0));
                m_simplices[0].p[0] = 1;
                m_ray = m_simplices[0].c[0]->w;
                sqdist = sqrl;
                lastw[0] =
                        lastw[1] =
                                lastw[2] =
                                        lastw[3] = m_ray;
                /* Loop                                         */
                do
                {
                        const U next = 1 - m_current;
                        sSimplex& cs = m_simplices[m_current];
                        sSimplex& ns = m_simplices[next];
                        /* Check zero                                                   */
                        const btScalar rl = m_ray.length();
                        if (rl < GJK_MIN_DISTANCE)
                        { /* Touching or inside                         */
                                m_status = eGjkInside;
                                break;
                        }
                        /* Append new vertice in -'v' direction */
                        appendvertice(cs, -m_ray);
                        const btVector3& w = cs.c[cs.rank - 1]->w;
                        bool found = false;
                        for (U i = 0; i < 4; ++i)
                        {
                                if ((w - lastw[i]).length2() < GJK_DUPLICATED_EPS)
                                {
                                        found = true;
                                        break;
                                }
                        }
                        if (found)
                        { /* Return old simplex                         */
                                removevertice(m_simplices[m_current]);
                                break;
                        }
                        else
                        { /* Update lastw                                       */
                                lastw[clastw = (clastw + 1) & 3] = w;
                        }
                        /* Check for termination                                */
                        const btScalar omega = btDot(m_ray, w) / rl;
                        alpha = btMax(omega, alpha);
                        if (((rl - alpha) - (GJK_ACCURARY * rl)) <= 0)
                        { /* Return old simplex                         */
                                removevertice(m_simplices[m_current]);
                                break;
                        }
                        /* Reduce simplex                                               */
                        btScalar weights[4];
                        U mask = 0;
                        switch (cs.rank)
                        {
                                case 2:
                                        sqdist = projectorigin(cs.c[0]->w,
                                                                                   cs.c[1]->w,
                                                                                   weights, mask);
                                        break;
                                case 3:
                                        sqdist = projectorigin(cs.c[0]->w,
                                                                                   cs.c[1]->w,
                                                                                   cs.c[2]->w,
                                                                                   weights, mask);
                                        break;
                                case 4:
                                        sqdist = projectorigin(cs.c[0]->w,
                                                                                   cs.c[1]->w,
                                                                                   cs.c[2]->w,
                                                                                   cs.c[3]->w,
                                                                                   weights, mask);
                                        break;
                        }
                        if (sqdist >= 0)
                        { /* Valid      */
                                ns.rank = 0;
                                m_ray = btVector3(0, 0, 0);
                                m_current = next;
                                for (U i = 0, ni = cs.rank; i < ni; ++i)
                                {
                                        if (mask & (1 << i))
                                        {
                                                ns.c[ns.rank] = cs.c[i];
                                                ns.p[ns.rank++] = weights[i];
                                                m_ray += cs.c[i]->w * weights[i];
                                        }
                                        else
                                        {
                                                m_free[m_nfree++] = cs.c[i];
                                        }
                                }
                                if (mask == 15) m_status = eGjkInside;
                        }
                        else
                        { /* Return old simplex                         */
                                removevertice(m_simplices[m_current]);
                                break;
                        }
                        m_status = ((++iterations) < GJK_MAX_ITERATIONS) ? m_status : eGjkFailed;
                } while (m_status == eGjkValid);
                m_simplex = &m_simplices[m_current];
                switch (m_status)
                {
                        case eGjkValid:
                                m_distance = m_ray.length();
                                break;
                        case eGjkInside:
                                m_distance = 0;
                                break;
                        default:
                        {
                        }
                }
                return (m_status);
        }
        bool EncloseOrigin()
        {
                switch (m_simplex->rank)
                {
                        case 1:
                        {
                                for (U i = 0; i < 3; ++i)
                                {
                                        btVector3 axis = btVector3(0, 0, 0);
                                        axis[i] = 1;
                                        appendvertice(*m_simplex, axis);
                                        if (EncloseOrigin()) return (true);
                                        removevertice(*m_simplex);
                                        appendvertice(*m_simplex, -axis);
                                        if (EncloseOrigin()) return (true);
                                        removevertice(*m_simplex);
                                }
                        }
                        break;
                        case 2:
                        {
                                const btVector3 d = m_simplex->c[1]->w - m_simplex->c[0]->w;
                                for (U i = 0; i < 3; ++i)
                                {
                                        btVector3 axis = btVector3(0, 0, 0);
                                        axis[i] = 1;
                                        const btVector3 p = btCross(d, axis);
                                        if (p.length2() > 0)
                                        {
                                                appendvertice(*m_simplex, p);
                                                if (EncloseOrigin()) return (true);
                                                removevertice(*m_simplex);
                                                appendvertice(*m_simplex, -p);
                                                if (EncloseOrigin()) return (true);
                                                removevertice(*m_simplex);
                                        }
                                }
                        }
                        break;
                        case 3:
                        {
                                const btVector3 n = btCross(m_simplex->c[1]->w - m_simplex->c[0]->w,
                                                                                        m_simplex->c[2]->w - m_simplex->c[0]->w);
                                if (n.length2() > 0)
                                {
                                        appendvertice(*m_simplex, n);
                                        if (EncloseOrigin()) return (true);
                                        removevertice(*m_simplex);
                                        appendvertice(*m_simplex, -n);
                                        if (EncloseOrigin()) return (true);
                                        removevertice(*m_simplex);
                                }
                        }
                        break;
                        case 4:
                        {
                                if (btFabs(det(m_simplex->c[0]->w - m_simplex->c[3]->w,
                                                           m_simplex->c[1]->w - m_simplex->c[3]->w,
                                                           m_simplex->c[2]->w - m_simplex->c[3]->w)) > 0)
                                        return (true);
                        }
                        break;
                }
                return (false);
        }
        /* Internals    */
        void getsupport(const btVector3& d, sSV& sv) const
        {
                sv.d = d / d.length();
                sv.w = m_shape.Support(sv.d);
        }
        void removevertice(sSimplex& simplex)
        {
                m_free[m_nfree++] = simplex.c[--simplex.rank];
        }
        void appendvertice(sSimplex& simplex, const btVector3& v)
        {
                simplex.p[simplex.rank] = 0;
                simplex.c[simplex.rank] = m_free[--m_nfree];
                getsupport(v, *simplex.c[simplex.rank++]);
        }
        static btScalar det(const btVector3& a, const btVector3& b, const btVector3& c)
        {
                return (a.y() * b.z() * c.x() + a.z() * b.x() * c.y() -
                                a.x() * b.z() * c.y() - a.y() * b.x() * c.z() +
                                a.x() * b.y() * c.z() - a.z() * b.y() * c.x());
        }
        static btScalar projectorigin(const btVector3& a,
                                                                  const btVector3& b,
                                                                  btScalar* w, U& m)
        {
                const btVector3 d = b - a;
                const btScalar l = d.length2();
                if (l > GJK_SIMPLEX2_EPS)
                {
                        const btScalar t(l > 0 ? -btDot(a, d) / l : 0);
                        if (t >= 1)
                        {
                                w[0] = 0;
                                w[1] = 1;
                                m = 2;
                                return (b.length2());
                        }
                        else if (t <= 0)
                        {
                                w[0] = 1;
                                w[1] = 0;
                                m = 1;
                                return (a.length2());
                        }
                        else
                        {
                                w[0] = 1 - (w[1] = t);
                                m = 3;
                                return ((a + d * t).length2());
                        }
                }
                return (-1);
        }
        static btScalar projectorigin(const btVector3& a,
                                                                  const btVector3& b,
                                                                  const btVector3& c,
                                                                  btScalar* w, U& m)
        {
                static const U imd3[] = {1, 2, 0};
                const btVector3* vt[] = {&a, &b, &c};
                const btVector3 dl[] = {a - b, b - c, c - a};
                const btVector3 n = btCross(dl[0], dl[1]);
                const btScalar l = n.length2();
                if (l > GJK_SIMPLEX3_EPS)
                {
                        btScalar mindist = -1;
                        btScalar subw[2] = {0.f, 0.f};
                        U subm(0);
                        for (U i = 0; i < 3; ++i)
                        {
                                if (btDot(*vt[i], btCross(dl[i], n)) > 0)
                                {
                                        const U j = imd3[i];
                                        const btScalar subd(projectorigin(*vt[i], *vt[j], subw, subm));
                                        if ((mindist < 0) || (subd < mindist))
                                        {
                                                mindist = subd;
                                                m = static_cast<U>(((subm & 1) ? 1 << i : 0) + ((subm & 2) ? 1 << j : 0));
                                                w[i] = subw[0];
                                                w[j] = subw[1];
                                                w[imd3[j]] = 0;
                                        }
                                }
                        }
                        if (mindist < 0)
                        {
                                const btScalar d = btDot(a, n);
                                const btScalar s = btSqrt(l);
                                const btVector3 p = n * (d / l);
                                mindist = p.length2();
                                m = 7;
                                w[0] = (btCross(dl[1], b - p)).length() / s;
                                w[1] = (btCross(dl[2], c - p)).length() / s;
                                w[2] = 1 - (w[0] + w[1]);
                        }
                        return (mindist);
                }
                return (-1);
        }
        static btScalar projectorigin(const btVector3& a,
                                                                  const btVector3& b,
                                                                  const btVector3& c,
                                                                  const btVector3& d,
                                                                  btScalar* w, U& m)
        {
                static const U imd3[] = {1, 2, 0};
                const btVector3* vt[] = {&a, &b, &c, &d};
                const btVector3 dl[] = {a - d, b - d, c - d};
                const btScalar vl = det(dl[0], dl[1], dl[2]);
                const bool ng = (vl * btDot(a, btCross(b - c, a - b))) <= 0;
                if (ng && (btFabs(vl) > GJK_SIMPLEX4_EPS))
                {
                        btScalar mindist = -1;
                        btScalar subw[3] = {0.f, 0.f, 0.f};
                        U subm(0);
                        for (U i = 0; i < 3; ++i)
                        {
                                const U j = imd3[i];
                                const btScalar s = vl * btDot(d, btCross(dl[i], dl[j]));
                                if (s > 0)
                                {
                                        const btScalar subd = projectorigin(*vt[i], *vt[j], d, subw, subm);
                                        if ((mindist < 0) || (subd < mindist))
                                        {
                                                mindist = subd;
                                                m = static_cast<U>((subm & 1 ? 1 << i : 0) +
                                                                                   (subm & 2 ? 1 << j : 0) +
                                                                                   (subm & 4 ? 8 : 0));
                                                w[i] = subw[0];
                                                w[j] = subw[1];
                                                w[imd3[j]] = 0;
                                                w[3] = subw[2];
                                        }
                                }
                        }
                        if (mindist < 0)
                        {
                                mindist = 0;
                                m = 15;
                                w[0] = det(c, b, d) / vl;
                                w[1] = det(a, c, d) / vl;
                                w[2] = det(b, a, d) / vl;
                                w[3] = 1 - (w[0] + w[1] + w[2]);
                        }
                        return (mindist);
                }
                return (-1);
        }
};

enum eEpaStatus
{
        eEpaValid,
        eEpaTouching,
        eEpaDegenerated,
        eEpaNonConvex,
        eEpaInvalidHull,
        eEpaOutOfFaces,
        eEpaOutOfVertices,
        eEpaAccuraryReached,
        eEpaFallBack,
        eEpaFailed
};

// EPA
template <typename btConvexTemplate>
struct EPA
{
        /* Types                */

        struct sFace
        {
                btVector3 n;
                btScalar d;
                typename GJK<btConvexTemplate>::sSV* c[3];
                sFace* f[3];
                sFace* l[2];
                U1 e[3];
                U1 pass;
        };
        struct sList
        {
                sFace* root;
                U count;
                sList() : root(0), count(0) {}
        };
        struct sHorizon
        {
                sFace* cf;
                sFace* ff;
                U nf;
                sHorizon() : cf(0), ff(0), nf(0) {}
        };

        /* Fields               */
        eEpaStatus m_status;
        typename GJK<btConvexTemplate>::sSimplex m_result;
        btVector3 m_normal;
        btScalar m_depth;
        typename GJK<btConvexTemplate>::sSV m_sv_store[EPA_MAX_VERTICES];
        sFace m_fc_store[EPA_MAX_FACES];
        U m_nextsv;
        sList m_hull;
        sList m_stock;
        /* Methods              */
        EPA()
        {
                Initialize();
        }

        static inline void bind(sFace* fa, U ea, sFace* fb, U eb)
        {
                fa->e[ea] = (U1)eb;
                fa->f[ea] = fb;
                fb->e[eb] = (U1)ea;
                fb->f[eb] = fa;
        }
        static inline void append(sList& list, sFace* face)
        {
                face->l[0] = 0;
                face->l[1] = list.root;
                if (list.root) list.root->l[0] = face;
                list.root = face;
                ++list.count;
        }
        static inline void remove(sList& list, sFace* face)
        {
                if (face->l[1]) face->l[1]->l[0] = face->l[0];
                if (face->l[0]) face->l[0]->l[1] = face->l[1];
                if (face == list.root) list.root = face->l[1];
                --list.count;
        }

        void Initialize()
        {
                m_status = eEpaFailed;
                m_normal = btVector3(0, 0, 0);
                m_depth = 0;
                m_nextsv = 0;
                for (U i = 0; i < EPA_MAX_FACES; ++i)
                {
                        append(m_stock, &m_fc_store[EPA_MAX_FACES - i - 1]);
                }
        }
        eEpaStatus Evaluate(GJK<btConvexTemplate>& gjk, const btVector3& guess)
        {
                typename GJK<btConvexTemplate>::sSimplex& simplex = *gjk.m_simplex;
                if ((simplex.rank > 1) && gjk.EncloseOrigin())
                {
                        /* Clean up                             */
                        while (m_hull.root)
                        {
                                sFace* f = m_hull.root;
                                remove(m_hull, f);
                                append(m_stock, f);
                        }
                        m_status = eEpaValid;
                        m_nextsv = 0;
                        /* Orient simplex               */
                        if (gjk.det(simplex.c[0]->w - simplex.c[3]->w,
                                                simplex.c[1]->w - simplex.c[3]->w,
                                                simplex.c[2]->w - simplex.c[3]->w) < 0)
                        {
                                btSwap(simplex.c[0], simplex.c[1]);
                                btSwap(simplex.p[0], simplex.p[1]);
                        }
                        /* Build initial hull   */
                        sFace* tetra[] = {newface(simplex.c[0], simplex.c[1], simplex.c[2], true),
                                                          newface(simplex.c[1], simplex.c[0], simplex.c[3], true),
                                                          newface(simplex.c[2], simplex.c[1], simplex.c[3], true),
                                                          newface(simplex.c[0], simplex.c[2], simplex.c[3], true)};
                        if (m_hull.count == 4)
                        {
                                sFace* best = findbest();
                                sFace outer = *best;
                                U pass = 0;
                                U iterations = 0;
                                bind(tetra[0], 0, tetra[1], 0);
                                bind(tetra[0], 1, tetra[2], 0);
                                bind(tetra[0], 2, tetra[3], 0);
                                bind(tetra[1], 1, tetra[3], 2);
                                bind(tetra[1], 2, tetra[2], 1);
                                bind(tetra[2], 2, tetra[3], 1);
                                m_status = eEpaValid;
                                for (; iterations < EPA_MAX_ITERATIONS; ++iterations)
                                {
                                        if (m_nextsv < EPA_MAX_VERTICES)
                                        {
                                                sHorizon horizon;
                                                typename GJK<btConvexTemplate>::sSV* w = &m_sv_store[m_nextsv++];
                                                bool valid = true;
                                                best->pass = (U1)(++pass);
                                                gjk.getsupport(best->n, *w);
                                                const btScalar wdist = btDot(best->n, w->w) - best->d;
                                                if (wdist > EPA_ACCURACY)
                                                {
                                                        for (U j = 0; (j < 3) && valid; ++j)
                                                        {
                                                                valid &= expand(pass, w,
                                                                                                best->f[j], best->e[j],
                                                                                                horizon);
                                                        }
                                                        if (valid && (horizon.nf >= 3))
                                                        {
                                                                bind(horizon.cf, 1, horizon.ff, 2);
                                                                remove(m_hull, best);
                                                                append(m_stock, best);
                                                                best = findbest();
                                                                outer = *best;
                                                        }
                                                        else
                                                        {
                                                                m_status = eEpaInvalidHull;
                                                                break;
                                                        }
                                                }
                                                else
                                                {
                                                        m_status = eEpaAccuraryReached;
                                                        break;
                                                }
                                        }
                                        else
                                        {
                                                m_status = eEpaOutOfVertices;
                                                break;
                                        }
                                }
                                const btVector3 projection = outer.n * outer.d;
                                m_normal = outer.n;
                                m_depth = outer.d;
                                m_result.rank = 3;
                                m_result.c[0] = outer.c[0];
                                m_result.c[1] = outer.c[1];
                                m_result.c[2] = outer.c[2];
                                m_result.p[0] = btCross(outer.c[1]->w - projection,
                                                                                outer.c[2]->w - projection)
                                                                        .length();
                                m_result.p[1] = btCross(outer.c[2]->w - projection,
                                                                                outer.c[0]->w - projection)
                                                                        .length();
                                m_result.p[2] = btCross(outer.c[0]->w - projection,
                                                                                outer.c[1]->w - projection)
                                                                        .length();
                                const btScalar sum = m_result.p[0] + m_result.p[1] + m_result.p[2];
                                m_result.p[0] /= sum;
                                m_result.p[1] /= sum;
                                m_result.p[2] /= sum;
                                return (m_status);
                        }
                }
                /* Fallback             */
                m_status = eEpaFallBack;
                m_normal = -guess;
                const btScalar nl = m_normal.length();
                if (nl > 0)
                        m_normal = m_normal / nl;
                else
                        m_normal = btVector3(1, 0, 0);
                m_depth = 0;
                m_result.rank = 1;
                m_result.c[0] = simplex.c[0];
                m_result.p[0] = 1;
                return (m_status);
        }
        bool getedgedist(sFace* face, typename GJK<btConvexTemplate>::sSV* a, typename GJK<btConvexTemplate>::sSV* b, btScalar& dist)
        {
                const btVector3 ba = b->w - a->w;
                const btVector3 n_ab = btCross(ba, face->n);   // Outward facing edge normal direction, on triangle plane
                const btScalar a_dot_nab = btDot(a->w, n_ab);  // Only care about the sign to determine inside/outside, so not normalization required

                if (a_dot_nab < 0)
                {
                        // Outside of edge a->b

                        const btScalar ba_l2 = ba.length2();
                        const btScalar a_dot_ba = btDot(a->w, ba);
                        const btScalar b_dot_ba = btDot(b->w, ba);

                        if (a_dot_ba > 0)
                        {
                                // Pick distance vertex a
                                dist = a->w.length();
                        }
                        else if (b_dot_ba < 0)
                        {
                                // Pick distance vertex b
                                dist = b->w.length();
                        }
                        else
                        {
                                // Pick distance to edge a->b
                                const btScalar a_dot_b = btDot(a->w, b->w);
                                dist = btSqrt(btMax((a->w.length2() * b->w.length2() - a_dot_b * a_dot_b) / ba_l2, (btScalar)0));
                        }

                        return true;
                }

                return false;
        }
        sFace* newface(typename GJK<btConvexTemplate>::sSV* a, typename GJK<btConvexTemplate>::sSV* b, typename GJK<btConvexTemplate>::sSV* c, bool forced)
        {
                if (m_stock.root)
                {
                        sFace* face = m_stock.root;
                        remove(m_stock, face);
                        append(m_hull, face);
                        face->pass = 0;
                        face->c[0] = a;
                        face->c[1] = b;
                        face->c[2] = c;
                        face->n = btCross(b->w - a->w, c->w - a->w);
                        const btScalar l = face->n.length();
                        const bool v = l > EPA_ACCURACY;

                        if (v)
                        {
                                if (!(getedgedist(face, a, b, face->d) ||
                                          getedgedist(face, b, c, face->d) ||
                                          getedgedist(face, c, a, face->d)))
                                {
                                        // Origin projects to the interior of the triangle
                                        // Use distance to triangle plane
                                        face->d = btDot(a->w, face->n) / l;
                                }

                                face->n /= l;
                                if (forced || (face->d >= -EPA_PLANE_EPS))
                                {
                                        return face;
                                }
                                else
                                        m_status = eEpaNonConvex;
                        }
                        else
                                m_status = eEpaDegenerated;

                        remove(m_hull, face);
                        append(m_stock, face);
                        return 0;
                }
                m_status = m_stock.root ? eEpaOutOfVertices : eEpaOutOfFaces;
                return 0;
        }
        sFace* findbest()
        {
                sFace* minf = m_hull.root;
                btScalar mind = minf->d * minf->d;
                for (sFace* f = minf->l[1]; f; f = f->l[1])
                {
                        const btScalar sqd = f->d * f->d;
                        if (sqd < mind)
                        {
                                minf = f;
                                mind = sqd;
                        }
                }
                return (minf);
        }
        bool expand(U pass, typename GJK<btConvexTemplate>::sSV* w, sFace* f, U e, sHorizon& horizon)
        {
                static const U i1m3[] = {1, 2, 0};
                static const U i2m3[] = {2, 0, 1};
                if (f->pass != pass)
                {
                        const U e1 = i1m3[e];
                        if ((btDot(f->n, w->w) - f->d) < -EPA_PLANE_EPS)
                        {
                                sFace* nf = newface(f->c[e1], f->c[e], w, false);
                                if (nf)
                                {
                                        bind(nf, 0, f, e);
                                        if (horizon.cf)
                                                bind(horizon.cf, 1, nf, 2);
                                        else
                                                horizon.ff = nf;
                                        horizon.cf = nf;
                                        ++horizon.nf;
                                        return (true);
                                }
                        }
                        else
                        {
                                const U e2 = i2m3[e];
                                f->pass = (U1)pass;
                                if (expand(pass, w, f->f[e1], f->e[e1], horizon) &&
                                        expand(pass, w, f->f[e2], f->e[e2], horizon))
                                {
                                        remove(m_hull, f);
                                        append(m_stock, f);
                                        return (true);
                                }
                        }
                }
                return (false);
        }
};

template <typename btConvexTemplate>
static void Initialize(const btConvexTemplate& a, const btConvexTemplate& b,
                                           btGjkEpaSolver3::sResults& results,
                                           MinkowskiDiff<btConvexTemplate>& shape)
{
        /* Results              */
        results.witnesses[0] =
                results.witnesses[1] = btVector3(0, 0, 0);
        results.status = btGjkEpaSolver3::sResults::Separated;
        /* Shape                */

        shape.m_toshape1 = b.getWorldTransform().getBasis().transposeTimes(a.getWorldTransform().getBasis());
        shape.m_toshape0 = a.getWorldTransform().inverseTimes(b.getWorldTransform());
}

//
// Api
//

//
template <typename btConvexTemplate>
bool btGjkEpaSolver3_Distance(const btConvexTemplate& a, const btConvexTemplate& b,
                                                          const btVector3& guess,
                                                          btGjkEpaSolver3::sResults& results)
{
        MinkowskiDiff<btConvexTemplate> shape(a, b);
        Initialize(a, b, results, shape);
        GJK<btConvexTemplate> gjk(a, b);
        eGjkStatus gjk_status = gjk.Evaluate(shape, guess);
        if (gjk_status == eGjkValid)
        {
                btVector3 w0 = btVector3(0, 0, 0);
                btVector3 w1 = btVector3(0, 0, 0);
                for (U i = 0; i < gjk.m_simplex->rank; ++i)
                {
                        const btScalar p = gjk.m_simplex->p[i];
                        w0 += shape.Support(gjk.m_simplex->c[i]->d, 0) * p;
                        w1 += shape.Support(-gjk.m_simplex->c[i]->d, 1) * p;
                }
                results.witnesses[0] = a.getWorldTransform() * w0;
                results.witnesses[1] = a.getWorldTransform() * w1;
                results.normal = w0 - w1;
                results.distance = results.normal.length();
                results.normal /= results.distance > GJK_MIN_DISTANCE ? results.distance : 1;
                return (true);
        }
        else
        {
                results.status = gjk_status == eGjkInside ? btGjkEpaSolver3::sResults::Penetrating : btGjkEpaSolver3::sResults::GJK_Failed;
                return (false);
        }
}

template <typename btConvexTemplate>
bool btGjkEpaSolver3_Penetration(const btConvexTemplate& a,
                                                                 const btConvexTemplate& b,
                                                                 const btVector3& guess,
                                                                 btGjkEpaSolver3::sResults& results)
{
        MinkowskiDiff<btConvexTemplate> shape(a, b);
        Initialize(a, b, results, shape);
        GJK<btConvexTemplate> gjk(a, b);
        eGjkStatus gjk_status = gjk.Evaluate(shape, -guess);
        switch (gjk_status)
        {
                case eGjkInside:
                {
                        EPA<btConvexTemplate> epa;
                        eEpaStatus epa_status = epa.Evaluate(gjk, -guess);
                        if (epa_status != eEpaFailed)
                        {
                                btVector3 w0 = btVector3(0, 0, 0);
                                for (U i = 0; i < epa.m_result.rank; ++i)
                                {
                                        w0 += shape.Support(epa.m_result.c[i]->d, 0) * epa.m_result.p[i];
                                }
                                results.status = btGjkEpaSolver3::sResults::Penetrating;
                                results.witnesses[0] = a.getWorldTransform() * w0;
                                results.witnesses[1] = a.getWorldTransform() * (w0 - epa.m_normal * epa.m_depth);
                                results.normal = -epa.m_normal;
                                results.distance = -epa.m_depth;
                                return (true);
                        }
                        else
                                results.status = btGjkEpaSolver3::sResults::EPA_Failed;
                }
                break;
                case eGjkFailed:
                        results.status = btGjkEpaSolver3::sResults::GJK_Failed;
                        break;
                default:
                {
                }
        }
        return (false);
}

#if 0
int     btComputeGjkEpaPenetration2(const btCollisionDescription& colDesc, btDistanceInfo* distInfo)
{
    btGjkEpaSolver3::sResults results;
    btVector3 guess = colDesc.m_firstDir;
    
    bool res = btGjkEpaSolver3::Penetration(colDesc.m_objA,colDesc.m_objB,
                                            colDesc.m_transformA,colDesc.m_transformB,
                                            colDesc.m_localSupportFuncA,colDesc.m_localSupportFuncB,
                                            guess,
                                            results);
    if (res)
    {
        if ((results.status==btGjkEpaSolver3::sResults::Penetrating) || results.status==GJK::eStatus::Inside)
        {
            //normal could be 'swapped'
            
            distInfo->m_distance = results.distance;
            distInfo->m_normalBtoA = results.normal;
            btVector3 tmpNormalInB = results.witnesses[1]-results.witnesses[0];
            btScalar lenSqr = tmpNormalInB.length2();
            if (lenSqr <= (SIMD_EPSILON*SIMD_EPSILON))
            {
                tmpNormalInB = results.normal;
                lenSqr = results.normal.length2();
            }
            
            if (lenSqr > (SIMD_EPSILON*SIMD_EPSILON))
            {
                tmpNormalInB /= btSqrt(lenSqr);
                btScalar distance2 = -(results.witnesses[0]-results.witnesses[1]).length();
                //only replace valid penetrations when the result is deeper (check)
                //if ((distance2 < results.distance))
                {
                    distInfo->m_distance = distance2;
                    distInfo->m_pointOnA= results.witnesses[0];
                    distInfo->m_pointOnB= results.witnesses[1];
                    distInfo->m_normalBtoA= tmpNormalInB;
                    return 0;
                }
            }
        }
        
    }
    
    return -1;
}
#endif

template <typename btConvexTemplate, typename btDistanceInfoTemplate>
int btComputeGjkDistance(const btConvexTemplate& a, const btConvexTemplate& b,
                                                 const btGjkCollisionDescription& colDesc, btDistanceInfoTemplate* distInfo)
{
        btGjkEpaSolver3::sResults results;
        btVector3 guess = colDesc.m_firstDir;

        bool isSeparated = btGjkEpaSolver3_Distance(a, b,
                                                                                                guess,
                                                                                                results);
        if (isSeparated)
        {
                distInfo->m_distance = results.distance;
                distInfo->m_pointOnA = results.witnesses[0];
                distInfo->m_pointOnB = results.witnesses[1];
                distInfo->m_normalBtoA = results.normal;
                return 0;
        }

        return -1;
}

/* Symbols cleanup              */

#undef GJK_MAX_ITERATIONS
#undef GJK_ACCURARY
#undef GJK_MIN_DISTANCE
#undef GJK_DUPLICATED_EPS
#undef GJK_SIMPLEX2_EPS
#undef GJK_SIMPLEX3_EPS
#undef GJK_SIMPLEX4_EPS

#undef EPA_MAX_VERTICES
#undef EPA_MAX_FACES
#undef EPA_MAX_ITERATIONS
#undef EPA_ACCURACY
#undef EPA_FALLBACK
#undef EPA_PLANE_EPS
#undef EPA_INSIDE_EPS

#endif  //BT_GJK_EPA3_H