ShapeCast.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/Geometry/AABox.h>
#include <Jolt/Physics/Collision/CollideShape.h>
#include <Jolt/Physics/Collision/Shape/Shape.h>
 
JPH_NAMESPACE_BEGIN
 
template <class Vec, class Mat, class ShapeCastType>
struct ShapeCastT
{
    JPH_OVERRIDE_NEW_DELETE
 
                                ShapeCastT(const Shape *inShape, Vec3Arg inScale, typename Mat::ArgType inCenterOfMassStart, Vec3Arg inDirection, const AABox &inWorldSpaceBounds) :
        mShape(inShape),
        mScale(inScale),
        mCenterOfMassStart(inCenterOfMassStart),
        mDirection(inDirection),
        mShapeWorldBounds(inWorldSpaceBounds)
    {
    }
 
                                ShapeCastT(const Shape *inShape, Vec3Arg inScale, typename Mat::ArgType inCenterOfMassStart, Vec3Arg inDirection) :
        ShapeCastT<Vec, Mat, ShapeCastType>(inShape, inScale, inCenterOfMassStart, inDirection, inShape->GetWorldSpaceBounds(inCenterOfMassStart, inScale))
    {
    }
 
    static inline ShapeCastType sFromWorldTransform(const Shape *inShape, Vec3Arg inScale, typename Mat::ArgType inWorldTransform, Vec3Arg inDirection)
    {
        return ShapeCastType(inShape, inScale, inWorldTransform.PreTranslated(inShape->GetCenterOfMass()), inDirection);
    }
 
    ShapeCastType               PostTransformed(typename Mat::ArgType inTransform) const
    {
        Mat44 start = inTransform * mCenterOfMassStart;
        Vec3 direction = inTransform.Multiply3x3(mDirection);
        return { mShape, mScale, start, direction };
    }
 
    ShapeCastType               PostTranslated(typename Vec::ArgType inTranslation) const
    {
        return { mShape, mScale, mCenterOfMassStart.PostTranslated(inTranslation), mDirection };
    }
 
    inline Vec                  GetPointOnRay(float inFraction) const
    {
        return mCenterOfMassStart.GetTranslation() + inFraction * mDirection;
    }
 
    const Shape *               mShape;                             
    const Vec3                  mScale;                             
    const Mat                   mCenterOfMassStart;                 
    const Vec3                  mDirection;                         
    const AABox                 mShapeWorldBounds;                  
};
 
struct ShapeCast : public ShapeCastT<Vec3, Mat44, ShapeCast>
{
    using ShapeCastT<Vec3, Mat44, ShapeCast>::ShapeCastT;
};
 
struct RShapeCast : public ShapeCastT<RVec3, RMat44, RShapeCast>
{
    using ShapeCastT<RVec3, RMat44, RShapeCast>::ShapeCastT;
 
    explicit                    RShapeCast(const ShapeCast &inCast) :
        RShapeCast(inCast.mShape, inCast.mScale, RMat44(inCast.mCenterOfMassStart), inCast.mDirection, inCast.mShapeWorldBounds)
    {
    }
 
    explicit                    operator ShapeCast() const
    {
        return ShapeCast(mShape, mScale, mCenterOfMassStart.ToMat44(), mDirection, mShapeWorldBounds);
    }
};
 
class ShapeCastSettings : public CollideSettingsBase
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    void                        SetBackFaceMode(EBackFaceMode inMode) { mBackFaceModeTriangles = mBackFaceModeConvex = inMode; }
 
    EBackFaceMode               mBackFaceModeTriangles = EBackFaceMode::IgnoreBackFaces;
 
    EBackFaceMode               mBackFaceModeConvex = EBackFaceMode::IgnoreBackFaces;
 
    bool                        mUseShrunkenShapeAndConvexRadius = false;
 
    bool                        mReturnDeepestPoint = false;
};
 
class ShapeCastResult : public CollideShapeResult
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
                                ShapeCastResult() = default;
 
                                ShapeCastResult(float inFraction, Vec3Arg inContactPoint1, Vec3Arg inContactPoint2, Vec3Arg inContactNormalOrPenetrationDepth, bool inBackFaceHit, const SubShapeID &inSubShapeID1, const SubShapeID &inSubShapeID2, const BodyID &inBodyID2) :
        CollideShapeResult(inContactPoint1, inContactPoint2, inContactNormalOrPenetrationDepth, (inContactPoint2 - inContactPoint1).Length(), inSubShapeID1, inSubShapeID2, inBodyID2),
        mFraction(inFraction),
        mIsBackFaceHit(inBackFaceHit)
    {
    }
 
    inline float                GetEarlyOutFraction() const         { return mFraction > 0.0f? mFraction : -mPenetrationDepth; }
 
    ShapeCastResult             Reversed(Vec3Arg inWorldSpaceCastDirection) const
    {
        // Calculate by how much to shift the contact points
        Vec3 delta = mFraction * inWorldSpaceCastDirection;
 
        ShapeCastResult result;
        result.mContactPointOn2 = mContactPointOn1 - delta;
        result.mContactPointOn1 = mContactPointOn2 - delta;
        result.mPenetrationAxis = -mPenetrationAxis;
        result.mPenetrationDepth = mPenetrationDepth;
        result.mSubShapeID2 = mSubShapeID1;
        result.mSubShapeID1 = mSubShapeID2;
        result.mBodyID2 = mBodyID2;
        result.mFraction = mFraction;
        result.mIsBackFaceHit = mIsBackFaceHit;
 
        result.mShape2Face.resize(mShape1Face.size());
        for (Face::size_type i = 0; i < mShape1Face.size(); ++i)
            result.mShape2Face[i] = mShape1Face[i] - delta;
 
        result.mShape1Face.resize(mShape2Face.size());
        for (Face::size_type i = 0; i < mShape2Face.size(); ++i)
            result.mShape1Face[i] = mShape2Face[i] - delta;
 
        return result;
    }
 
    float                       mFraction;                          
    bool                        mIsBackFaceHit;                     
};
 
JPH_NAMESPACE_END