TransformedShape.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/ObjectLayer.h>
#include <Jolt/Physics/Collision/ShapeFilter.h>
#include <Jolt/Physics/Collision/Shape/Shape.h>
#include <Jolt/Physics/Collision/Shape/SubShapeID.h>
#include <Jolt/Physics/Collision/BackFaceMode.h>
#include <Jolt/Physics/Body/BodyID.h>
 
JPH_NAMESPACE_BEGIN
 
struct RRayCast;
struct RShapeCast;
class CollideShapeSettings;
class RayCastResult;
 
class JPH_EXPORT TransformedShape
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
                                TransformedShape() = default;
                                TransformedShape(RVec3Arg inPositionCOM, QuatArg inRotation, const Shape *inShape, const BodyID &inBodyID, const SubShapeIDCreator &inSubShapeIDCreator = SubShapeIDCreator()) : mShapePositionCOM(inPositionCOM), mShapeRotation(inRotation), mShape(inShape), mBodyID(inBodyID), mSubShapeIDCreator(inSubShapeIDCreator) { }
 
    bool                        CastRay(const RRayCast &inRay, RayCastResult &ioHit) const;
 
    void                        CastRay(const RRayCast &inRay, const RayCastSettings &inRayCastSettings, CastRayCollector &ioCollector, const ShapeFilter &inShapeFilter = { }) const;
 
    void                        CollidePoint(RVec3Arg inPoint, CollidePointCollector &ioCollector, const ShapeFilter &inShapeFilter = { }) const;
 
    void                        CollideShape(const Shape *inShape, Vec3Arg inShapeScale, RMat44Arg inCenterOfMassTransform, const CollideShapeSettings &inCollideShapeSettings, RVec3Arg inBaseOffset, CollideShapeCollector &ioCollector, const ShapeFilter &inShapeFilter = { }) const;
 
    void                        CastShape(const RShapeCast &inShapeCast, const ShapeCastSettings &inShapeCastSettings, RVec3Arg inBaseOffset, CastShapeCollector &ioCollector, const ShapeFilter &inShapeFilter = { }) const;
 
    void                        CollectTransformedShapes(const AABox &inBox, TransformedShapeCollector &ioCollector, const ShapeFilter &inShapeFilter = { }) const;
 
    using GetTrianglesContext = Shape::GetTrianglesContext;
 
    void                        GetTrianglesStart(GetTrianglesContext &ioContext, const AABox &inBox, RVec3Arg inBaseOffset) const;
 
    int                         GetTrianglesNext(GetTrianglesContext &ioContext, int inMaxTrianglesRequested, Float3 *outTriangleVertices, const PhysicsMaterial **outMaterials = nullptr) const;
 
    inline Vec3                 GetShapeScale() const                       { return Vec3::sLoadFloat3Unsafe(mShapeScale); }
    inline void                 SetShapeScale(Vec3Arg inScale)              { inScale.StoreFloat3(&mShapeScale); }
 
    inline RMat44               GetCenterOfMassTransform() const            { return RMat44::sRotationTranslation(mShapeRotation, mShapePositionCOM); }
 
    inline RMat44               GetInverseCenterOfMassTransform() const     { return RMat44::sInverseRotationTranslation(mShapeRotation, mShapePositionCOM); }
 
    inline void                 SetWorldTransform(RVec3Arg inPosition, QuatArg inRotation, Vec3Arg inScale)
    {
        mShapePositionCOM = inPosition + inRotation * (inScale * mShape->GetCenterOfMass());
        mShapeRotation = inRotation;
        SetShapeScale(inScale);
    }
 
    inline void                 SetWorldTransform(RMat44Arg inTransform)
    {
        Vec3 scale;
        RMat44 rot_trans = inTransform.Decompose(scale);
        SetWorldTransform(rot_trans.GetTranslation(), rot_trans.GetQuaternion(), scale);
    }
 
    inline RMat44               GetWorldTransform() const
    {
        RMat44 transform = RMat44::sRotation(mShapeRotation).PreScaled(GetShapeScale());
        transform.SetTranslation(mShapePositionCOM - transform.Multiply3x3(mShape->GetCenterOfMass()));
        return transform;
    }
 
    AABox                       GetWorldSpaceBounds() const                 { return mShape != nullptr? mShape->GetWorldSpaceBounds(GetCenterOfMassTransform(), GetShapeScale()) : AABox(); }
 
    inline SubShapeID           MakeSubShapeIDRelativeToShape(const SubShapeID &inSubShapeID) const
    {
        // Take off the sub shape ID part that comes from mSubShapeIDCreator and validate that it is the same
        SubShapeID sub_shape_id;
        uint num_bits_written = mSubShapeIDCreator.GetNumBitsWritten();
        JPH_IF_ENABLE_ASSERTS(uint32 root_id =) inSubShapeID.PopID(num_bits_written, sub_shape_id);
        JPH_ASSERT(root_id == (mSubShapeIDCreator.GetID().GetValue() & ((1 << num_bits_written) - 1)));
        return sub_shape_id;
    }
 
    inline Vec3                 GetWorldSpaceSurfaceNormal(const SubShapeID &inSubShapeID, RVec3Arg inPosition) const
    {
        RMat44 inv_com = GetInverseCenterOfMassTransform();
        Vec3 scale = GetShapeScale(); // See comment at ScaledShape::GetSurfaceNormal for the math behind the scaling of the normal
        return inv_com.Multiply3x3Transposed(mShape->GetSurfaceNormal(MakeSubShapeIDRelativeToShape(inSubShapeID), Vec3(inv_com * inPosition) / scale) / scale).Normalized();
    }
 
    void                        GetSupportingFace(const SubShapeID &inSubShapeID, Vec3Arg inDirection, RVec3Arg inBaseOffset, Shape::SupportingFace &outVertices) const
    {
        Mat44 com = GetCenterOfMassTransform().PostTranslated(-inBaseOffset).ToMat44();
        mShape->GetSupportingFace(MakeSubShapeIDRelativeToShape(inSubShapeID), com.Multiply3x3Transposed(inDirection), GetShapeScale(), com, outVertices);
    }
 
    inline const PhysicsMaterial *GetMaterial(const SubShapeID &inSubShapeID) const
    {
        return mShape->GetMaterial(MakeSubShapeIDRelativeToShape(inSubShapeID));
    }
 
    inline uint64               GetSubShapeUserData(const SubShapeID &inSubShapeID) const
    {
        return mShape->GetSubShapeUserData(MakeSubShapeIDRelativeToShape(inSubShapeID));
    }
 
    TransformedShape            GetSubShapeTransformedShape(const SubShapeID &inSubShapeID, SubShapeID &outRemainder) const
    {
        TransformedShape ts = mShape->GetSubShapeTransformedShape(inSubShapeID, Vec3::sZero(), mShapeRotation, GetShapeScale(), outRemainder);
        ts.mShapePositionCOM += mShapePositionCOM;
        return ts;
    }
 
    inline static BodyID        sGetBodyID(const TransformedShape *inTS)    { return inTS != nullptr? inTS->mBodyID : BodyID(); }
 
    RVec3                       mShapePositionCOM;                          
    Quat                        mShapeRotation;                             
    RefConst<Shape>             mShape;                                     
    Float3                      mShapeScale { 1, 1, 1 };                    
    BodyID                      mBodyID;                                    
    SubShapeIDCreator           mSubShapeIDCreator;                         
};
 
static_assert(JPH_CPU_ADDRESS_BITS != 64 || sizeof(TransformedShape) == JPH_IF_SINGLE_PRECISION_ELSE(64, 96), "Not properly packed");
static_assert(alignof(TransformedShape) == JPH_RVECTOR_ALIGNMENT, "Not properly aligned");
 
JPH_NAMESPACE_END