ConvexHullShape.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/Physics/Collision/Shape/ConvexShape.h>
#include <Jolt/Physics/PhysicsSettings.h>
#include <Jolt/Geometry/Plane.h>
#ifdef JPH_DEBUG_RENDERER
    #include <Jolt/Renderer/DebugRenderer.h>
#endif // JPH_DEBUG_RENDERER
 
JPH_NAMESPACE_BEGIN
 
class JPH_EXPORT ConvexHullShapeSettings final : public ConvexShapeSettings
{
public:
    JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, ConvexHullShapeSettings)
 
    
                            ConvexHullShapeSettings() = default;
 
                            ConvexHullShapeSettings(const Vec3 *inPoints, int inNumPoints, float inMaxConvexRadius = cDefaultConvexRadius, const PhysicsMaterial *inMaterial = nullptr) : ConvexShapeSettings(inMaterial), mPoints(inPoints, inPoints + inNumPoints), mMaxConvexRadius(inMaxConvexRadius) { }
                            ConvexHullShapeSettings(const Array<Vec3> &inPoints, float inConvexRadius = cDefaultConvexRadius, const PhysicsMaterial *inMaterial = nullptr) : ConvexShapeSettings(inMaterial), mPoints(inPoints), mMaxConvexRadius(inConvexRadius) { }
 
    // See: ShapeSettings
    virtual ShapeResult     Create() const override;
 
    Array<Vec3>             mPoints;                                                            
    float                   mMaxConvexRadius = 0.0f;                                            
    float                   mMaxErrorConvexRadius = 0.05f;                                      
    float                   mHullTolerance = 1.0e-3f;                                           
};
 
class JPH_EXPORT ConvexHullShape final : public ConvexShape
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    static constexpr int    cMaxPointsInHull = 256;
 
                            ConvexHullShape() : ConvexShape(EShapeSubType::ConvexHull) { }
                            ConvexHullShape(const ConvexHullShapeSettings &inSettings, ShapeResult &outResult);
 
    // See Shape::GetCenterOfMass
    virtual Vec3            GetCenterOfMass() const override                                    { return mCenterOfMass; }
 
    // See Shape::GetLocalBounds
    virtual AABox           GetLocalBounds() const override                                     { return mLocalBounds; }
 
    // See Shape::GetInnerRadius
    virtual float           GetInnerRadius() const override                                     { return mInnerRadius; }
 
    // See Shape::GetMassProperties
    virtual MassProperties  GetMassProperties() const override;
 
    // See Shape::GetSurfaceNormal
    virtual Vec3            GetSurfaceNormal(const SubShapeID &inSubShapeID, Vec3Arg inLocalSurfacePosition) const override;
 
    // See Shape::GetSupportingFace
    virtual void            GetSupportingFace(const SubShapeID &inSubShapeID, Vec3Arg inDirection, Vec3Arg inScale, Mat44Arg inCenterOfMassTransform, SupportingFace &outVertices) const override;
 
    // See ConvexShape::GetSupportFunction
    virtual const Support * GetSupportFunction(ESupportMode inMode, SupportBuffer &inBuffer, Vec3Arg inScale) const override;
 
    // See Shape::GetSubmergedVolume
    virtual void            GetSubmergedVolume(Mat44Arg inCenterOfMassTransform, Vec3Arg inScale, const Plane &inSurface, float &outTotalVolume, float &outSubmergedVolume, Vec3 &outCenterOfBuoyancy JPH_IF_DEBUG_RENDERER(, RVec3Arg inBaseOffset)) const override;
 
#ifdef JPH_DEBUG_RENDERER
    // See Shape::Draw
    virtual void            Draw(DebugRenderer *inRenderer, RMat44Arg inCenterOfMassTransform, Vec3Arg inScale, ColorArg inColor, bool inUseMaterialColors, bool inDrawWireframe) const override;
 
    void                    DrawShrunkShape(DebugRenderer *inRenderer, RMat44Arg inCenterOfMassTransform, Vec3Arg inScale) const;
