EVEngine/World3D_8h_source.html

#pragma once

#include "common/Export.h"


#include "common/Snapshot.h"

#include "common/Result.h"

#include "physics/OwnedQuery3D.h"

#include "physics/PhysicsHandles.h"

#include "physics/backend/SimulationBackend.h"


#include <cstdint>

#include <memory>

#include <string>

#include <unordered_map>

#include <unordered_set>

#include <utility>

#include <vector>


#include <box3d/id.h>

#include <box3d/types.h>


namespace eve::physics {


namespace action_adapter {

class ActionCollisionIgnoreState;

}


class Body3D;

class Shape3D;

class Joint3D;

class Mechanism3D;


struct CameraSphereHit3D {

    bool  hit = false;

    int   bodyId = -1;

    float fraction = 1.f;

    float x = 0.f, y = 0.f, z = 0.f;

    float nx = 0.f, ny = 0.f, nz = 0.f;

};


struct ClothContact3D {

    bool   hit = false;

    float  nx = 0.f;

    float  ny = 0.f;

    float  nz = 0.f;

    float  depth = 0.f;  // radius - distance (meters); > 0 when inside

    Body3D *body = nullptr;

    float   friction = 0.f;

    float   restitution = 0.f;

};


enum class ClothProbeStatus { Miss, Hit };


class EVENGINE_API_WORLD World3D {

public:


    struct EventShape {

        int bodyId = 0;

        int shapeId = 0;

        int shapeTag = 0;

    };


    struct ContactEvent {

        EventShape shapeA;

        EventShape shapeB;

    };


    struct TriggerEvent {

        EventShape sensor;

        EventShape visitor;

    };


    struct HitEvent {

        EventShape shapeA;

        EventShape shapeB;

        float pointX = 0.f, pointY = 0.f, pointZ = 0.f;

        float normalX = 0.f, normalY = 0.f, normalZ = 0.f;

        float approachSpeed = 0.f;

        float normalImpulse = 0.f;

    };


    struct JointStressEvent {

        int jointId = 0;

        int bodyAId = 0;

        int bodyBId = 0;

        int kind = 0;

        float forceX = 0.f, forceY = 0.f, forceZ = 0.f;

        float torqueX = 0.f, torqueY = 0.f, torqueZ = 0.f;

    };


    World3D(float gravityX, float gravityY, float gravityZ, bool sleep,

            eve::PersistentId instanceId = eve::PersistentId::nil());

    ~World3D();


    World3D(const World3D &)            = delete;

    World3D &operator=(const World3D &) = delete;


    void update(float dt);

    void updateFull(float dt, int subStepCount);


    [[nodiscard("check the physics step outcome or explicitly ignore it")]]

    eve::Result<void> step(const eve::SimulationStep &step, const SimulationSettings &settings = {});


    [[nodiscard]] SimulationObservation simulationObservation() const noexcept;

    [[nodiscard]] SimulationBackendKind backendKind() const noexcept;

    [[nodiscard]] SimulationDeterminism backendDeterminism() const noexcept;

    [[nodiscard]] eve::SimulationTick simulationTick() const noexcept { return simulationTick_; }

    [[nodiscard]] PhysicsWorldHandle runtimeHandle() const noexcept { return runtimeHandle_; }

    [[nodiscard]] std::weak_ptr<const void> lifetimeToken() const noexcept { return queryLifetime_; }

    [[nodiscard]] eve::PersistentId persistentId() const noexcept { return instanceId_; }

    [[nodiscard]] static World3D* findWorld(PhysicsWorldHandle handle) noexcept;

    [[nodiscard]] bool usedBackendFallback() const noexcept { return backendFallback_; }

    [[nodiscard("inspect backend selection diagnostics")]]

    eve::Status backendSelectionStatus() const;


    [[nodiscard("check or persist the physics snapshot")]]

    eve::Result<eve::SnapshotEnvelope> snapshot(const eve::SnapshotHashProvider &hashProvider) const;


    [[nodiscard("check the physics snapshot restore outcome")]]

    eve::Result<void> restore(const eve::SnapshotEnvelope &snapshot, const eve::SnapshotHashProvider &hashProvider);


    void  setGravity(float gx, float gy, float gz);

    float getGravityX() const;

    float getGravityY() const;

    float getGravityZ() const;

    void setContinuousCollisionEnabled(bool enabled);

    bool isContinuousCollisionEnabled() const;

    void setRestitutionThreshold(float speed);

    float getRestitutionThreshold() const;

    void setHitEventThreshold(float speed);

    float getHitEventThreshold() const;

    void setBodyPairCollisionEnabled(Body3D *bodyA, Body3D *bodyB, bool enabled);

    bool isBodyPairCollisionEnabled(Body3D *bodyA, Body3D *bodyB) const;

    void setShapePairCollisionEnabled(Shape3D *shapeA, Shape3D *shapeB, bool enabled);

    bool isShapePairCollisionEnabled(Shape3D *shapeA, Shape3D *shapeB) const;

    void setContactTuning(float hertz, float dampingRatio, float pushOutSpeed);

    float getContactHertz() const { return contactHertz_; }

    float getContactDampingRatio() const { return contactDampingRatio_; }

    float getContactPushOutSpeed() const { return contactPushOutSpeed_; }

    void setContactRecycleDistance(float distance);

    float getContactRecycleDistance() const;

    void setMaximumLinearSpeed(float speed);

    float getMaximumLinearSpeed() const;

    void setWarmStartingEnabled(bool enabled);

    bool isWarmStartingEnabled() const;

    int explode(float x, float y, float z, float radius, float falloff,

                float impulsePerArea, int maskBits = -1);

    int getExplosionResultCount() const { return static_cast<int>(explosionResults_.size()); }

    int getExplosionResultBodyId(int index) const;

    float getExplosionResultDeltaVelocityX(int index) const;

    float getExplosionResultDeltaVelocityY(int index) const;

    float getExplosionResultDeltaVelocityZ(int index) const;

    float getExplosionResultDeltaAngularVelocityX(int index) const;

    float getExplosionResultDeltaAngularVelocityY(int index) const;

    float getExplosionResultDeltaAngularVelocityZ(int index) const;

    float getBoundsMinX() const;

    float getBoundsMinY() const;

    float getBoundsMinZ() const;

    float getBoundsMaxX() const;

    float getBoundsMaxY() const;

    float getBoundsMaxZ() const;

    int getBodyCount() const;

    int getShapeCount() const;

    int getContactCount() const;

    int getJointCount() const;

    int getIslandCount() const;

    int getAwakeBodyCount() const;

    int getAwakeContactCount() const;

    int getRecycledContactCount() const;

    int getStaticTreeHeight() const;

    int getDynamicTreeHeight() const;

    int getMemoryByteCount() const;

    float getProfileStepMs() const;

    float getProfilePairsMs() const;

    float getProfileCollideMs() const;

    float getProfileSolveMs() const;

    float getProfileBulletsMs() const;

    float getProfileSensorsMs() const;


    Body3D *newBody(const std::string &bodyType, float x, float y, float z);

    [[nodiscard]] Body3D *findBody(PhysicsBodyHandle handle) const;

    [[nodiscard]] Body3D *findBodyById(int bodyId) const;

    [[nodiscard]] Shape3D *findShape(PhysicsShapeHandle handle) const;

    [[nodiscard]] Shape3D *findShapeById(int shapeId) const;

    [[nodiscard]] Joint3D *findJoint(PhysicsJointHandle handle) const;

    Joint3D *newDistanceJoint(Body3D *bodyA, Body3D *bodyB, float anchorAX, float anchorAY,

                              float anchorAZ, float anchorBX, float anchorBY, float anchorBZ,

                              float length, bool collideConnected = false);

    Joint3D *newRevoluteJoint(Body3D *bodyA, Body3D *bodyB, float anchorX, float anchorY,

                              float anchorZ, float axisX, float axisY, float axisZ,

                              bool collideConnected = false);

    Joint3D *newPrismaticJoint(Body3D *bodyA, Body3D *bodyB, float anchorX, float anchorY,

                               float anchorZ, float axisX, float axisY, float axisZ,

                               bool collideConnected = false);

    Joint3D *newSphericalJoint(Body3D *bodyA, Body3D *bodyB, float anchorX, float anchorY,

                               float anchorZ, float axisX, float axisY, float axisZ,

                               bool collideConnected = false);

