mitiru::physics

Shared physics primitives. See `mitiru::physics2d` and `mitiru::physics3d` for backend-specific implementations.

Name	Kind	Items
`Box2DContactBegin`	struct	2
`Box2DBodyMove`	struct	4
`Box2DWorld`	class	20
`Box2DWorld`	class	5
`CollisionBridge`	class	12
`ObjectLayerPairFilterImpl`	class	1
`BPLayerInterfaceImpl`	class	3
`ObjectVsBroadPhaseLayerFilterImpl`	class	1
`ContactListenerImpl`	class	5
`JoltPhysicsWorld`	class	37
`JoltPhysicsWorld`	class	35
`BroadphaseType`	enum	3
`ColliderShapeType`	enum	5
`MeshData`	struct	1
`PhysicsBridge`	class	11
`PhysicsSystem`	class	3

struct Box2DContactBegin 2

b2BodyId a

b2BodyId b

struct Box2DBodyMove 4

b2BodyId body

float x

float y

float angle

class Box2DWorld 20

Box2DWorld(float gravityX = 0.0f, float gravityY = -9.81f)

~Box2DWorld()

Box2DWorld(const Box2DWorld&) = delete

Box2DWorld& operator=(const Box2DWorld&) = delete

Box2DWorld(Box2DWorld&& other) noexcept

Box2DWorld& operator=(Box2DWorld&& other) noexcept

void step(float dt, int subStepCount = 4)

b2WorldId worldId() const noexcept

b2BodyId createStaticBody(float x, float y)

b2BodyId createDynamicBody(float x, float y)

void addBox(b2BodyId body, float halfW, float halfH, float density = 1.0f)

void addCircle(b2BodyId body, float radius, float density = 1.0f, float restitution = 0.0f, float friction = 0.3f)

b2BodyId createStaticEdge(float x1, float y1, float x2, float y2, float friction = 0.3f, float restitution = 0.0f)

void destroyBody(b2BodyId body)

void setLinearVelocity(b2BodyId body, float vx, float vy)

sgc::Vec2f getLinearVelocity(b2BodyId body) const

sgc::Vec2f getPosition(b2BodyId body) const

float getAngle(b2BodyId body) const

std::vector<Box2DBodyMove> drainMoveEvents() const

std::vector<Box2DContactBegin> drainBeginContacts() const

class Box2DWorld 5

Box2DWorld(float = 0, float = -9.81f)

void step(float, int = 4)

std::vector<Box2DBodyMove> drainMoveEvents() const

std::vector<Box2DContactBegin> drainBeginContacts() const

using CollisionCallback = std::function<void(const CollisionPair&)>;

class CollisionBridge 12

void registerCallback(CollisionCallback callback)

[[nodiscard]] std::size_t callbackCount() const noexcept

[[nodiscard]] std::vector<CollisionPair> detectCollisions(scene::GameWorld& world)

using JoltBodyId = uint32_t;

using JoltContactCallback = std::function<void(const JoltContactEvent&)>;

using JoltShapeId = uint32_t;

inline constexpr JoltBodyId INVALID_JOLT_BODY_ID = 0xFFFFFFFF

inline constexpr JoltShapeId INVALID_JOLT_SHAPE_ID = 0xFFFFFFFF

[[nodiscard]] inline JPH::Vec3 toJolt(const sgc::Vec3f& v) noexcept

[[nodiscard]] inline sgc::Vec3f fromJolt(const JPH::Vec3& v) noexcept

[[nodiscard]] inline JPH::Quat toJoltQuat(const sgc::Quaternionf& q) noexcept

[[nodiscard]] inline sgc::Quaternionf fromJoltQuat(const JPH::Quat& q) noexcept

class ObjectLayerPairFilterImpl : public JPH::ObjectLayerPairFilter 1

bool ShouldCollide(JPH::ObjectLayer inObject1, JPH::ObjectLayer inObject2) const override

class BPLayerInterfaceImpl : public JPH::BroadPhaseLayerInterface 3

BPLayerInterfaceImpl()

JPH::uint GetNumBroadPhaseLayers() const override

JPH::BroadPhaseLayer GetBroadPhaseLayer(JPH::ObjectLayer inLayer) const override

