ConvexSupport.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Math/Mat44.h>
 
JPH_NAMESPACE_BEGIN
 
template <typename ConvexObject>
struct TransformedConvexObject
{
    TransformedConvexObject(Mat44Arg inTransform, const ConvexObject &inObject) :
        mTransform(inTransform),
        mObject(inObject)
    {
    }
 
    Vec3                    GetSupport(Vec3Arg inDirection) const
    {
        return mTransform * mObject.GetSupport(mTransform.Multiply3x3Transposed(inDirection));
    }
 
    template <class VERTEX_ARRAY>
    void                    GetSupportingFace(Vec3Arg inDirection, VERTEX_ARRAY &outVertices) const
    {
        mObject.GetSupportingFace(mTransform.Multiply3x3Transposed(inDirection), outVertices);
 
        for (Vec3 &v : outVertices)
            v = mTransform * v;
    }
 
    Mat44                   mTransform;
    const ConvexObject &    mObject;
};
 
template <typename ConvexObject>
struct AddConvexRadius
{
    AddConvexRadius(const ConvexObject &inObject, float inRadius) :
        mObject(inObject),
        mRadius(inRadius)
    {
    }
 
    Vec3                    GetSupport(Vec3Arg inDirection) const
    {
        float length = inDirection.Length();
        return length > 0.0f ? mObject.GetSupport(inDirection) + (mRadius / length) * inDirection : mObject.GetSupport(inDirection);
    }
 
    const ConvexObject &    mObject;
    float                   mRadius;
};
 
template <typename ConvexObjectA, typename ConvexObjectB>
struct MinkowskiDifference
{
    MinkowskiDifference(const ConvexObjectA &inObjectA, const ConvexObjectB &inObjectB) :
        mObjectA(inObjectA),
        mObjectB(inObjectB)
    {
    }
 
    Vec3                    GetSupport(Vec3Arg inDirection) const
    {
        return mObjectA.GetSupport(inDirection) - mObjectB.GetSupport(-inDirection);
    }
 
    const ConvexObjectA &   mObjectA;
    const ConvexObjectB &   mObjectB;
};
 
struct PointConvexSupport
{
    Vec3                    GetSupport([[maybe_unused]] Vec3Arg inDirection) const
    {
        return mPoint;
    }
 
    Vec3                    mPoint;
};
 
struct TriangleConvexSupport
{
                            TriangleConvexSupport(Vec3Arg inV1, Vec3Arg inV2, Vec3Arg inV3) :
        mV1(inV1),
        mV2(inV2),
        mV3(inV3)
    {
    }
 
    Vec3                    GetSupport(Vec3Arg inDirection) const
    {
        // Project vertices on inDirection
        float d1 = mV1.Dot(inDirection);
        float d2 = mV2.Dot(inDirection);
        float d3 = mV3.Dot(inDirection);
 
        // Return vertex with biggest projection
        if (d1 > d2)
        {
            if (d1 > d3)
                return mV1;
            else
                return mV3;
        }
        else
        {
            if (d2 > d3)
                return mV2;
            else
                return mV3;
        }
    }
 
    template <class VERTEX_ARRAY>
    void                    GetSupportingFace([[maybe_unused]] Vec3Arg inDirection, VERTEX_ARRAY &outVertices) const
    {
        outVertices.push_back(mV1);
        outVertices.push_back(mV2);
        outVertices.push_back(mV3);
    }
 
    Vec3                    mV1;
    Vec3                    mV2;
    Vec3                    mV3;
};
 
template <class VERTEX_ARRAY>
struct PolygonConvexSupport
{
    explicit                PolygonConvexSupport(const VERTEX_ARRAY &inVertices) :
        mVertices(inVertices)
    {
    }
 
    Vec3                    GetSupport(Vec3Arg inDirection) const
    {
        Vec3 support_point = mVertices[0];
        float best_dot = mVertices[0].Dot(inDirection);
 
        for (typename VERTEX_ARRAY::const_iterator v = mVertices.begin() + 1; v < mVertices.end(); ++v)
        {
            float dot = v->Dot(inDirection);
            if (dot > best_dot)
            {
                best_dot = dot;
                support_point = *v;
            }
        }
 
        return support_point;
    }
 
    template <class VERTEX_ARRAY_ARG>
    void                    GetSupportingFace([[maybe_unused]] Vec3Arg inDirection, VERTEX_ARRAY_ARG &outVertices) const
    {
        for (Vec3 v : mVertices)
            outVertices.push_back(v);
    }
 
    const VERTEX_ARRAY &    mVertices;
};
 
JPH_NAMESPACE_END