JoltPhysics/_body_interface_8h_source.html

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)

// SPDX-FileCopyrightText: 2021 Jorrit Rouwe

// SPDX-License-Identifier: MIT


#pragma once


#include <Jolt/Physics/Body/BodyID.h>

#include <Jolt/Physics/EActivation.h>

#include <Jolt/Physics/Collision/ObjectLayer.h>

#include <Jolt/Physics/Body/MotionType.h>

#include <Jolt/Physics/Body/MotionQuality.h>

#include <Jolt/Physics/Body/BodyType.h>

#include <Jolt/Core/Reference.h>


JPH_NAMESPACE_BEGIN


class Body;

class BodyCreationSettings;

class SoftBodyCreationSettings;

class BodyLockInterface;

class BroadPhase;

class BodyManager;

class TransformedShape;

class PhysicsMaterial;

class SubShapeID;

class Shape;

class TwoBodyConstraintSettings;

class TwoBodyConstraint;

class BroadPhaseLayerFilter;

class AABox;

class CollisionGroup;


class JPH_EXPORT BodyInterface : public NonCopyable

{

public:

    void                        Init(BodyLockInterface &inBodyLockInterface, BodyManager &inBodyManager, BroadPhase &inBroadPhase) { mBodyLockInterface = &inBodyLockInterface; mBodyManager = &inBodyManager; mBroadPhase = &inBroadPhase; }


    Body *                      CreateBody(const BodyCreationSettings &inSettings);


    Body *                      CreateSoftBody(const SoftBodyCreationSettings &inSettings);


    Body *                      CreateBodyWithID(const BodyID &inBodyID, const BodyCreationSettings &inSettings);


    Body *                      CreateSoftBodyWithID(const BodyID &inBodyID, const SoftBodyCreationSettings &inSettings);


    Body *                      CreateBodyWithoutID(const BodyCreationSettings &inSettings) const;


    Body *                      CreateSoftBodyWithoutID(const SoftBodyCreationSettings &inSettings) const;


    void                        DestroyBodyWithoutID(Body *inBody) const;


    bool                        AssignBodyID(Body *ioBody);


    bool                        AssignBodyID(Body *ioBody, const BodyID &inBodyID);


    Body *                      UnassignBodyID(const BodyID &inBodyID);


    void                        UnassignBodyIDs(const BodyID *inBodyIDs, int inNumber, Body **outBodies);


    void                        DestroyBody(const BodyID &inBodyID);


    void                        DestroyBodies(const BodyID *inBodyIDs, int inNumber);


    void                        AddBody(const BodyID &inBodyID, EActivation inActivationMode);


    void                        RemoveBody(const BodyID &inBodyID);


    bool                        IsAdded(const BodyID &inBodyID) const;


    BodyID                      CreateAndAddBody(const BodyCreationSettings &inSettings, EActivation inActivationMode);


    BodyID                      CreateAndAddSoftBody(const SoftBodyCreationSettings &inSettings, EActivation inActivationMode);


    using AddState = void *;


    AddState                    AddBodiesPrepare(BodyID *ioBodies, int inNumber);


    void                        AddBodiesFinalize(BodyID *ioBodies, int inNumber, AddState inAddState, EActivation inActivationMode);


    void                        AddBodiesAbort(BodyID *ioBodies, int inNumber, AddState inAddState);


    void                        RemoveBodies(BodyID *ioBodies, int inNumber);


    void                        ActivateBody(const BodyID &inBodyID);

    void                        ActivateBodies(const BodyID *inBodyIDs, int inNumber);

    void                        ActivateBodiesInAABox(const AABox &inBox, const BroadPhaseLayerFilter &inBroadPhaseLayerFilter, const ObjectLayerFilter &inObjectLayerFilter);

    void                        DeactivateBody(const BodyID &inBodyID);

    void                        DeactivateBodies(const BodyID *inBodyIDs, int inNumber);

    bool                        IsActive(const BodyID &inBodyID) const;

    void                        ResetSleepTimer(const BodyID &inBodyID);


    TwoBodyConstraint *         CreateConstraint(const TwoBodyConstraintSettings *inSettings, const BodyID &inBodyID1, const BodyID &inBodyID2);


    void                        ActivateConstraint(const TwoBodyConstraint *inConstraint);


    RefConst<Shape>             GetShape(const BodyID &inBodyID) const;


    void                        SetShape(const BodyID &inBodyID, const Shape *inShape, bool inUpdateMassProperties, EActivation inActivationMode) const;


    void                        NotifyShapeChanged(const BodyID &inBodyID, Vec3Arg inPreviousCenterOfMass, bool inUpdateMassProperties, EActivation inActivationMode) const;


    void                        SetObjectLayer(const BodyID &inBodyID, ObjectLayer inLayer);