class ObjectVsBroadPhaseLayerFilterImpl : public JPH::ObjectVsBroadPhaseLayerFilter 1

bool ShouldCollide(JPH::ObjectLayer inLayer1, JPH::BroadPhaseLayer inLayer2) const override

class ContactListenerImpl : public JPH::ContactListener 5

void SetOnContactAdded(JoltContactCallback callback)

void SetOnContactRemoved(JoltContactCallback callback)

JPH::ValidateResult OnContactValidate( const JPH::Body& , const JPH::Body& , JPH::RVec3Arg , const JPH::CollideShapeResult& ) override

void OnContactAdded( const JPH::Body& inBody1, const JPH::Body& inBody2, const JPH::ContactManifold& inManifold, JPH::ContactSettings& ) override

void OnContactRemoved(const JPH::SubShapeIDPair& inSubShapePair) override

class JoltPhysicsWorld 37

JoltPhysicsWorld() = default

~JoltPhysicsWorld()

JoltPhysicsWorld(const JoltPhysicsWorld&) = delete

JoltPhysicsWorld& operator=(const JoltPhysicsWorld&) = delete

JoltPhysicsWorld(JoltPhysicsWorld&&) = delete

JoltPhysicsWorld& operator=(JoltPhysicsWorld&&) = delete

void init(const JoltPhysicsConfig& config = {})

void shutdown()

[[nodiscard]] bool isInitialized() const noexcept

[[nodiscard]] const JoltPhysicsConfig& config() const noexcept

void update(float dt)

[[nodiscard]] JoltShapeId createBoxShape(const sgc::Vec3f& halfExtents)

[[nodiscard]] JoltShapeId createSphereShape(float radius)

[[nodiscard]] JoltShapeId createCapsuleShape(float halfHeight, float radius)

[[nodiscard]] JoltShapeId createMeshShape( const std::vector<sgc::Vec3f>& vertices, const std::vector<uint32_t>& indices)

[[nodiscard]] JoltShapeId createCompoundShape(const std::vector<JoltShapeId>& shapeIds)

[[nodiscard]] JoltBodyId createStaticBody( JoltShapeId shapeId, const sgc::Vec3f& position, const sgc::Quaternionf& rotation = {})

[[nodiscard]] JoltBodyId createDynamicBody( JoltShapeId shapeId, const sgc::Vec3f& position, const sgc::Quaternionf& rotation = {}, float mass = 1.0f)

[[nodiscard]] JoltBodyId createKinematicBody( JoltShapeId shapeId, const sgc::Vec3f& position, const sgc::Quaternionf& rotation = {})

void removeBody(JoltBodyId bodyId)

void setPosition(JoltBodyId bodyId, const sgc::Vec3f& position)

[[nodiscard]] sgc::Vec3f getPosition(JoltBodyId bodyId) const

void setRotation(JoltBodyId bodyId, const sgc::Quaternionf& rotation)

[[nodiscard]] sgc::Quaternionf getRotation(JoltBodyId bodyId) const

void setVelocity(JoltBodyId bodyId, const sgc::Vec3f& velocity)

[[nodiscard]] sgc::Vec3f getVelocity(JoltBodyId bodyId) const

void applyForce(JoltBodyId bodyId, const sgc::Vec3f& force)

void applyImpulse(JoltBodyId bodyId, const sgc::Vec3f& impulse)

[[nodiscard]] std::optional<JoltRaycastResult> raycast( const sgc::Vec3f& origin, const sgc::Vec3f& direction, float maxDist = 1000.0f) const

[[nodiscard]] std::vector<JoltBodyId> overlapSphere( const sgc::Vec3f& center, float radius) const

void onContactAdded(JoltContactCallback callback)

void onContactRemoved(JoltContactCallback callback)

[[nodiscard]] uint32_t getBodyCount() const noexcept

[[nodiscard]] uint32_t getActiveBodyCount() const noexcept

[[nodiscard]] std::vector<JoltDebugLine> gatherDebugLines() const

[[nodiscard]] JPH::PhysicsSystem* rawPhysicsSystem() noexcept

[[nodiscard]] const JPH::PhysicsSystem* rawPhysicsSystem() const noexcept

class JoltPhysicsWorld 35

