ArtifactProvider.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/ArtifactPublication.h"
#include "common/RuntimeHandle.h"
#include "physics/PhysicsHandles.h"
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
namespace eve::physics {
 
class Body3D;
class Shape3D;
class World3D;
 
struct PhysicsArtifactHandleTag {};
using PhysicsArtifactHandle = eve::RuntimeHandle<PhysicsArtifactHandleTag>;
 
struct PhysicsArtifactRayHit {
    bool  hit      = false;
    float fraction = 0.f;
    float x        = 0.f;
    float y        = 0.f;
    float z        = 0.f;
    float normalX  = 0.f;
    float normalY  = 0.f;
    float normalZ  = 0.f;
};
 
struct PhysicsArtifactCollider {
    eve::PersistentId     id;
    std::string           buildKey;
    PhysicsArtifactHandle handle;
    PhysicsWorldHandle    world = PhysicsWorldHandle::invalid();
    std::string           shape;
    std::string                backend = "box3d";
    eve::artifact::Bounds      bounds;
    std::vector<float>         vertices;
    std::vector<std::uint32_t> indices;
};
 
class EVENGINE_API_WORLD PhysicsArtifactProvider final : public eve::artifact::IPhysicsArtifactAdapter {
public:
    PhysicsArtifactProvider();
    ~PhysicsArtifactProvider() override;
 
    [[nodiscard]] eve::Result<std::unique_ptr<eve::artifact::PreparedPublication>> prepare(
        const eve::artifact::PublicationView& publication) override;
    [[nodiscard]] eve::Result<eve::Value> snapshotState() const override;
    [[nodiscard]] eve::Result<void> restoreState(const eve::Value& state) override;
    [[nodiscard]] bool emptyState() const noexcept override;
    void clearState() noexcept override { clear(); }
 
    [[nodiscard]] const PhysicsArtifactCollider* find(eve::PersistentId id) const noexcept;
    [[nodiscard]] const PhysicsArtifactCollider* find(PhysicsArtifactHandle handle) const noexcept;
    [[nodiscard]] bool isHandleLive(PhysicsArtifactHandle handle) const noexcept;
    [[nodiscard]] PhysicsArtifactRayHit rayCast(eve::PersistentId id, float ox, float oy, float oz, float dx, float dy,
                                                float dz) const noexcept;
    [[nodiscard]] std::size_t size() const noexcept;
    [[nodiscard]] std::string backendName(eve::PersistentId id) const;
    [[nodiscard]] bool isBox3DBacked(eve::PersistentId id) const noexcept;
    [[nodiscard]] eve::Result<void> bindWorld(World3D& world);
    [[nodiscard]] eve::Result<void> unbindWorld(PhysicsWorldHandle world);
    [[nodiscard]] PhysicsWorldHandle boundWorld() const noexcept;
    [[nodiscard]] bool isSharedWorldBacked(eve::PersistentId id) const noexcept;
    void clear() noexcept;
    void setPrepareFailure(bool enabled) noexcept { failPrepare_ = enabled; }
 
private:
    struct State;
    friend class PhysicsArtifactStage;
    void commit(PhysicsArtifactCollider collider, std::unique_ptr<World3D> world, std::unique_ptr<Body3D> body,
                std::unique_ptr<Shape3D> shape) noexcept;
    void release(PhysicsArtifactCollider& collider, std::unique_ptr<World3D>& world, std::unique_ptr<Body3D>& body,
                 std::unique_ptr<Shape3D>& shape) noexcept;
    std::unique_ptr<State> state_;
    std::uint32_t          nextIndex_   = 0;
    bool                   failPrepare_ = false;
    World3D*               boundWorld_  = nullptr;
    PhysicsWorldHandle     boundWorldHandle_ = PhysicsWorldHandle::invalid();
    std::weak_ptr<const void> boundWorldLifetime_;
    std::shared_ptr<const void> providerLifetime_ = std::make_shared<int>(0);
};
 
[[nodiscard]] EVENGINE_API_WORLD PhysicsArtifactProvider& physicsArtifactProvider() noexcept;
EVENGINE_API_WORLD void registerPhysicsArtifactProvider();
 
}  // namespace eve::physics