World.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Snapshot.h"
#include "common/Result.h"
#include "physics/PhysicsHandles.h"
#include "physics/Joint2D.h"
#include "physics/backend/SimulationBackend.h"
 
#include <cstdint>
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
class b2World;
class b2Body;
class b2Fixture;
class b2Joint;
class b2Contact;
struct b2Manifold;
struct b2ContactImpulse;
 
namespace eve::graphics {
class Graphics;
}
 
namespace eve::physics {
 
class Body;
class Fixture;
class ContactRelay;
class Mechanism2D;
 
class EVENGINE_API_WORLD World {
public:
    struct ContactEvent {
        int bodyAId = 0;
        int bodyBId = 0;
        std::string fixtureATag;
        std::string fixtureBTag;
    };
 
    struct ImpactEvent : ContactEvent {
        float pointX = 0.f;
        float pointY = 0.f;
        float normalX = 0.f;
        float normalY = 0.f;
        float relativeNormalSpeed = 0.f;
        float normalImpulse = 0.f;
        float tangentImpulse = 0.f;
    };
 
    struct ClothContact {
        bool   hit = false;
        float  nx = 0.f;
        float  ny = 0.f;
        float  depth = 0.f;  // radius - distance (pixels); > 0 when inside
        Body  *body = nullptr;
    };
 
    World(float gravityX, float gravityY, bool sleep, float meter,
          eve::PersistentId instanceId = eve::PersistentId::nil());
    ~World();
 
    World(const World &)            = delete;
    World &operator=(const World &) = delete;
 
    void update(float dt);
    void updateFull(float dt, int velocityIterations, int positionIterations);
 