    Joint3D *newWheelJoint(Body3D *bodyA, Body3D *bodyB, float anchorX, float anchorY,

                           float anchorZ, float suspensionAxisX, float suspensionAxisY,

                           float suspensionAxisZ, float wheelAxisX, float wheelAxisY,

                           float wheelAxisZ, bool collideConnected = false);

    Joint3D *newWeldJoint(Body3D *bodyA, Body3D *bodyB, float anchorX, float anchorY,

                          float anchorZ, bool collideConnected = false);

    Joint3D *newMotorJoint(Body3D *bodyA, Body3D *bodyB, bool collideConnected = false);

    Joint3D *newParallelJoint(Body3D *bodyA, Body3D *bodyB, float axisX, float axisY, float axisZ,

                              bool collideConnected = false);

    Joint3D *newFilterJoint(Body3D *bodyA, Body3D *bodyB);


    Mechanism3D *newShaft(Body3D *support, Body3D *rotor, float anchorX, float anchorY,

                          float anchorZ, float axisX, float axisY, float axisZ,

                          bool collideConnected = false);

    Mechanism3D *newRatchet(Body3D *frame, Body3D *wheel, float anchorX, float anchorY,

                            float anchorZ, float axisX, float axisY, float axisZ, int direction,

                            float engagementTorque, bool collideConnected = false);

    Mechanism3D *newCrankSlider(Body3D *frame, Body3D *crank, Body3D *rod, Body3D *slider,

                                float crankAnchorX, float crankAnchorY, float crankAnchorZ,

                                float axisX, float axisY, float axisZ, float crankPinX,

                                float crankPinY, float crankPinZ, float sliderPinX,

                                float sliderPinY, float sliderPinZ, float slideAxisX,

                                float slideAxisY, float slideAxisZ, bool collideConnected = false);


    void destroyBody(Body3D *body);

    void destroy();


    int rayCast(float x1, float y1, float z1, float x2, float y2, float z2);

    int rayCastFiltered(float x1, float y1, float z1, float x2, float y2, float z2,

                        uint64_t maskBits);

    [[nodiscard]] eve::Result<RayHit3D> rayCastOwned(float x1, float y1, float z1, float x2,

                                                     float y2, float z2, QueryFilter3D filter = {});

    bool sphereCast(float x1, float y1, float z1, float x2, float y2, float z2,

                    float radius, uint64_t maskBits, int ignoredBodyId,

                    CameraSphereHit3D* out) const;

    int rayCastAll(float x1, float y1, float z1, float x2, float y2, float z2, int maxHits);

    bool  hasRayHit() const { return rayHitBodyId_ >= 0; }

    int   getRayHitBodyId() const { return rayHitBodyId_; }

    int getRayHitShapeId() const { return rayHitShapeId_; }

    int getRayHitShapeTag() const { return rayHitShapeTag_; }

    int getRayHitMaterialId() const { return rayHitMaterialId_; }

    int getRayHitTriangleIndex() const { return rayHitTriangleIndex_; }

    float getRayHitX() const { return rayHitX_; }

    float getRayHitY() const { return rayHitY_; }

    float getRayHitZ() const { return rayHitZ_; }

    float getRayHitNormalX() const { return rayHitNormalX_; }

    float getRayHitNormalY() const { return rayHitNormalY_; }

    float getRayHitNormalZ() const { return rayHitNormalZ_; }

    float getRayHitFraction() const { return rayHitFraction_; }

    int getRayResultCount() const { return static_cast<int>(rayResults_.size()); }

    int getRayResultBodyId(int index) const;

    int getRayResultShapeId(int index) const;

    int getRayResultShapeTag(int index) const;

    int getRayResultMaterialId(int index) const;

    int getRayResultTriangleIndex(int index) const;

    float getRayResultX(int index) const;

    float getRayResultY(int index) const;

    float getRayResultZ(int index) const;

    float getRayResultNormalX(int index) const;

    float getRayResultNormalY(int index) const;

    float getRayResultNormalZ(int index) const;

    float getRayResultFraction(int index) const;


    int queryAABB(float minX, float minY, float minZ, float maxX, float maxY, float maxZ);

    [[nodiscard]] eve::Result<BroadPhaseAabb3D> queryAabbBroadPhaseOwned(

        float minX, float minY, float minZ, float maxX, float maxY, float maxZ,

        QueryFilter3D filter = {});


    int querySphere(float x, float y, float z, float radius);


    int queryCapsule(float ax, float ay, float az, float bx, float by, float bz, float radius);

    [[nodiscard]] eve::Result<CapsuleOverlap3D> queryCapsuleOwned(

        float ax, float ay, float az, float bx, float by, float bz, float radius,

        QueryFilter3D filter = {});


    int queryBox(float x, float y, float z, float width, float height, float depth, float qx,

                 float qy, float qz, float qw);


    int castSphere(float x, float y, float z, float radius, float dx, float dy, float dz);

    int castSphereAll(float x, float y, float z, float radius, float dx, float dy, float dz,

                      int maxHits);


    int castCapsule(float ax, float ay, float az, float bx, float by, float bz, float radius,

                    float dx, float dy, float dz);

    int castCapsuleAll(float ax, float ay, float az, float bx, float by, float bz, float radius,

                       float dx, float dy, float dz, int maxHits);


    int castBox(float x, float y, float z, float width, float height, float depth, float qx,

                float qy, float qz, float qw, float dx, float dy, float dz);

    int castBoxAll(float x, float y, float z, float width, float height, float depth, float qx,

                   float qy, float qz, float qw, float dx, float dy, float dz, int maxHits);


    int closestPoint(float x, float y, float z, float maxDistance);

    bool hasClosestPoint() const { return closestBodyId_ >= 0; }

    int getClosestBodyId() const { return closestBodyId_; }

    int getClosestShapeId() const { return closestShapeId_; }

    int getClosestShapeTag() const { return closestShapeTag_; }

    float getClosestX() const { return closestX_; }

    float getClosestY() const { return closestY_; }

    float getClosestZ() const { return closestZ_; }

    float getClosestNormalX() const { return closestNormalX_; }

    float getClosestNormalY() const { return closestNormalY_; }

    float getClosestNormalZ() const { return closestNormalZ_; }

    float getClosestDistance() const { return closestDistance_; }


    bool hasShapeCastHit() const { return shapeCastBodyId_ >= 0; }

    int getShapeCastBodyId() const { return shapeCastBodyId_; }

    int getShapeCastShapeId() const { return shapeCastShapeId_; }

    int getShapeCastShapeTag() const { return shapeCastShapeTag_; }

    int getShapeCastMaterialId() const { return shapeCastMaterialId_; }

    int getShapeCastTriangleIndex() const { return shapeCastTriangleIndex_; }

    float getShapeCastX() const { return shapeCastX_; }

    float getShapeCastY() const { return shapeCastY_; }

    float getShapeCastZ() const { return shapeCastZ_; }

    float getShapeCastNormalX() const { return shapeCastNormalX_; }

    float getShapeCastNormalY() const { return shapeCastNormalY_; }

    float getShapeCastNormalZ() const { return shapeCastNormalZ_; }

    float getShapeCastFraction() const { return shapeCastFraction_; }

    int getShapeCastResultCount() const { return static_cast<int>(shapeCastResults_.size()); }

    int getShapeCastResultBodyId(int index) const;

    int getShapeCastResultShapeId(int index) const;

    int getShapeCastResultShapeTag(int index) const;

    int getShapeCastResultMaterialId(int index) const;

    int getShapeCastResultTriangleIndex(int index) const;

    float getShapeCastResultX(int index) const;

    float getShapeCastResultY(int index) const;

    float getShapeCastResultZ(int index) const;

    float getShapeCastResultNormalX(int index) const;

    float getShapeCastResultNormalY(int index) const;

    float getShapeCastResultNormalZ(int index) const;

    float getShapeCastResultFraction(int index) const;


    bool moveCapsule(float ax, float ay, float az, float bx, float by, float bz, float radius,

                     float dx, float dy, float dz);

    [[nodiscard]] eve::Result<CapsuleMove3D> moveCapsuleOwned(

        float ax, float ay, float az, float bx, float by, float bz, float radius, float dx,

        float dy, float dz, QueryFilter3D filter = {}, CapsuleMovePolicy3D policy = {});

    float getMoverDeltaX() const { return moverDeltaX_; }

    float getMoverDeltaY() const { return moverDeltaY_; }

    float getMoverDeltaZ() const { return moverDeltaZ_; }

    float getMoverNormalX() const { return moverNormalX_; }

    float getMoverNormalY() const { return moverNormalY_; }

    float getMoverNormalZ() const { return moverNormalZ_; }