#endif // JPH_DEBUG_RENDERER
 
    // See Shape::CastRay
    virtual bool            CastRay(const RayCast &inRay, const SubShapeIDCreator &inSubShapeIDCreator, RayCastResult &ioHit) const override;
    virtual void            CastRay(const RayCast &inRay, const RayCastSettings &inRayCastSettings, const SubShapeIDCreator &inSubShapeIDCreator, CastRayCollector &ioCollector, const ShapeFilter &inShapeFilter = { }) const override;
 
    // See: Shape::CollidePoint
    virtual void            CollidePoint(Vec3Arg inPoint, const SubShapeIDCreator &inSubShapeIDCreator, CollidePointCollector &ioCollector, const ShapeFilter &inShapeFilter = { }) const override;
 
    // See: Shape::CollideSoftBodyVertices
    virtual void            CollideSoftBodyVertices(Mat44Arg inCenterOfMassTransform, Vec3Arg inScale, SoftBodyVertex *ioVertices, uint inNumVertices, float inDeltaTime, Vec3Arg inDisplacementDueToGravity, int inCollidingShapeIndex) const override;
 
    // See Shape::GetTrianglesStart
    virtual void            GetTrianglesStart(GetTrianglesContext &ioContext, const AABox &inBox, Vec3Arg inPositionCOM, QuatArg inRotation, Vec3Arg inScale) const override;
 
    // See Shape::GetTrianglesNext
    virtual int             GetTrianglesNext(GetTrianglesContext &ioContext, int inMaxTrianglesRequested, Float3 *outTriangleVertices, const PhysicsMaterial **outMaterials = nullptr) const override;
 
    // See Shape
    virtual void            SaveBinaryState(StreamOut &inStream) const override;
 
    // See Shape::GetStats
    virtual Stats           GetStats() const override;
 
    // See Shape::GetVolume
    virtual float           GetVolume() const override                                          { return mVolume; }
 
    float                   GetConvexRadius() const                                             { return mConvexRadius; }
 
    const Array<Plane> &    GetPlanes() const                                                   { return mPlanes; }
 
    inline uint             GetNumPoints() const                                                { return uint(mPoints.size()); }
 
    inline Vec3             GetPoint(uint inIndex) const                                        { return mPoints[inIndex].mPosition; }
 
    inline uint             GetNumFaces() const                                                 { return uint(mFaces.size()); }
 
    inline uint             GetNumVerticesInFace(uint inFaceIndex) const                        { return mFaces[inFaceIndex].mNumVertices; }
 
    inline uint             GetFaceVertices(uint inFaceIndex, uint inMaxVertices, uint *outVertices) const
    {
        const Face &face = mFaces[inFaceIndex];
        const uint8 *first_vertex = mVertexIdx.data() + face.mFirstVertex;
        uint num_vertices = min<uint>(face.mNumVertices, inMaxVertices);
        for (uint i = 0; i < num_vertices; ++i)
            outVertices[i] = first_vertex[i];
        return face.mNumVertices;
    }
 
    // Register shape functions with the registry
    static void             sRegister();
 
#ifdef JPH_DEBUG_RENDERER
    inline static bool      sDrawFaceOutlines = false;
#endif // JPH_DEBUG_RENDERER
 
protected:
    // See: Shape::RestoreBinaryState
    virtual void            RestoreBinaryState(StreamIn &inStream) override;
 
private:
    bool                    CastRayHelper(const RayCast &inRay, float &outMinFraction, float &outMaxFraction) const;
 
    class                   CHSGetTrianglesContext;
 
    class                   HullNoConvex;
    class                   HullWithConvex;
    class                   HullWithConvexScaled;
 
    struct Face
    {
        uint16              mFirstVertex;               
        uint16              mNumVertices = 0;           
    };
 
    static_assert(sizeof(Face) == 4, "Unexpected size");
    static_assert(alignof(Face) == 2, "Unexpected alignment");
 
    struct Point
    {
        Vec3                mPosition;                  
        int                 mNumFaces = 0;              
        int                 mFaces[3] = { -1, -1, -1 }; 
    };
 
    static_assert(sizeof(Point) == 32, "Unexpected size");
    static_assert(alignof(Point) == JPH_VECTOR_ALIGNMENT, "Unexpected alignment");
 
    Vec3                    mCenterOfMass;              
    Mat44                   mInertia;                   
    AABox                   mLocalBounds;               
    Array<Point>            mPoints;                    
    Array<Face>             mFaces;                     
    Array<Plane>            mPlanes;                    
    Array<uint8>            mVertexIdx;                 
    float                   mConvexRadius = 0.0f;       
    float                   mVolume;                    
    float                   mInnerRadius = FLT_MAX;     
 
#ifdef JPH_DEBUG_RENDERER
    mutable DebugRenderer::GeometryRef mGeometry;
#endif // JPH_DEBUG_RENDERER
};
 
JPH_NAMESPACE_END