    ObjectLayer                 GetObjectLayer(const BodyID &inBodyID) const;


    void                        SetPositionAndRotation(const BodyID &inBodyID, RVec3Arg inPosition, QuatArg inRotation, EActivation inActivationMode);

    void                        SetPositionAndRotationWhenChanged(const BodyID &inBodyID, RVec3Arg inPosition, QuatArg inRotation, EActivation inActivationMode);

    void                        GetPositionAndRotation(const BodyID &inBodyID, RVec3 &outPosition, Quat &outRotation) const;

    void                        SetPosition(const BodyID &inBodyID, RVec3Arg inPosition, EActivation inActivationMode);

    RVec3                       GetPosition(const BodyID &inBodyID) const;

    RVec3                       GetCenterOfMassPosition(const BodyID &inBodyID) const;

    void                        SetRotation(const BodyID &inBodyID, QuatArg inRotation, EActivation inActivationMode);

    Quat                        GetRotation(const BodyID &inBodyID) const;

    RMat44                      GetWorldTransform(const BodyID &inBodyID) const;

    RMat44                      GetCenterOfMassTransform(const BodyID &inBodyID) const;


    void                        MoveKinematic(const BodyID &inBodyID, RVec3Arg inTargetPosition, QuatArg inTargetRotation, float inDeltaTime);


    void                        SetLinearAndAngularVelocity(const BodyID &inBodyID, Vec3Arg inLinearVelocity, Vec3Arg inAngularVelocity);

    void                        GetLinearAndAngularVelocity(const BodyID &inBodyID, Vec3 &outLinearVelocity, Vec3 &outAngularVelocity) const;

    void                        SetLinearVelocity(const BodyID &inBodyID, Vec3Arg inLinearVelocity);

    Vec3                        GetLinearVelocity(const BodyID &inBodyID) const;

    void                        AddLinearVelocity(const BodyID &inBodyID, Vec3Arg inLinearVelocity);

    void                        AddLinearAndAngularVelocity(const BodyID &inBodyID, Vec3Arg inLinearVelocity, Vec3Arg inAngularVelocity);

    void                        SetAngularVelocity(const BodyID &inBodyID, Vec3Arg inAngularVelocity);

    Vec3                        GetAngularVelocity(const BodyID &inBodyID) const;

    Vec3                        GetPointVelocity(const BodyID &inBodyID, RVec3Arg inPoint) const;


    void                        SetPositionRotationAndVelocity(const BodyID &inBodyID, RVec3Arg inPosition, QuatArg inRotation, Vec3Arg inLinearVelocity, Vec3Arg inAngularVelocity);


    void                        AddForce(const BodyID &inBodyID, Vec3Arg inForce, EActivation inActivationMode = EActivation::Activate);

    void                        AddForce(const BodyID &inBodyID, Vec3Arg inForce, RVec3Arg inPoint, EActivation inActivationMode = EActivation::Activate);

    void                        AddTorque(const BodyID &inBodyID, Vec3Arg inTorque, EActivation inActivationMode = EActivation::Activate);

    void                        AddForceAndTorque(const BodyID &inBodyID, Vec3Arg inForce, Vec3Arg inTorque, EActivation inActivationMode = EActivation::Activate);


    void                        AddImpulse(const BodyID &inBodyID, Vec3Arg inImpulse);

    void                        AddImpulse(const BodyID &inBodyID, Vec3Arg inImpulse, RVec3Arg inPoint);

    void                        AddAngularImpulse(const BodyID &inBodyID, Vec3Arg inAngularImpulse);

    bool                        ApplyBuoyancyImpulse(const BodyID &inBodyID, RVec3Arg inSurfacePosition, Vec3Arg inSurfaceNormal, float inBuoyancy, float inLinearDrag, float inAngularDrag, Vec3Arg inFluidVelocity, Vec3Arg inGravity, float inDeltaTime);


    EBodyType                   GetBodyType(const BodyID &inBodyID) const;


    void                        SetMotionType(const BodyID &inBodyID, EMotionType inMotionType, EActivation inActivationMode);

    EMotionType                 GetMotionType(const BodyID &inBodyID) const;


    void                        SetMotionQuality(const BodyID &inBodyID, EMotionQuality inMotionQuality);

    EMotionQuality              GetMotionQuality(const BodyID &inBodyID) const;


    Mat44                       GetInverseInertia(const BodyID &inBodyID) const;


    void                        SetRestitution(const BodyID &inBodyID, float inRestitution);

    float                       GetRestitution(const BodyID &inBodyID) const;


    void                        SetFriction(const BodyID &inBodyID, float inFriction);

    float                       GetFriction(const BodyID &inBodyID) const;


    void                        SetGravityFactor(const BodyID &inBodyID, float inGravityFactor);

    float                       GetGravityFactor(const BodyID &inBodyID) const;