    int getMoverPlaneCount() const { return moverPlaneCount_; }

    int getMoverIterations() const { return moverIterations_; }

    void setMoverUp(float x, float y, float z);

    void setMoverSlopeLimit(float degrees);

    bool isMoverGrounded() const { return moverGrounded_; }

    float getMoverGroundDot() const { return moverGroundDot_; }


    int getQueryCount() const { return static_cast<int>(queryBodyIds_.size()); }

    int getQueryBodyId(int index) const;

    int getQueryShapeCount() const { return static_cast<int>(queryShapes_.size()); }

    int getQueryShapeId(int index) const;

    int getQueryShapeTag(int index) const;


    int getBeginContactCount() const { return static_cast<int>(beginContacts_.size()); }

    int getBeginContactBodyAId(int index) const;

    int getBeginContactBodyBId(int index) const;

    int getBeginContactShapeAId(int index) const;

    int getBeginContactShapeBId(int index) const;

    int getBeginContactShapeATag(int index) const;

    int getBeginContactShapeBTag(int index) const;

    int getEndContactCount() const { return static_cast<int>(endContacts_.size()); }

    int getEndContactBodyAId(int index) const;

    int getEndContactBodyBId(int index) const;

    int getEndContactShapeAId(int index) const;

    int getEndContactShapeBId(int index) const;

    int getEndContactShapeATag(int index) const;

    int getEndContactShapeBTag(int index) const;


    int getBeginTriggerCount() const { return static_cast<int>(beginTriggers_.size()); }

    int getBeginTriggerSensorBodyId(int index) const;

    int getBeginTriggerVisitorBodyId(int index) const;

    int getBeginTriggerSensorShapeId(int index) const;

    int getBeginTriggerVisitorShapeId(int index) const;

    int getBeginTriggerSensorShapeTag(int index) const;

    int getBeginTriggerVisitorShapeTag(int index) const;

    int getEndTriggerCount() const { return static_cast<int>(endTriggers_.size()); }

    int getEndTriggerSensorBodyId(int index) const;

    int getEndTriggerVisitorBodyId(int index) const;

    int getEndTriggerSensorShapeId(int index) const;

    int getEndTriggerVisitorShapeId(int index) const;

    int getEndTriggerSensorShapeTag(int index) const;

    int getEndTriggerVisitorShapeTag(int index) const;

    void clearContactEvents();


    int queryBodyContacts(int bodyId, int maxPoints);

    int getContactPointCount() const { return static_cast<int>(contactPoints_.size()); }

    int getContactPointShapeId(int index) const;

    int getContactPointShapeTag(int index) const;

    int getContactPointOtherBodyId(int index) const;

    int getContactPointOtherShapeId(int index) const;

    int getContactPointOtherShapeTag(int index) const;

    float getContactPointX(int index) const;

    float getContactPointY(int index) const;

    float getContactPointZ(int index) const;

    float getContactPointNormalX(int index) const;

    float getContactPointNormalY(int index) const;

    float getContactPointNormalZ(int index) const;

    float getContactPointSeparation(int index) const;

    float getContactPointNormalImpulse(int index) const;

    float getContactPointTotalNormalImpulse(int index) const;

    float getContactPointNormalVelocity(int index) const;

    bool isContactPointPersisted(int index) const;


    int getHitCount() const { return static_cast<int>(hits_.size()); }

    int getHitBodyAId(int index) const;

    int getHitBodyBId(int index) const;

    int getHitShapeAId(int index) const;

    int getHitShapeBId(int index) const;

    int getHitShapeATag(int index) const;

    int getHitShapeBTag(int index) const;

    float getHitPointX(int index) const;

    float getHitPointY(int index) const;

    float getHitPointZ(int index) const;

    float getHitNormalX(int index) const;

    float getHitNormalY(int index) const;

    float getHitNormalZ(int index) const;

    float getHitApproachSpeed(int index) const;

    float getHitNormalImpulse(int index) const;

    int getJointStressCount() const { return static_cast<int>(jointStressEvents_.size()); }

    int getJointStressJointId(int index) const;

    int getJointStressBodyAId(int index) const;

    int getJointStressBodyBId(int index) const;

    int getJointStressKind(int index) const;

    float getJointStressForceX(int index) const;

    float getJointStressForceY(int index) const;

    float getJointStressForceZ(int index) const;

    float getJointStressTorqueX(int index) const;

    float getJointStressTorqueY(int index) const;

    float getJointStressTorqueZ(int index) const;

    void setQueryFilter(int categoryBits, int maskBits);

    void resetQueryFilter();

    int getQueryCategoryBits() const { return static_cast<int>(queryCategoryBits_); }

    int getQueryMaskBits() const { return static_cast<int>(queryMaskBits_); }

    void setQueryIgnoredBodyId(int bodyId);

    void setQueryIgnoredShapeId(int shapeId);

    int getQueryIgnoredBodyId() const { return queryIgnoredBodyId_; }

    int getQueryIgnoredShapeId() const { return queryIgnoredShapeId_; }

    void clearQueryIgnores();


    bool      isValid() const;


    bool pointProbe(float x, float y, float z, float radius, ClothContact3D *out) const;

    [[nodiscard]] ClothProbeStatus pointProbeFiltered(float x, float y, float z, float radius, ClothContact3D *out,

                                                      uint64_t categoryBits, uint64_t maskBits) const;

    b3WorldId raw() const { return worldId_; }


    void forgetBody(Body3D *body);

    void forgetShape(Shape3D *shape);

    void forgetJoint(Joint3D *joint);

    void forgetMechanism(Mechanism3D *mechanism);

    void registerShapeHandle(Shape3D *shape);

    void updateShapeTag(Shape3D *shape);


    int nextBodyId();

    PhysicsBodyHandle nextBodyRuntimeHandle();

    PhysicsShapeHandle nextShapeRuntimeHandle();

    PhysicsJointHandle nextJointRuntimeHandle();

    int nextShapeId() { return nextShapeId_++; }

    int nextJointId() { return nextJointId_++; }

    int nextMechanismId();


    void emitContactEvents();


private:

    friend class action_adapter::ActionCollisionIgnoreState;

    friend struct WorldSnapshotAccess;

    friend class Body3D;

    friend class Joint3D;

    friend class Mechanism3D;

    friend class Shape3D;

    friend class TargetingLineOfSightAdapter;

    friend void registerCameraObstructionWorld(World3D *world);


    World3D(float gravityX, float gravityY, float gravityZ, bool sleep,

            eve::PersistentId instanceId, bool registerQueries);


    b3WorldId worldId_{};

    std::unique_ptr<ISimulationBackend> simulation_;

    PhysicsWorldHandle                  runtimeHandle_          = PhysicsWorldHandle::invalid();

    eve::PersistentId                   instanceId_             = eve::PersistentId::nil();

    std::shared_ptr<const void>         queryLifetime_          = std::make_shared<int>(0);

    bool      destroyed_ = false;

    int       nextId_    = 1;

    int       nextShapeId_ = 1;

    int       nextJointId_ = 1;

    int       nextMechanismId_ = 1;

    std::uint32_t                       nextBodyHandleIndex_    = 1u;

    std::uint32_t                       nextShapeHandleIndex_   = 1u;

    std::uint32_t                       nextJointHandleIndex_   = 1u;

    eve::SimulationTick                 simulationTick_         = eve::SimulationTick::zero();

    eve::Status                         backendSelectionStatus_ = eve::Status::success();

    bool                                backendFallback_        = false;


    std::unordered_set<Body3D *>  bodies_;

    std::unordered_set<Shape3D *> shapes_;

    std::unordered_set<Joint3D *> joints_;

    std::unordered_set<Mechanism3D *> mechanisms_;

    std::unordered_set<uint64_t> disabledBodyPairs_;

    std::unordered_set<uint64_t> disabledShapePairs_;

    std::unordered_map<uint64_t, EventShape> shapeRecords_;

    std::unordered_map<PhysicsShapeHandle, Shape3D *> shapeHandles_;

    std::unordered_map<uint64_t, PhysicsShapeHandle>  shapeRawHandles_;

    std::unordered_map<PhysicsJointHandle, Joint3D *> jointHandles_;

    std::vector<ContactEvent> beginContacts_;

    std::vector<ContactEvent> endContacts_;

    std::vector<TriggerEvent> beginTriggers_;

    std::vector<TriggerEvent> endTriggers_;

    std::vector<HitEvent> hits_;

    std::vector<JointStressEvent> jointStressEvents_;


    struct ContactPointResult {