    [[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 lifetime_; }
    [[nodiscard]] eve::PersistentId persistentId() const noexcept { return instanceId_; }
    [[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 getGravityX() const;
    float getGravityY() const;
 
    void  setMeter(float pixelsPerMeter);
    float getMeter() const { return meter_; }
 
    Body *newBody(const std::string &bodyType, float x, float y);
    [[nodiscard]] Body *findBody(PhysicsBodyHandle handle) const;
    [[nodiscard]] Body *findBodyById(int bodyId) const;
    [[nodiscard]] Joint2D *findJoint(PhysicsJointHandle handle) const;
 
    Joint2D *newDistanceJoint(Body *bodyA, Body *bodyB, float anchorAX, float anchorAY,
                              float anchorBX, float anchorBY, float lengthPixels,
                              bool collideConnected = false);
    Joint2D *newRevoluteJoint(Body *bodyA, Body *bodyB, float anchorX, float anchorY,
                              bool collideConnected = false);
    Joint2D *newPrismaticJoint(Body *bodyA, Body *bodyB, float anchorX, float anchorY, float axisX,
                               float axisY, bool collideConnected = false);
    Joint2D *newWeldJoint(Body *bodyA, Body *bodyB, float anchorX, float anchorY,
                          bool collideConnected = false);
    Joint2D *newWheelJoint(Body *bodyA, Body *bodyB, float anchorX, float anchorY, float axisX,
                           float axisY, bool collideConnected = false);
    Joint2D *newMotorJoint(Body *bodyA, Body *bodyB, bool collideConnected = false);
    Joint2D *newGearJoint(Joint2D *joint1, Joint2D *joint2, float ratio);
 
    Mechanism2D *newShaft(Body *support, Body *rotor, float anchorX, float anchorY,
                          bool collideConnected = false);
    Mechanism2D *newRatchet(Body *frame, Body *wheel, float anchorX, float anchorY, int direction,
                            float engagementTorque, bool collideConnected = false);
    Mechanism2D *newCrankSlider(Body *frame, Body *crank, Body *rod, Body *slider,
                                float crankAnchorX, float crankAnchorY, float crankPinX,
                                float crankPinY, float sliderPinX, float sliderPinY,
                                float slideAxisX, float slideAxisY, bool collideConnected = false);
 
    void destroyBody(Body *body);
    void destroy();
 
    bool isValid() const { return !destroyed_ && world_ != nullptr; }
 
    bool pointProbe(float x, float y, float radius, ClothContact *out) const;
 
    void drawDebug(graphics::Graphics *gfx);
 
    int rayCast(float x1, float y1, float x2, float y2);
    bool  hasRayHit() const { return rayHitBodyId_ >= 0; }
    int   getRayHitBodyId() const { return rayHitBodyId_; }
    float getRayHitX() const { return rayHitX_; }
    float getRayHitY() const { return rayHitY_; }
    float getRayHitNormalX() const { return rayHitNormalX_; }
    float getRayHitNormalY() const { return rayHitNormalY_; }
    float getRayHitFraction() const { return rayHitFraction_; }
 
    int queryAABB(float x, float y, float w, float h);
    int getQueryCount() const { return static_cast<int>(queryBodyIds_.size()); }
    int getQueryBodyId(int index) const;
 
    int getBeginContactCount() const { return int(beginContacts_.size()); }
    int getBeginContactBodyAId(int index) const;
    int getBeginContactBodyBId(int index) const;
    std::string getBeginContactFixtureATag(int index) const;
    std::string getBeginContactFixtureBTag(int index) const;
    int getEndContactCount() const { return int(endContacts_.size()); }
    int getEndContactBodyAId(int index) const;
    int getEndContactBodyBId(int index) const;
    std::string getEndContactFixtureATag(int index) const;
    std::string getEndContactFixtureBTag(int index) const;
 
    int getImpactCount() const { return int(impacts_.size()); }
    int getImpactBodyAId(int index) const;
    int getImpactBodyBId(int index) const;
    std::string getImpactFixtureATag(int index) const;
    std::string getImpactFixtureBTag(int index) const;
    float getImpactPointX(int index) const;
    float getImpactPointY(int index) const;
    float getImpactNormalX(int index) const;
    float getImpactNormalY(int index) const;
    float getImpactRelativeNormalSpeed(int index) const;
    float getImpactNormalImpulse(int index) const;
    float getImpactTangentImpulse(int index) const;
    void clearContactEvents();
 
    float toMeters(float pixels) const;
    float toPixels(float meters) const;
 
    b2World *raw() { return world_; }
    const b2World *raw() const { return world_; }
 
    void onBeginContact(b2Contact *contact);
    void onEndContact(b2Contact *contact);
    void onPreSolve(b2Contact *contact, const b2Manifold *oldManifold);
    void onPostSolve(b2Contact *contact, const b2ContactImpulse *impulse);
 
    void forgetBody(Body *body);
    void forgetFixture(Fixture *fixture);
    void forgetJoint(Joint2D *joint);
    void forgetMechanism(Mechanism2D *mechanism);
 
    int nextBodyId();
    PhysicsBodyHandle nextBodyRuntimeHandle();
    PhysicsJointHandle nextJointRuntimeHandle();
    int nextJointId();
    int nextMechanismId();
 
private:
    friend struct WorldSnapshotAccess;
    friend class Body;
    friend class Fixture;
    friend class Joint2D;
    friend class Mechanism2D;
 
    Joint2D *adoptJoint(Body *bodyA, Body *bodyB, b2Joint *raw, Joint2D::Kind kind);
 
    b2World      *world_ = nullptr;
    ContactRelay *relay_ = nullptr;
    std::unique_ptr<ISimulationBackend> simulation_;
    PhysicsWorldHandle                  runtimeHandle_          = PhysicsWorldHandle::invalid();
    std::shared_ptr<const void>         lifetime_               = std::make_shared<int>(0);
    eve::PersistentId                   instanceId_             = eve::PersistentId::nil();
    float         meter_ = 30.f;
    int           nextId_ = 1;
    int           nextJointId_ = 1;
    int           nextMechanismId_ = 1;
    std::uint32_t                       nextBodyHandleIndex_    = 1u;
    std::uint32_t                       nextJointHandleIndex_   = 1u;
    bool          destroyed_ = false;
    eve::SimulationTick                 simulationTick_         = eve::SimulationTick::zero();
    eve::Status                         backendSelectionStatus_ = eve::Status::success();
    bool                                backendFallback_        = false;
 
    std::unordered_set<Body *>    bodies_;
    std::unordered_set<Fixture *> fixtures_;
    std::unordered_set<Joint2D *> joints_;
    std::unordered_set<Mechanism2D *> mechanisms_;
    std::unordered_map<PhysicsJointHandle, Joint2D *> jointHandles_;
 
    int   rayHitBodyId_   = -1;
    float rayHitX_        = 0.f;
    float rayHitY_        = 0.f;
    float rayHitNormalX_  = 0.f;
    float rayHitNormalY_  = 0.f;
    float rayHitFraction_ = 0.f;
 
    std::vector<int> queryBodyIds_;
 
    struct PreSolveData {
        float pointX = 0.f;
        float pointY = 0.f;
        float normalX = 0.f;
        float normalY = 0.f;
        float relativeNormalSpeed = 0.f;
    };
    std::unordered_map<b2Contact *, PreSolveData> preSolve_;
    std::vector<ContactEvent> beginContacts_;
    std::vector<ContactEvent> endContacts_;
    std::vector<ImpactEvent> impacts_;
 
    [[nodiscard]] eve::Result<void> prepareRuntimeHandleRefresh() const;
    void refreshRuntimeHandlesAfterRestore();
    void adoptPreparedTopology(World &prepared);
};
 
}  // namespace eve::physics