GeometryCollectionInstance.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include "common/Result.h"
#include "common/Time.h"
#include "physics/PhysicsLink.h"
#include "physics/destruction/DestructionField.h"
#include "physics/destruction/GeometryCollectionAsset.h"
#include "physics/destruction/GeometryCollectionSnapshot.h"
 
#include <cstdint>
#include <memory>
#include <vector>
 
namespace eve::physics {
 
class World3D;
 
enum class BoneRuntimeState : std::uint8_t {
    Attached = 0,
    Detached = 1,
    Sleeping = 2,
};
 
struct EVENGINE_API_DOMAINS BoneDetachEvent {
    int boneA = -1;
    int boneB = -1;
    std::int64_t tick = 0;
};
 
struct EVENGINE_API_DOMAINS ClusterBreakEvent {
    int clusterA = -1;
    int clusterB = -1;
    int boneA = -1;
    int boneB = -1;
    std::int64_t tick = 0;
};
 
struct EVENGINE_API_DOMAINS DestructionStepBudget {
    int maxEdgeBreaksPerStep = 0;
    int maxSleepsPerStep = 0;
};
 
struct EVENGINE_API_DOMAINS DestructionStepReceipt {
    int edgesBroken = 0;
    int edgesDeferred = 0;
    int clusterBreaks = 0;
};
 
struct EVENGINE_API_DOMAINS BonePresentation {
    BoneRuntimeState state = BoneRuntimeState::Attached;
    float halfExtentX = 0.5f;
    float halfExtentY = 0.5f;
    float halfExtentZ = 0.5f;
    float worldX = 0.f;
    float worldY = 0.f;
    float worldZ = 0.f;
    float rotX = 0.f;
    float rotY = 0.f;
    float rotZ = 0.f;
    float rotW = 1.f;
    int clusterId = 0;
    int fractureLevel = 0;
};
 
class EVENGINE_API_DOMAINS GeometryCollectionInstance {
public:
    GeometryCollectionInstance(const GeometryCollectionInstance&)            = delete;
    GeometryCollectionInstance& operator=(const GeometryCollectionInstance&) = delete;
    ~GeometryCollectionInstance();
 
    [[nodiscard("check geometry-collection instantiation")]]
    static eve::Result<std::unique_ptr<GeometryCollectionInstance>> create(World3D& world,
                                                                            const GeometryCollectionAsset& asset,
                                                                            float originX, float originY,
                                                                            float originZ);
 
    [[nodiscard]] bool hasLiveWorld() const noexcept;
 
    void setStepBudget(DestructionStepBudget budget) noexcept { budget_ = budget; }
    [[nodiscard]] DestructionStepBudget stepBudget() const noexcept { return budget_; }
 
    [[nodiscard("check field application")]]
    eve::Result<FieldApplicationReceipt> applyField(const DestructionField& field);
 
    [[nodiscard("check geometry-collection step")]] eve::Result<DestructionStepReceipt> step(SimulationStep step);
 
    [[nodiscard]] int boneCount() const noexcept { return static_cast<int>(bones_.size()); }
    [[nodiscard]] int edgeCount() const noexcept { return static_cast<int>(edges_.size()); }
    [[nodiscard]] BoneRuntimeState boneState(int boneIndex) const;
    [[nodiscard]] int boneClusterId(int boneIndex) const;
    [[nodiscard]] float edgeStrain(int edgeIndex) const;
    [[nodiscard]] bool isEdgeBroken(int edgeIndex) const;
    [[nodiscard]] int detachEventCount() const noexcept { return static_cast<int>(detachEvents_.size()); }
    [[nodiscard]] BoneDetachEvent detachEventAt(int index) const;
    [[nodiscard]] int clusterBreakEventCount() const noexcept {
        return static_cast<int>(clusterBreakEvents_.size());
    }
    [[nodiscard]] ClusterBreakEvent clusterBreakEventAt(int index) const;
    [[nodiscard]] int pendingEdgeBreakCount() const noexcept { return static_cast<int>(pendingEdgeBreaks_.size()); }
 
    [[nodiscard("check bone physics-link resolution")]] eve::Result<PhysicsLink> boneLink(int boneIndex) const;
 
    [[nodiscard("check bone presentation sampling")]]
    eve::Result<BonePresentation> bonePresentation(int boneIndex) const;
 
    [[nodiscard]] std::uint64_t sleepBatchRevision() const noexcept { return sleepBatchRevision_; }
 
    [[nodiscard("check geometry-collection snapshot capture")]]
    eve::Result<GeometryCollectionInstanceSnapshot> captureSnapshot() const;
 
    [[nodiscard("check geometry-collection snapshot restore")]]
    eve::Result<void> restoreSnapshot(const GeometryCollectionInstanceSnapshot& snapshot);
 
    void releaseBodies();
 
private:
    struct BoneRuntime {
        BoneRuntimeState state = BoneRuntimeState::Attached;
        bool             anchored = false;
        PhysicsLink      link;
        float            halfExtentX = 0.5f;
        float            halfExtentY = 0.5f;
        float            halfExtentZ = 0.5f;
        int              clusterId = 0;
        int              fractureLevel = 0;
    };
    struct EdgeRuntime {
        int   boneA = 0;
        int   boneB = 0;
        float strainThreshold = 1.f;
        float accumulatedStrain = 0.f;
        bool  broken = false;
    };
 
    GeometryCollectionInstance(PhysicsWorldHandle worldHandle, float originX, float originY, float originZ);
 
    [[nodiscard]] World3D* resolveWorld() const noexcept;
    [[nodiscard]] eve::Result<Body3D*> resolveBoneBody(int boneIndex) const;
    [[nodiscard]] float falloffAt(const DestructionField& field, float x, float y, float z) const;
    void breakEdge(int edgeIndex, std::uint64_t tick, DestructionStepReceipt& receipt);
    void syncBoneActivationFromGraph();
    void destroyOwnedBodies(World3D& world);
 
    PhysicsWorldHandle worldHandle_ = PhysicsWorldHandle::invalid();
    float originX_ = 0.f;
    float originY_ = 0.f;
    float originZ_ = 0.f;
    std::uint64_t lastTick_ = 0;
    std::uint64_t sleepBatchRevision_ = 0;
    bool orphanedPhysics_ = false;
    DestructionStepBudget budget_{};
    std::vector<BoneRuntime> bones_;
    std::vector<EdgeRuntime> edges_;
    std::vector<BoneDetachEvent> detachEvents_;
    std::vector<ClusterBreakEvent> clusterBreakEvents_;
    std::vector<int> pendingEdgeBreaks_;
};
 
}  // namespace eve::physics