        int shapeId = -1;

        int shapeTag = 0;

        int otherBodyId = -1;

        int otherShapeId = -1;

        int otherShapeTag = 0;

        uint32_t featureId = 0;

        float x = 0.f, y = 0.f, z = 0.f;

        float normalX = 0.f, normalY = 0.f, normalZ = 0.f;

        float separation = 0.f;

        float normalImpulse = 0.f;

        float totalNormalImpulse = 0.f;

        float normalVelocity = 0.f;

        bool persisted = false;

    };

    std::vector<ContactPointResult> contactPoints_;

    [[nodiscard]] eve::Result<void> prepareRuntimeHandleRefresh() const;

    void refreshRuntimeHandlesAfterRestore();

    void adoptPreparedTopology(World3D &prepared);

    const ContactPointResult &contactPointAt(int index, const char *operation) const;

    static bool preSolveCallback(b3ShapeId shapeIdA, b3ShapeId shapeIdB, b3Pos point,

                                 b3Vec3 normal, void *context);

    static bool customFilterCallback(b3ShapeId shapeIdA, b3ShapeId shapeIdB,

                                     void *context);

    void refreshContactFilter(Shape3D *shape);

    void removeCollisionOverridesForBody(int bodyId);

    void removeCollisionOverridesForShape(int shapeId);


    EventShape eventShapeFrom(b3ShapeId shapeId) const;

    const ContactEvent &contactEventAt(const std::vector<ContactEvent> &events, int index,

                                       const char *operation) const;

    const TriggerEvent &triggerEventAt(const std::vector<TriggerEvent> &events, int index,

                                       const char *operation) const;

    const HitEvent &hitEventAt(int index, const char *operation) const;

    const JointStressEvent &jointStressEventAt(int index, const char *operation) const;


    int   rayHitBodyId_   = -1;

    int   rayHitShapeId_  = -1;

    int   rayHitShapeTag_ = 0;

    int   rayHitMaterialId_ = 0;

    int   rayHitTriangleIndex_ = -1;

    float rayHitX_        = 0.f;

    float rayHitY_        = 0.f;

    float rayHitZ_        = 0.f;

    float rayHitNormalX_  = 0.f;

    float rayHitNormalY_  = 0.f;

    float rayHitNormalZ_  = 0.f;

    float rayHitFraction_ = 0.f;


    struct RayResult {

        int bodyId = -1;

        int shapeId = -1;

        int shapeTag = 0;

        int materialId = 0;

        int triangleIndex = -1;

        float x = 0.f, y = 0.f, z = 0.f;

        float normalX = 0.f, normalY = 0.f, normalZ = 0.f;

        float fraction = 0.f;

    };

    std::vector<RayResult> rayResults_;

    const RayResult &rayResultAt(int index, const char *operation) const;


    std::vector<int> queryBodyIds_;

    std::vector<std::pair<int, int>> queryShapes_;


    int overlapProxy(b3Pos origin, const b3ShapeProxy &proxy);

    int castProxyAll(b3Pos origin, const b3ShapeProxy &proxy, b3Vec3 translation, int maxHits);

    int rayCastAllInternal(float x1, float y1, float z1, float x2, float y2, float z2,

                           int maxHits, b3QueryFilter filter);

    b3QueryFilter makeQueryFilter() const;

    bool shouldIgnoreQueryShape(b3ShapeId shapeId) const;


    int shapeCastBodyId_ = -1;

    int shapeCastShapeId_ = -1;

    int shapeCastShapeTag_ = 0;

    int shapeCastMaterialId_ = 0;

    int shapeCastTriangleIndex_ = -1;

    float shapeCastX_ = 0.f, shapeCastY_ = 0.f, shapeCastZ_ = 0.f;

    float shapeCastNormalX_ = 0.f, shapeCastNormalY_ = 0.f, shapeCastNormalZ_ = 0.f;

    float shapeCastFraction_ = 0.f;

    struct ShapeCastResult {

        int bodyId = -1;

        int shapeId = -1;

        int shapeTag = 0;

        int materialId = 0;

        int triangleIndex = -1;

        float x = 0.f, y = 0.f, z = 0.f;

        float normalX = 0.f, normalY = 0.f, normalZ = 0.f;

        float fraction = 0.f;

    };

    std::vector<ShapeCastResult> shapeCastResults_;

    const ShapeCastResult &shapeCastResultAt(int index, const char *operation) const;


    int closestBodyId_ = -1;

    int closestShapeId_ = -1;

    int closestShapeTag_ = 0;

    float closestX_ = 0.f, closestY_ = 0.f, closestZ_ = 0.f;

    float closestNormalX_ = 0.f, closestNormalY_ = 0.f, closestNormalZ_ = 0.f;

    float closestDistance_ = 0.f;


    float moverDeltaX_ = 0.f, moverDeltaY_ = 0.f, moverDeltaZ_ = 0.f;

    float moverNormalX_ = 0.f, moverNormalY_ = 0.f, moverNormalZ_ = 0.f;

    int moverPlaneCount_ = 0;

    int moverIterations_ = 0;

    b3Vec3 moverUp_ = b3Vec3{0.f, 1.f, 0.f};

    float moverSlopeCos_ = 0.6427876f;

    float moverGroundDot_ = -1.f;

    bool moverGrounded_ = false;


    float contactHertz_ = 30.f;

    float contactDampingRatio_ = 10.f;

    float contactPushOutSpeed_ = 3.f;


    struct ExplosionResult {

        int bodyId = -1;

        float deltaVX = 0.f, deltaVY = 0.f, deltaVZ = 0.f;

        float deltaWX = 0.f, deltaWY = 0.f, deltaWZ = 0.f;

    };

    std::vector<ExplosionResult> explosionResults_;

    const ExplosionResult &explosionResultAt(int index, const char *operation) const;


    uint32_t queryCategoryBits_ = 0xFFFFFFFFu;

    uint32_t queryMaskBits_ = 0xFFFFFFFFu;

    int queryIgnoredBodyId_ = -1;

    int queryIgnoredShapeId_ = -1;

};


}  // namespace eve::physics

operation
ActionParameterOperation operation
Definition ActionNotifyRegistry.cpp:152

y
float y
Definition AnimClip.cpp:738

x
float x
Definition AnimClip.cpp:738

z
float z
Definition AnimClip.cpp:738

degrees
float degrees
Definition CardTypes.cpp:35

bz
int bz
Definition CaveMesh.cpp:114

ax
int ax
Definition CaveMesh.cpp:113

ay
int ay
Definition CaveMesh.cpp:113

bx
int bx
Definition CaveMesh.cpp:114

length
float length
Definition CaveMesh.cpp:94

az
int az
Definition CaveMesh.cpp:113

by
int by
Definition CaveMesh.cpp:114

Export.h

EVENGINE_API_WORLD
#define EVENGINE_API_WORLD
Definition Export.h:109

shape
ShaderImageInput shape
Definition GraphicsShaderResources.cpp:17

height
std::uint32_t height
Definition ImageImporter.cpp:14

width
std::uint32_t width
Definition ImageImporter.cpp:13

destroy
void(* destroy)(void *)
Definition JobSystemThreadPool.cpp:91

kind
TokenKind kind
Definition LanguageIndex.cpp:17

distance
float distance
Definition MeshContactBlend.cpp:43

normal
Texture * normal
Definition ModelRenderer.cpp:154

OwnedQuery3D.h
Owning, generation-qualified results for cross-module 3D physics queries.

world
World3D * world
Definition PhysicsCapabilities.cpp:116

PhysicsHandles.h
Process-local, generation-qualified handles owned by the physics domain.

radius
float radius
Definition PlacementSystem.cpp:42

handle
PrimitiveHandle handle
Definition PrimitiveScriptBindings.cpp:21

Result.h
Move-only, checked operation results for the common layer.

origin
V3 origin
Definition RoadBake.cpp:138

direction
RoadLaneDirection direction
Definition RoadTraffic.cpp:20

axisZ
float axisZ
Definition RockMesh.cpp:22

axisY
float axisY
Definition RockMesh.cpp:22

axisX
float axisX
Definition RockMesh.cpp:22

filter
std::string filter
Definition SceneLoader.cpp:188

dz
float dz
Definition ShadowScheme.cpp:20

dy
float dy
Definition ShadowScheme.cpp:20

dx
float dx
Definition ShadowScheme.cpp:20

SimulationBackend.h
Backend-neutral, observable fixed-step contract for physics domains.

Snapshot.h
Versioned, integrity-checked persistence envelopes.