JoltPhysicsWorld() = default

~JoltPhysicsWorld() = default

JoltPhysicsWorld(const JoltPhysicsWorld&) = delete

JoltPhysicsWorld& operator=(const JoltPhysicsWorld&) = delete

JoltPhysicsWorld(JoltPhysicsWorld&&) = delete

JoltPhysicsWorld& operator=(JoltPhysicsWorld&&) = delete

void init(const JoltPhysicsConfig& = {})

void shutdown()

[[nodiscard]] bool isInitialized() const noexcept

[[nodiscard]] const JoltPhysicsConfig& config() const noexcept

void update(float )

[[nodiscard]] JoltShapeId createBoxShape(const sgc::Vec3f& )

[[nodiscard]] JoltShapeId createSphereShape(float )

[[nodiscard]] JoltShapeId createCapsuleShape(float , float )

[[nodiscard]] JoltShapeId createMeshShape( const std::vector<sgc::Vec3f>& , const std::vector<uint32_t>& )

[[nodiscard]] JoltShapeId createCompoundShape(const std::vector<JoltShapeId>& )

[[nodiscard]] JoltBodyId createStaticBody( JoltShapeId , const sgc::Vec3f& , const sgc::Quaternionf& = {})

[[nodiscard]] JoltBodyId createDynamicBody( JoltShapeId , const sgc::Vec3f& , const sgc::Quaternionf& = {}, float = 1.0f)

[[nodiscard]] JoltBodyId createKinematicBody( JoltShapeId , const sgc::Vec3f& , const sgc::Quaternionf& = {})

void removeBody(JoltBodyId )

void setPosition(JoltBodyId , const sgc::Vec3f& )

[[nodiscard]] sgc::Vec3f getPosition(JoltBodyId ) const

void setRotation(JoltBodyId , const sgc::Quaternionf& )

[[nodiscard]] sgc::Quaternionf getRotation(JoltBodyId ) const

void setVelocity(JoltBodyId , const sgc::Vec3f& )

[[nodiscard]] sgc::Vec3f getVelocity(JoltBodyId ) const

void applyForce(JoltBodyId , const sgc::Vec3f& )

void applyImpulse(JoltBodyId , const sgc::Vec3f& )

[[nodiscard]] std::optional<JoltRaycastResult> raycast( const sgc::Vec3f& , const sgc::Vec3f& , float = 1000.0f) const

[[nodiscard]] std::vector<JoltBodyId> overlapSphere( const sgc::Vec3f& , float ) const

void onContactAdded(JoltContactCallback )

void onContactRemoved(JoltContactCallback )

[[nodiscard]] uint32_t getBodyCount() const noexcept

[[nodiscard]] uint32_t getActiveBodyCount() const noexcept

[[nodiscard]] std::vector<JoltDebugLine> gatherDebugLines() const

enum BroadphaseType 3

BruteForce

SpatialHash

BVH

enum ColliderShapeType 5

Sphere

Box

Capsule

Mesh

using ShapeData = std::variant<SphereData, BoxData, CapsuleData, MeshData>;

struct MeshData 1

std::string meshId

class PhysicsBridge 11

void init(const PhysicsConfig& config)

void shutdown()

[[nodiscard]] bool isInitialized() const noexcept

[[nodiscard]] const PhysicsConfig& config() const noexcept

void syncToPhysics(scene::GameWorld& world)

void stepSimulation(float dt)

void syncFromPhysics(scene::GameWorld& world)

[[nodiscard]] std::optional<RaycastHit> raycast( const sgc::Vec3f& origin, const sgc::Vec3f& direction, float maxDist = 1000.0f) const

[[nodiscard]] std::size_t bodyCount() const noexcept

[[nodiscard]] sgc::Vec3f getVelocity(scene::EntityId entityId) const noexcept

[[nodiscard]] sgc::Vec3f getPosition(scene::EntityId entityId) const noexcept

class PhysicsSystem : public scene::ISystem 3

PhysicsSystem(PhysicsBridge& physicsBridge, CollisionBridge& collisionBridge)

[[nodiscard]] std::string name() const override

void update(scene::GameWorld& world, float dt) override

Sourced from docs/API_CATALOG.md, auto-generated by tools/generate_api_catalog.py.