    void                        SetUseManifoldReduction(const BodyID &inBodyID, bool inUseReduction);

    bool                        GetUseManifoldReduction(const BodyID &inBodyID) const;


    void                        SetCollisionGroup(const BodyID &inBodyID, const CollisionGroup &inCollisionGroup);

    const CollisionGroup &      GetCollisionGroup(const BodyID &inBodyID) const;


    TransformedShape            GetTransformedShape(const BodyID &inBodyID) const;


    uint64                      GetUserData(const BodyID &inBodyID) const;

    void                        SetUserData(const BodyID &inBodyID, uint64 inUserData) const;


    const PhysicsMaterial *     GetMaterial(const BodyID &inBodyID, const SubShapeID &inSubShapeID) const;


    void                        InvalidateContactCache(const BodyID &inBodyID);


private:

    JPH_INLINE void             ActivateBodyInternal(Body &ioBody) const;


    BodyLockInterface *         mBodyLockInterface = nullptr;

    BodyManager *               mBodyManager = nullptr;

    BroadPhase *                mBroadPhase = nullptr;

};


JPH_NAMESPACE_END

BodyID.h

BodyType.h

EBodyType
EBodyType
Type of body.
Definition BodyType.h:11

JPH_EXPORT
#define JPH_EXPORT
Definition Core.h:275

uint64
std::uint64_t uint64
Definition Core.h:491

JPH_NAMESPACE_END
#define JPH_NAMESPACE_END
Definition Core.h:419

JPH_NAMESPACE_BEGIN
#define JPH_NAMESPACE_BEGIN
Definition Core.h:413

EActivation.h

EActivation
EActivation
Enum used by AddBody to determine if the body needs to be initially active.
Definition EActivation.h:11

EActivation::Activate
@ Activate
Activate the body, making it part of the simulation.

MotionQuality.h

EMotionQuality
EMotionQuality
Motion quality, or how well it detects collisions when it has a high velocity.
Definition MotionQuality.h:11

MotionType.h

EMotionType
EMotionType
Motion type of a physics body.
Definition MotionType.h:11

ObjectLayer.h

ObjectLayer
uint16 ObjectLayer
Definition ObjectLayer.h:16

Reference.h

AABox
Axis aligned box.
Definition AABox.h:16

BodyCreationSettings
Settings for constructing a rigid body.
Definition BodyCreationSettings.h:31

Body
Definition Body.h:39

BodyID
ID of a body. This is a way of reasoning about bodies in a multithreaded simulation while avoiding ra...
Definition BodyID.h:13

BodyInterface
Definition BodyInterface.h:36

BodyInterface::Init
void Init(BodyLockInterface &inBodyLockInterface, BodyManager &inBodyManager, BroadPhase &inBroadPhase)
Initialize the interface (should only be called by PhysicsSystem)
Definition BodyInterface.h:39

BodyInterface::AddState
void * AddState
Add state handle, used to keep track of a batch of bodies while adding them to the PhysicsSystem.
Definition BodyInterface.h:116

BodyLockInterface
Base class interface for locking a body. Usually you will use BodyLockRead / BodyLockWrite / BodyLock...
Definition BodyLockInterface.h:17

BodyManager
Class that contains all bodies.
Definition BodyManager.h:44

BroadPhase
Used to do coarse collision detection operations to quickly prune out bodies that will not collide.
Definition BroadPhase.h:26

BroadPhaseLayerFilter
Filter class for broadphase layers.
Definition BroadPhaseLayer.h:94

CollisionGroup
Definition CollisionGroup.h:20

Mat44
Holds a 4x4 matrix of floats, but supports also operations on the 3x3 upper left part of the matrix.
Definition Mat44.h:13

NonCopyable
Class that makes another class non-copyable. Usage: Inherit from NonCopyable.
Definition NonCopyable.h:11

ObjectLayerFilter
Filter class for object layers.
Definition ObjectLayer.h:28

PhysicsMaterial
Definition PhysicsMaterial.h:23

Quat
Definition Quat.h:33

RefConst
Definition Reference.h:163

Shape
Base class for all shapes (collision volume of a body). Defines a virtual interface for collision det...
Definition Shape.h:186

SoftBodyCreationSettings
Definition SoftBodyCreationSettings.h:18

SubShapeID
A sub shape id contains a path to an element (usually a triangle or other primitive type) of a compou...
Definition SubShapeID.h:23

TransformedShape
Definition TransformedShape.h:26

TwoBodyConstraint
Base class for all constraints that involve 2 bodies. Body1 is usually considered the parent,...
Definition TwoBodyConstraint.h:27

TwoBodyConstraintSettings
Base class for settings for all constraints that involve 2 bodies.
Definition TwoBodyConstraint.h:16

Vec3
Definition Vec3.h:17