events
Battle::Events events
Definition TacticsPersistence.cpp:172

settings
TerrainThermalSettings settings
Definition TerrainGenerationSession.cpp:95

separation
float separation
Definition TreeMesh.cpp:159

step
float step
Definition TreeMesh.cpp:314

body
std::string body
Definition UnityImporter.cpp:595

index
uint32_t index
Definition UnityVegetationMaterial.cpp:163

depth
std::uint32_t depth
Definition UnityVegetationPreset.cpp:34

context
const VegetationPresetContext & context
Definition VegetationPreset.cpp:94

point
glm::vec3 point
Definition VolumeFluidSimplexQuery.cpp:17

qy
float qy
Definition WorldSnapshot.cpp:249

qx
float qx
Definition WorldSnapshot.cpp:249

qw
float qw
Definition WorldSnapshot.cpp:249

qz
float qz
Definition WorldSnapshot.cpp:249

eve::Result
Move-only operation result carrying either a value or Status.
Definition Result.h:155

eve::RuntimeHandle< PhysicsWorldHandleTag >

eve::Status
Structured status and zero or more diagnostics for an operation.
Definition Status.h:68

eve::Status::success
static Status success(StatusCode code=StatusCode::Ok)
Construct a successful status with an explicit non-error outcome.
Definition Status.h:81

eve::detail::Id128
Id128 public API.
Definition Identity.h:112

eve::detail::Id128::nil
static constexpr Id128 nil() noexcept
Returns the all-zero nil value.
Definition Identity.h:142

eve::detail::StrongUint64< detail::SimulationTickTag >

eve::detail::StrongUint64< detail::SimulationTickTag >::zero
static constexpr StrongUint64 zero() noexcept
Returns the zero value for this strong type.
Definition StrongUint64.h:24

eve::physics::Body3D
3D rigid body (Box3D) in meter-space coordinates (+Y up by convention). Owned by a World3D; create pr...
Definition Body3D.h:24

eve::physics::Joint3D
Script-facing Box3D joint owned by a World3D.
Definition Joint3D.h:17

eve::physics::Mechanism3D
Composed mechanical assembly owned by a World3D.
Definition Mechanism3D.h:25

eve::physics::Shape3D
3D shape (box/sphere/capsule) attached to a Body3D with material settings. Created via Body3D::new*Sh...
Definition Shape3D.h:25

eve::physics::TargetingLineOfSightAdapter
Read-only 3D physics implementation of sensing's LOS capability.
Definition TargetingLineOfSightAdapter.h:30

eve::physics::World3D
Box3D rigid-body world. Script coordinates are meters (Box3D native), unlike 2D World which uses pixe...
Definition World3D.h:63

eve::physics::World3D::hasClosestPoint
bool hasClosestPoint() const
Whether the latest closestPoint call found a shape.
Definition World3D.h:655

eve::physics::World3D::getBeginTriggerVisitorShapeId
int getBeginTriggerVisitorShapeId(int index) const
Visitor shape ID of a begin-trigger event.

eve::physics::World3D::getProfileStepMs
float getProfileStepMs() const
Latest complete physics step time in milliseconds.

eve::physics::World3D::getBeginContactShapeAId
int getBeginContactShapeAId(int index) const
Shape ID on stable side A of a begin-contact event.

eve::physics::World3D::getShapeCastX
float getShapeCastX() const
World-space contact point X from the last shape cast.
Definition World3D.h:690

eve::physics::World3D::getEndTriggerCount
int getEndTriggerCount() const
Number of sensor overlaps that ended during the latest step.
Definition World3D.h:828

eve::physics::World3D::getJointStressForceY
float getJointStressForceY(int index) const
Constraint force Y of a stress event.

eve::physics::World3D::getClosestShapeId
int getClosestShapeId() const
Stable shape id from the latest closestPoint call, or -1.
Definition World3D.h:659

eve::physics::World3D::getContactPointTotalNormalImpulse
float getContactPointTotalNormalImpulse(int index) const
Total normal impulse accumulated across all physics substeps.

eve::physics::World3D::getRayHitTriangleIndex
int getRayHitTriangleIndex() const
Mesh/height-field triangle index from the last ray cast, otherwise -1.
Definition World3D.h:523

eve::physics::World3D::getHitNormalX
float getHitNormalX(int index) const
Hit normal X, pointing from stable side A to B.

eve::physics::World3D::getDynamicTreeHeight
int getDynamicTreeHeight() const
Dynamic broad-phase tree height.

eve::physics::World3D::hasRayHit
bool hasRayHit() const
Definition World3D.h:514

eve::physics::World3D::persistentId
eve::PersistentId persistentId() const noexcept
Stable non-nil identity written to snapshot envelopes.
Definition World3D.h:152

eve::physics::World3D::getShapeCastResultShapeId
int getShapeCastResultShapeId(int index) const
Shape ID of a sorted Shape Cast result.

eve::physics::World3D::getClosestY
float getClosestY() const
Closest surface point Y.
Definition World3D.h:665

eve::physics::World3D::getBeginTriggerSensorBodyId
int getBeginTriggerSensorBodyId(int index) const
Sensor body ID of a begin-trigger event.

eve::physics::World3D::getHitPointZ
float getHitPointZ(int index) const
World-space impact point Z.

eve::physics::World3D::getContactPushOutSpeed
float getContactPushOutSpeed() const
Current maximum contact push-out speed in m/s.
Definition World3D.h:222

eve::physics::World3D::getContactPointNormalImpulse
float getContactPointNormalImpulse(int index) const
Normal impulse from the final physics substep.

eve::physics::World3D::getEndContactShapeBId
int getEndContactShapeBId(int index) const
Shape ID on stable side B of an end-contact event.

eve::physics::World3D::getShapeCastResultFraction
float getShapeCastResultFraction(int index) const
Translation fraction in [0,1] of a Shape Cast result.

eve::physics::World3D::getClosestShapeTag
int getClosestShapeTag() const
User tag of the shape from the latest closestPoint call, or zero.
Definition World3D.h:661

eve::physics::World3D::runtimeHandle
PhysicsWorldHandle runtimeHandle() const noexcept
Process-local identity used by PhysicsLink; invalid after destruction.
Definition World3D.h:141

eve::physics::World3D::getEndContactBodyAId
int getEndContactBodyAId(int index) const
Body ID on stable side A of an end-contact event.

eve::physics::World3D::getEndContactShapeATag
int getEndContactShapeATag(int index) const
Shape Tag on stable side A of an end-contact event.

eve::physics::World3D::getJointCount
int getJointCount() const
Current backend joint count.

eve::physics::World3D::getShapeCastShapeId
int getShapeCastShapeId() const
Stable shape id from the last shape cast, or -1.
Definition World3D.h:682

eve::physics::World3D::getRayResultTriangleIndex
int getRayResultTriangleIndex(int index) const
Mesh/height-field triangle index of a sorted ray result, otherwise -1.

eve::physics::World3D::getRayHitX
float getRayHitX() const
Definition World3D.h:524

eve::physics::World3D::getShapeCastZ
float getShapeCastZ() const
World-space contact point Z from the last shape cast.
Definition World3D.h:694

eve::physics::World3D::getContactPointX
float getContactPointX(int index) const
World-space contact point X on the queried body.

eve::physics::World3D::lifetimeToken
std::weak_ptr< const void > lifetimeToken() const noexcept
Return a weak lifetime token for owner-thread runtime integrations.
Definition World3D.h:150

eve::physics::World3D::getBeginContactBodyBId
int getBeginContactBodyBId(int index) const
Body ID on stable side B of a begin-contact event.

eve::physics::World3D::getRayHitY
float getRayHitY() const
Definition World3D.h:525

eve::physics::World3D::getContactPointOtherShapeId
int getContactPointOtherShapeId(int index) const
Other Shape ID of a contact point.

eve::physics::World3D::getContactDampingRatio
float getContactDampingRatio() const
Current contact damping ratio.
Definition World3D.h:220

eve::physics::World3D::getMoverNormalY
float getMoverNormalY() const
Representative blocking normal Y from the last move.
Definition World3D.h:757

eve::physics::World3D::getQueryShapeCount
int getQueryShapeCount() const
Number of individual shapes hit by the last overlap query.
Definition World3D.h:778

eve::physics::World3D::getExplosionResultDeltaVelocityX
float getExplosionResultDeltaVelocityX(int index) const
Explosion-induced linear velocity delta X.

eve::physics::World3D::World3D
World3D(const World3D &)=delete

eve::physics::World3D::operator=
World3D & operator=(const World3D &)=delete

eve::physics::World3D::getQueryCount
int getQueryCount() const
Number of bodies hit by the last overlap query.
Definition World3D.h:774

eve::physics::World3D::getRayResultNormalY
float getRayResultNormalY(int index) const
Surface normal Y of a sorted ray result.

eve::physics::World3D::getProfileBulletsMs
float getProfileBulletsMs() const
Latest continuous-collision bullet time in milliseconds.

eve::physics::World3D::getContactHertz
float getContactHertz() const
Current contact stiffness frequency.
Definition World3D.h:218

eve::physics::World3D::getRayHitNormalX
float getRayHitNormalX() const
Definition World3D.h:527

eve::physics::World3D::getContactPointSeparation
float getContactPointSeparation(int index) const
Signed surface separation; negative values indicate penetration.

eve::physics::World3D::getHitShapeBId
int getHitShapeBId(int index) const
Stable Shape ID on side B of a hit.

eve::physics::World3D::getClosestNormalX
float getClosestNormalX() const
Surface-to-target normal X, or zero for an inside/on-surface target.
Definition World3D.h:669

eve::physics::World3D::getQueryMaskBits
int getQueryMaskBits() const
Query mask bits currently in use.
Definition World3D.h:945

eve::physics::World3D::getMoverDeltaZ
float getMoverDeltaZ() const
Resolved translation Z from the last moveCapsule call.
Definition World3D.h:753

eve::physics::World3D::getProfileCollideMs
float getProfileCollideMs() const
Latest narrow-phase collision time in milliseconds.

eve::physics::World3D::getHitCount
int getHitCount() const
Number of significant collision hits generated during the latest step.
Definition World3D.h:887

eve::physics::World3D::getJointStressKind
int getJointStressKind(int index) const
Joint kind code: 0 distance, 1 revolute, 2 prismatic, 3 spherical, 4 wheel.

eve::physics::World3D::getShapeCastShapeTag
int getShapeCastShapeTag() const
User tag of the shape from the last shape cast, or zero on no hit.
Definition World3D.h:684

eve::physics::World3D::getRayHitNormalZ
float getRayHitNormalZ() const
Definition World3D.h:529

eve::physics::World3D::getMoverDeltaY
float getMoverDeltaY() const
Resolved translation Y from the last moveCapsule call.
Definition World3D.h:751

eve::physics::World3D::getHitPointX
float getHitPointX(int index) const
World-space impact point X.

eve::physics::World3D::getBeginTriggerCount
int getBeginTriggerCount() const
Number of sensor overlaps that began during the latest step.
Definition World3D.h:814

eve::physics::World3D::getExplosionResultBodyId
int getExplosionResultBodyId(int index) const
Stable Body ID of an affected body, sorted ascending.

eve::physics::World3D::getQueryCategoryBits
int getQueryCategoryBits() const
Query category bits currently in use.
Definition World3D.h:943

eve::physics::World3D::getMoverNormalZ
float getMoverNormalZ() const
Representative blocking normal Z from the last move.
Definition World3D.h:759

eve::physics::World3D::getBeginTriggerVisitorShapeTag
int getBeginTriggerVisitorShapeTag(int index) const
Visitor Shape Tag of a begin-trigger event.

eve::physics::World3D::getEndContactShapeBTag
int getEndContactShapeBTag(int index) const
Shape Tag on stable side B of an end-contact event.

eve::physics::World3D::getClosestDistance
float getClosestDistance() const
Non-negative distance from the target to the closest shape.
Definition World3D.h:675

eve::physics::World3D::getHitBodyBId
int getHitBodyBId(int index) const
Stable body ID on side B of a hit.

eve::physics::World3D::nextJointId
int nextJointId()
Internal: next stable joint id.
Definition World3D.h:994

eve::physics::World3D::getContactPointShapeTag
int getContactPointShapeTag(int index) const
Queried-body Shape Tag of a contact point.

eve::physics::World3D::getHitNormalImpulse
float getHitNormalImpulse(int index) const
Total normal impulse accumulated across all manifolds and substeps.

eve::physics::World3D::getHitShapeAId
int getHitShapeAId(int index) const
Stable Shape ID on side A of a hit.

eve::physics::World3D::getShapeCastNormalZ
float getShapeCastNormalZ() const
Contact normal Z from the last shape cast.
Definition World3D.h:700

eve::physics::World3D::getContactPointY
float getContactPointY(int index) const
World-space contact point Y on the queried body.

eve::physics::World3D::getContactPointNormalY
float getContactPointNormalY(int index) const
Contact normal Y from queried body toward the other body.

eve::physics::World3D::getBeginContactCount
int getBeginContactCount() const
Number of non-sensor contacts that began during the latest step.
Definition World3D.h:785

eve::physics::World3D::getJointStressBodyAId
int getJointStressBodyAId(int index) const
Stable body A ID of a stress event.

eve::physics::World3D::getShapeCastResultNormalZ
float getShapeCastResultNormalZ(int index) const
Contact normal Z of a Shape Cast result.

eve::physics::World3D::getEndContactCount
int getEndContactCount() const
Number of non-sensor contacts that ended during the latest step.
Definition World3D.h:799

eve::physics::World3D::getRayResultShapeId
int getRayResultShapeId(int index) const
Shape ID of a sorted ray result.

eve::physics::World3D::getBeginTriggerSensorShapeId
int getBeginTriggerSensorShapeId(int index) const
Sensor shape ID of a begin-trigger event.

eve::physics::World3D::getJointStressCount
int getJointStressCount() const
Number of joints exceeding force/torque thresholds in the latest step.
Definition World3D.h:917

eve::physics::World3D::getShapeCastResultY
float getShapeCastResultY(int index) const
World-space contact point Y of a Shape Cast result.

eve::physics::World3D::getShapeCastTriangleIndex
int getShapeCastTriangleIndex() const
Mesh/height-field triangle index from the latest shape cast, otherwise -1.
Definition World3D.h:688

eve::physics::World3D::getMoverDeltaX
float getMoverDeltaX() const
Resolved translation X from the last moveCapsule call.
Definition World3D.h:749

eve::physics::World3D::getShapeCastMaterialId
int getShapeCastMaterialId() const
Surface material ID at the last shape-cast intersection, or zero.
Definition World3D.h:686

eve::physics::World3D::getRayResultFraction
float getRayResultFraction(int index) const
Segment fraction in [0,1] of a sorted ray result.

eve::physics::World3D::getClosestZ
float getClosestZ() const
Closest surface point Z.
Definition World3D.h:667

eve::physics::World3D::nextShapeId
int nextShapeId()
Internal: next stable shape id.
Definition World3D.h:992

eve::physics::World3D::getEndTriggerSensorShapeTag
int getEndTriggerSensorShapeTag(int index) const
Sensor Shape Tag of an end-trigger event.

eve::physics::World3D::getIslandCount
int getIslandCount() const
Current solver-island count.

eve::physics::World3D::getBeginContactShapeATag
int getBeginContactShapeATag(int index) const
Shape Tag on stable side A of a begin-contact event.

eve::physics::World3D::getStaticTreeHeight
int getStaticTreeHeight() const
Static broad-phase tree height.

eve::physics::World3D::getContactPointOtherBodyId
int getContactPointOtherBodyId(int index) const
Other Body ID of a contact point.

eve::physics::World3D::getEndTriggerSensorShapeId
int getEndTriggerSensorShapeId(int index) const
Sensor shape ID of an end-trigger event.

eve::physics::World3D::getShapeCastResultNormalX
float getShapeCastResultNormalX(int index) const
Contact normal X of a Shape Cast result.

eve::physics::World3D::getClosestBodyId
int getClosestBodyId() const
Stable body id from the latest closestPoint call, or -1.
Definition World3D.h:657

eve::physics::World3D::getContactPointZ
float getContactPointZ(int index) const
World-space contact point Z on the queried body.

eve::physics::World3D::getBeginContactShapeBTag
int getBeginContactShapeBTag(int index) const
Shape Tag on stable side B of a begin-contact event.

eve::physics::World3D::getExplosionResultDeltaAngularVelocityY
float getExplosionResultDeltaAngularVelocityY(int index) const
Explosion-induced angular velocity delta Y.

eve::physics::World3D::getExplosionResultDeltaVelocityY
float getExplosionResultDeltaVelocityY(int index) const
Explosion-induced linear velocity delta Y.

eve::physics::World3D::getRayResultX
float getRayResultX(int index) const
World-space hit point X of a sorted ray result.

eve::physics::World3D::getMemoryByteCount
int getMemoryByteCount() const
Approximate Box3D world allocation in bytes.

eve::physics::World3D::getEndTriggerVisitorShapeId
int getEndTriggerVisitorShapeId(int index) const
Visitor shape ID of an end-trigger event.

eve::physics::World3D::getQueryIgnoredShapeId
int getQueryIgnoredShapeId() const
Stable Shape3D ID currently ignored by queries, or -1.
Definition World3D.h:953

eve::physics::World3D::getEndTriggerVisitorShapeTag
int getEndTriggerVisitorShapeTag(int index) const
Visitor Shape Tag of an end-trigger event.

eve::physics::World3D::getShapeCastBodyId
int getShapeCastBodyId() const
Stable body id from the last shape cast, or -1.
Definition World3D.h:680

eve::physics::World3D::raw
b3WorldId raw() const
Raw Box3D world id.
Definition World3D.h:969

eve::physics::World3D::getShapeCastY
float getShapeCastY() const
World-space contact point Y from the last shape cast.
Definition World3D.h:692

eve::physics::World3D::getContactPointShapeId
int getContactPointShapeId(int index) const
Queried-body Shape ID of a contact point.

eve::physics::World3D::getExplosionResultDeltaAngularVelocityX
float getExplosionResultDeltaAngularVelocityX(int index) const
Explosion-induced angular velocity delta X.

eve::physics::World3D::getShapeCastResultX
float getShapeCastResultX(int index) const
World-space contact point X of a Shape Cast result.

eve::physics::World3D::getRayHitMaterialId
int getRayHitMaterialId() const
Surface material ID at the last ray intersection, or zero.
Definition World3D.h:521

eve::physics::World3D::getJointStressForceZ
float getJointStressForceZ(int index) const
Constraint force Z of a stress event.

eve::physics::World3D::getShapeCastResultTriangleIndex
int getShapeCastResultTriangleIndex(int index) const
Mesh/height-field triangle index of a Shape Cast result, otherwise -1.

eve::physics::World3D::getClosestNormalZ
float getClosestNormalZ() const
Surface-to-target normal Z, or zero for an inside/on-surface target.
Definition World3D.h:673

eve::physics::World3D::getExplosionResultCount
int getExplosionResultCount() const
Number of bodies affected by the latest explosion.
Definition World3D.h:249

eve::physics::World3D::getShapeCastResultZ
float getShapeCastResultZ(int index) const
World-space contact point Z of a Shape Cast result.

eve::physics::World3D::getRayHitShapeTag
int getRayHitShapeTag() const
User tag of the shape from the last ray cast, or zero on no hit.
Definition World3D.h:519

eve::physics::World3D::getProfileSensorsMs
float getProfileSensorsMs() const
Latest sensor processing time in milliseconds.

eve::physics::World3D::getBodyCount
int getBodyCount() const
Current backend body count.

eve::physics::World3D::getAwakeContactCount
int getAwakeContactCount() const
Contacts processed by the latest collide pass.

eve::physics::World3D::getHitShapeBTag
int getHitShapeBTag(int index) const
Shape Tag on side B of a hit.

eve::physics::World3D::getClosestNormalY
float getClosestNormalY() const
Surface-to-target normal Y, or zero for an inside/on-surface target.
Definition World3D.h:671

eve::physics::World3D::getHitBodyAId
int getHitBodyAId(int index) const
Stable body ID on side A of a hit.

eve::physics::World3D::getJointStressForceX
float getJointStressForceX(int index) const
Constraint force X of a stress event.

eve::physics::World3D::getContactPointNormalVelocity
float getContactPointNormalVelocity(int index) const
Pre-solve relative normal velocity; negative means approaching.

eve::physics::World3D::getRayResultShapeTag
int getRayResultShapeTag(int index) const
Shape Tag of a sorted ray result.

eve::physics::World3D::getShapeCastResultShapeTag
int getShapeCastResultShapeTag(int index) const
Shape Tag of a sorted Shape Cast result.

eve::physics::World3D::getShapeCastFraction
float getShapeCastFraction() const
Translation fraction in [0,1] at the earliest hit.
Definition World3D.h:702

eve::physics::World3D::getBeginContactShapeBId
int getBeginContactShapeBId(int index) const
Shape ID on stable side B of a begin-contact event.

eve::physics::World3D::getEndTriggerSensorBodyId
int getEndTriggerSensorBodyId(int index) const
Sensor body ID of an end-trigger event.

eve::physics::World3D::getEndTriggerVisitorBodyId
int getEndTriggerVisitorBodyId(int index) const
Visitor body ID of an end-trigger event.

eve::physics::World3D::getShapeCastNormalX
float getShapeCastNormalX() const
Contact normal X from the last shape cast.
Definition World3D.h:696

eve::physics::World3D::getContactCount
int getContactCount() const
Current backend contact count.

eve::physics::World3D::getQueryIgnoredBodyId
int getQueryIgnoredBodyId() const
Stable Body3D ID currently ignored by queries, or -1.
Definition World3D.h:951

eve::physics::World3D::getContactPointCount
int getContactPointCount() const
Number of points cached by queryBodyContacts.
Definition World3D.h:852

eve::physics::World3D::getExplosionResultDeltaAngularVelocityZ
float getExplosionResultDeltaAngularVelocityZ(int index) const
Explosion-induced angular velocity delta Z.

eve::physics::World3D::getRayResultNormalX
float getRayResultNormalX(int index) const
Surface normal X of a sorted ray result.

eve::physics::World3D::getShapeCastResultNormalY
float getShapeCastResultNormalY(int index) const
Contact normal Y of a Shape Cast result.

eve::physics::World3D::getProfileSolveMs
float getProfileSolveMs() const
Latest constraint solver time in milliseconds.

eve::physics::World3D::getJointStressBodyBId
int getJointStressBodyBId(int index) const
Stable body B ID of a stress event.

eve::physics::World3D::getEndContactShapeAId
int getEndContactShapeAId(int index) const
Shape ID on stable side A of an end-contact event.

eve::physics::World3D::getRayHitZ
float getRayHitZ() const
Definition World3D.h:526

eve::physics::World3D::getContactPointNormalX
float getContactPointNormalX(int index) const
Contact normal X from queried body toward the other body.

eve::physics::World3D::getShapeCastNormalY
float getShapeCastNormalY() const
Contact normal Y from the last shape cast.
Definition World3D.h:698

eve::physics::World3D::getHitNormalY
float getHitNormalY(int index) const
Hit normal Y, pointing from stable side A to B.

eve::physics::World3D::getProfilePairsMs
float getProfilePairsMs() const
Latest broad-phase pair generation time in milliseconds.

eve::physics::World3D::getHitApproachSpeed
float getHitApproachSpeed(int index) const
Positive pre-solve approach speed in m/s.

eve::physics::World3D::hasShapeCastHit
bool hasShapeCastHit() const
Whether the last sphere, capsule, or box cast hit a body.
Definition World3D.h:678

eve::physics::World3D::getRayHitBodyId
int getRayHitBodyId() const
Definition World3D.h:515

eve::physics::World3D::getClosestX
float getClosestX() const
Closest surface point X.
Definition World3D.h:663

eve::physics::World3D::getMoverNormalX
float getMoverNormalX() const
Representative blocking normal X from the last move.
Definition World3D.h:755

eve::physics::World3D::getRecycledContactCount
int getRecycledContactCount() const
Contact points recycled during the latest step.

eve::physics::World3D::getShapeCastResultMaterialId
int getShapeCastResultMaterialId(int index) const
Surface material ID at a sorted Shape Cast intersection.

eve::physics::World3D::getEndContactBodyBId
int getEndContactBodyBId(int index) const
Body ID on stable side B of an end-contact event.

eve::physics::World3D::getRayResultCount
int getRayResultCount() const
Number of results cached by the latest rayCast or rayCastAll call.
Definition World3D.h:532

eve::physics::World3D::getExplosionResultDeltaVelocityZ
float getExplosionResultDeltaVelocityZ(int index) const
Explosion-induced linear velocity delta Z.

eve::physics::World3D::usedBackendFallback
bool usedBackendFallback() const noexcept
Whether optional accelerator selection fell back to CPU.
Definition World3D.h:158

eve::physics::World3D::getHitNormalZ
float getHitNormalZ(int index) const
Hit normal Z, pointing from stable side A to B.

eve::physics::World3D::getBeginTriggerSensorShapeTag
int getBeginTriggerSensorShapeTag(int index) const
Sensor Shape Tag of a begin-trigger event.

eve::physics::World3D::getRayResultNormalZ
float getRayResultNormalZ(int index) const
Surface normal Z of a sorted ray result.

eve::physics::World3D::getRayHitFraction
float getRayHitFraction() const
Definition World3D.h:530

eve::physics::World3D::getShapeCastResultBodyId
int getShapeCastResultBodyId(int index) const
Body ID of a sorted Shape Cast result.

eve::physics::World3D::getHitShapeATag
int getHitShapeATag(int index) const
Shape Tag on side A of a hit.

eve::physics::World3D::getJointStressTorqueY
float getJointStressTorqueY(int index) const
Constraint torque Y of a stress event.

eve::physics::World3D::getJointStressJointId
int getJointStressJointId(int index) const
Stable Joint3D ID of a stress event.

eve::physics::World3D::getBeginContactBodyAId
int getBeginContactBodyAId(int index) const
Body ID on stable side A of a begin-contact event.

eve::physics::World3D::getBeginTriggerVisitorBodyId
int getBeginTriggerVisitorBodyId(int index) const
Visitor body ID of a begin-trigger event.

eve::physics::World3D::getJointStressTorqueZ
float getJointStressTorqueZ(int index) const
Constraint torque Z of a stress event.

eve::physics::World3D::getMoverIterations
int getMoverIterations() const
Number of outer solver passes used by the last move.
Definition World3D.h:763

eve::physics::World3D::getRayResultY
float getRayResultY(int index) const
World-space hit point Y of a sorted ray result.

eve::physics::World3D::getRayHitNormalY
float getRayHitNormalY() const
Definition World3D.h:528

eve::physics::World3D::getShapeCastResultCount
int getShapeCastResultCount() const
Number of results cached by the latest single or multi Shape Cast.
Definition World3D.h:704

eve::physics::World3D::getMoverPlaneCount
int getMoverPlaneCount() const
Number of collision planes considered during the last move.
Definition World3D.h:761

eve::physics::World3D::getJointStressTorqueX
float getJointStressTorqueX(int index) const
Constraint torque X of a stress event.

eve::physics::World3D::getContactPointOtherShapeTag
int getContactPointOtherShapeTag(int index) const
Other Shape Tag of a contact point.

eve::physics::World3D::getShapeCount
int getShapeCount() const
Current backend shape count.

eve::physics::World3D::getRayHitShapeId
int getRayHitShapeId() const
Stable shape id from the last ray cast, or -1.
Definition World3D.h:517

eve::physics::World3D::getHitPointY
float getHitPointY(int index) const
World-space impact point Y.

eve::physics::World3D::getRayResultBodyId
int getRayResultBodyId(int index) const
Body ID of a sorted ray result.

eve::physics::World3D::getRayResultMaterialId
int getRayResultMaterialId(int index) const
Surface material ID at a sorted ray intersection.

eve::physics::World3D::getContactPointNormalZ
float getContactPointNormalZ(int index) const
Contact normal Z from queried body toward the other body.

eve::physics::World3D::getMoverGroundDot
float getMoverGroundDot() const
Largest dot product between mover up and a contact normal.
Definition World3D.h:771

eve::physics::World3D::isMoverGrounded
bool isMoverGrounded() const
True when the last move touched a walkable plane.
Definition World3D.h:769

eve::physics::World3D::getRayResultZ
float getRayResultZ(int index) const
World-space hit point Z of a sorted ray result.

eve::physics::action_adapter::ActionCollisionIgnoreState
Owns temporary body-pair collision overrides projected from Action windows.
Definition ActionCollisionIgnoreState.h:47

eve::physics
Optional physics backend for vehicle mobility and body attach.
Definition Climbing.h:36

eve::physics::SimulationBackendKind
SimulationBackendKind
Kind of implementation that owns a simulation step.
Definition SimulationBackend.h:32

eve::physics::SimulationDeterminism
SimulationDeterminism
Determinism guarantee made by a simulation backend.
Definition SimulationBackend.h:64

eve::physics::registerCameraObstructionWorld
void registerCameraObstructionWorld(World3D *world)
Registers camera obstruction world.
Definition PhysicsCapabilities.cpp:177

eve::physics::ClothProbeStatus
ClothProbeStatus
Named outcome for a filtered cloth particle probe.
Definition World3D.h:57

eve::physics::ClothProbeStatus::Miss
@ Miss

eve::physics::ClothProbeStatus::Hit
@ Hit

eve
Build metadata (engine git commit, build time, third-party version).
Definition Build.cpp:16

eve::SnapshotHashProvider
std::function< Result< ContentId >(std::string_view canonicalInput)> SnapshotHashProvider
Injected content-digest implementation used by snapshots.
Definition Snapshot.h:36

enabled
bool enabled
Definition Settlement.cpp:31

eve::SimulationStep
One deterministic fixed-step emitted by SimulationClock.
Definition Time.h:158

eve::SnapshotEnvelope
Stable outer format shared by persistence and cross-process snapshots.
Definition Snapshot.h:46

eve::physics::CameraSphereHit3D
CameraSphereHit3D public API.
Definition World3D.h:33

eve::physics::CameraSphereHit3D::x
float x
Definition World3D.h:37

eve::physics::CameraSphereHit3D::nx
float nx
Definition World3D.h:38

eve::physics::CameraSphereHit3D::bodyId
int bodyId
Definition World3D.h:35

eve::physics::CameraSphereHit3D::fraction
float fraction
Definition World3D.h:36

eve::physics::CameraSphereHit3D::z
float z
Definition World3D.h:37

eve::physics::CameraSphereHit3D::ny
float ny
Definition World3D.h:38

eve::physics::CameraSphereHit3D::hit
bool hit
Definition World3D.h:34

eve::physics::CameraSphereHit3D::nz
float nz
Definition World3D.h:38

eve::physics::CameraSphereHit3D::y
float y
Definition World3D.h:37

eve::physics::CapsuleMovePolicy3D
Per-call capsule mover classification policy; never mutates persistent World3D settings.
Definition OwnedQuery3D.h:30

eve::physics::ClothContact3D
Result of a 3D point probe: deepest non-sensor shape within radius. Normal points from the shape towa...
Definition World3D.h:45

eve::physics::ClothContact3D::nz
float nz
Definition World3D.h:49

eve::physics::ClothContact3D::nx
float nx
Definition World3D.h:47

eve::physics::ClothContact3D::ny
float ny
Definition World3D.h:48

eve::physics::ClothContact3D::depth
float depth
Definition World3D.h:50

eve::physics::ClothContact3D::friction
float friction
Definition World3D.h:52

eve::physics::ClothContact3D::hit
bool hit
Definition World3D.h:46

eve::physics::ClothContact3D::restitution
float restitution
Definition World3D.h:53

eve::physics::ClothContact3D::body
Body3D * body
Definition World3D.h:51

eve::physics::QueryFilter3D
Query filter applied atomically for one owning query operation.
Definition OwnedQuery3D.h:22

eve::physics::SimulationObservation
Observable backend progress shared by CPU and accelerator providers.
Definition SimulationBackend.h:136

eve::physics::SimulationSettings
Validated solver policy for one simulation step.
Definition SimulationBackend.h:120

eve::physics::World3D::ContactEvent
Begin/end event for two non-sensor shapes.
Definition World3D.h:73

eve::physics::World3D::ContactEvent::shapeB
EventShape shapeB
Definition World3D.h:75

eve::physics::World3D::ContactEvent::shapeA
EventShape shapeA
Definition World3D.h:74

eve::physics::World3D::EventShape
Stable snapshot describing one side of a 3D collision event.
Definition World3D.h:66

eve::physics::World3D::HitEvent
Significant collision containing world-space feedback data.
Definition World3D.h:85

eve::physics::World3D::HitEvent::shapeA
EventShape shapeA
Definition World3D.h:86

eve::physics::World3D::HitEvent::shapeB
EventShape shapeB
Definition World3D.h:87

eve::physics::World3D::JointStressEvent
Joint whose solver force or torque exceeded a configured threshold.
Definition World3D.h:94

eve::physics::World3D::TriggerEvent
Begin/end overlap event with an explicit sensor and visitor side.
Definition World3D.h:79

eve::physics::World3D::TriggerEvent::visitor
EventShape visitor
Definition World3D.h:81

eve::physics::World3D::TriggerEvent::sensor
EventShape sensor
Definition World3D.h:80

eve::physics::WorldSnapshotAccess
Definition WorldSnapshot.cpp:29