ClimbingAnchorGraph.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "climbing/ClimbingPrimitives.h"
#include "common/Result.h"
#include "common/SquirrelOwnership.h"
#include "common/StrongUint64.h"
#include "common/Value.h"
#include "physics/PhysicsHandles.h"
 
#include <cstddef>
#include <cstdint>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace eve::physics {
class World3D;
}
 
namespace eve::climbing {
 
enum class ClimbingAnchorKind : std::uint8_t { Ledge, CornerInner, CornerOuter, LadderRung, Pole, Beam, Bar };
 
enum class ClimbingAnchorEdgeKind : std::uint8_t {
    Shimmy,
    Corner,
    Jump,
    Drop,
    Mount,
    Dismount,
    Climb,
    Balance,
    Swing
};
 
struct ClimbingAnchorNodeDefinition {
    std::string              id;
    ClimbingAnchorKind       kind = ClimbingAnchorKind::Ledge;
    Vec3                     localPosition;
    Vec3                     localNormal{0.f, 0.f, -1.f};
    Vec3                     localTangent{1.f, 0.f, 0.f};
    Vec3                     leftHandSocket;
    Vec3                     rightHandSocket;
    Vec3                     feetSocket;
    std::uint32_t            occupancySlots = 1;
    std::vector<std::string> tags;
    eve::Value::Object       extensionMetadata;
};
 
struct ClimbingAnchorEdgeDefinition {
    std::string                from;
    std::string                to;
    ClimbingAnchorEdgeKind     kind = ClimbingAnchorEdgeKind::Shimmy;
    bool                       bidirectional = false;
    std::vector<std::string>   requiredTags;
    eve::Value::Object         extensionMetadata;
};
 
struct ClimbingAnchorGraphDefinition {
    static constexpr std::string_view SchemaId = "evengine.climbing-anchor-graph";
    static constexpr std::int64_t SchemaVersion = 2;
 
    std::string                               id;
    std::string                               sourceGeometryContentId;
    std::string                               buildSettingsHash;
    std::vector<ClimbingAnchorNodeDefinition> nodes;
    std::vector<ClimbingAnchorEdgeDefinition> edges;
    eve::Value::Object                        extensionMetadata;
};
 
[[nodiscard]] eve::Result<void> validateClimbingAnchorGraphDefinition(const ClimbingAnchorGraphDefinition& graph);
[[nodiscard]] EVENGINE_API_DOMAINS eve::Result<eve::Value> encodeClimbingAnchorGraphDefinition(
    const ClimbingAnchorGraphDefinition& graph);
[[nodiscard]] EVENGINE_API_DOMAINS eve::Result<ClimbingAnchorGraphDefinition> decodeClimbingAnchorGraphDefinition(
    const eve::Value& value);
 
namespace detail {
struct ClimbingAnchorReservationIdTag {};
struct ClimbingAnchorAgentIdTag {};
}
 
using ClimbingAnchorReservationId = eve::detail::StrongUint64<detail::ClimbingAnchorReservationIdTag>;
using ClimbingAnchorAgentId = eve::detail::StrongUint64<detail::ClimbingAnchorAgentIdTag>;
 
struct ClimbingAnchorOccupant {
    ClimbingAnchorAgentId agentId = ClimbingAnchorAgentId::zero();
    ClimbingExecutionId   executionId = ClimbingExecutionId::zero();
    friend bool operator==(const ClimbingAnchorOccupant&, const ClimbingAnchorOccupant&) noexcept = default;
    friend auto operator<=>(const ClimbingAnchorOccupant&, const ClimbingAnchorOccupant&) noexcept = default;
};
 
struct ClimbingAnchorNodeRef {
    std::string   graphId;
    std::string   nodeId;
    std::uint64_t graphGeneration = 0;
};
 
struct ClimbingAnchorReservation {
    ClimbingAnchorReservationId id = ClimbingAnchorReservationId::zero();
    std::uint64_t               graphGeneration = 0;
    std::uint64_t               claimGeneration = 0;
    std::string                 nodeId;
    std::uint32_t               slot = 0;
    ClimbingAnchorOccupant      occupant;
};
 
enum class ClimbingRouteOccupancyPolicy : std::uint8_t { Ignore, AvoidFull };
 
struct ClimbingAnchorRouteRequest {
    ClimbingAnchorNodeRef          start;
    ClimbingAnchorNodeRef          goal;
    ClimbingRouteOccupancyPolicy   occupancyPolicy = ClimbingRouteOccupancyPolicy::AvoidFull;
    ClimbingAnchorOccupant         requester;
    std::vector<ClimbingAnchorEdgeKind> allowedEdgeKinds;
    std::vector<std::string>            availableTags;
    std::uint32_t                  maxVisitedNodes = 4096;
};
 
struct ClimbingAnchorRouteStep {
    ClimbingAnchorNodeRef      from;
    ClimbingAnchorNodeRef      to;
    ClimbingAnchorEdgeKind     kind = ClimbingAnchorEdgeKind::Shimmy;
};
 
struct ClimbingAnchorRoute {
    std::string                         graphId;
    std::uint64_t                       graphGeneration = 0;
    std::vector<ClimbingAnchorNodeRef>  nodes;
    std::vector<ClimbingAnchorRouteStep> steps;
};
 
struct ResolvedClimbingAnchorNode {
    ClimbingAnchorNodeRef    reference;
    ClimbingAnchorKind       kind = ClimbingAnchorKind::Ledge;
    physics::PhysicsBodyHandle body = physics::PhysicsBodyHandle::invalid();
    Vec3                     position;
    Vec3                     normal;
    Vec3                     tangent;
    Vec3                     leftHandSocket;
    Vec3                     rightHandSocket;
    Vec3                     feetSocket;
    Vec3                     pointVelocity;
    std::vector<std::string> tags;
};
 
struct ClimbingAnchorGraphReload {
    std::uint64_t                    oldGeneration = 0;
    std::uint64_t                    newGeneration = 0;
    std::vector<ClimbingAnchorOccupant> invalidatedOccupants;
};
 
class EVENGINE_API_DOMAINS ClimbingAnchorGraphInstance {
public:
    [[nodiscard]] static eve::Result<ClimbingAnchorGraphInstance> bind(ClimbingAnchorGraphDefinition graph,
                                                                       physics::World3D& world,
                                                                       physics::PhysicsBodyHandle body);
    [[nodiscard]] eve::Result<ClimbingAnchorNodeRef> nodeRef(std::string_view nodeId) const;
    [[nodiscard]] eve::Result<ResolvedClimbingAnchorNode> resolveNode(physics::World3D& world,
                                                                      const ClimbingAnchorNodeRef& reference) const;
    [[nodiscard]] eve::Result<ResolvedClimbingAnchorNode> resolveNodeKinematics(
        physics::World3D& world, const ClimbingAnchorNodeRef& reference) const;
    [[nodiscard]] eve::Result<std::vector<ClimbingAnchorEdgeDefinition>> edgesFrom(
        const ClimbingAnchorNodeRef& reference) const;
    [[nodiscard]] eve::Result<ClimbingAnchorRoute> planRoute(const ClimbingAnchorRouteRequest& request) const;
    [[nodiscard]] eve::Result<ClimbingAnchorReservation> reserve(const ClimbingAnchorNodeRef& reference,
                                                                  ClimbingAnchorOccupant occupant);
    [[nodiscard]] eve::Result<void> validateReservation(const ClimbingAnchorReservation& reservation) const;
    [[nodiscard]] eve::Result<ClimbingAnchorReservation> transferReservation(
        const ClimbingAnchorReservation& reservation);
    [[nodiscard]] eve::Result<ClimbingAnchorReservation> restoreReservation(
        const ClimbingAnchorReservation& reservation);
    [[nodiscard]] eve::Result<void> release(const ClimbingAnchorReservation& reservation);
    [[nodiscard]] eve::Result<std::uint32_t> releaseOccupant(ClimbingAnchorOccupant occupant);
    [[nodiscard]] eve::Result<ClimbingAnchorGraphReload> reload(ClimbingAnchorGraphDefinition graph);
    [[nodiscard]] std::uint64_t generation() const noexcept { return generation_; }
    [[nodiscard]] physics::PhysicsBodyHandle body() const noexcept { return body_; }
    [[nodiscard]] std::size_t reservationCount() const noexcept { return reservations_.size(); }
 
private:
    struct ReservationRecord {
        std::string         nodeId;
        std::uint32_t       slot = 0;
        ClimbingAnchorOccupant occupant;
        std::uint64_t       claimGeneration = 1;
    };
 
    const ClimbingAnchorNodeDefinition* findNode(std::string_view nodeId) const noexcept;
 
    ClimbingAnchorGraphDefinition                                      graph_;
    physics::PhysicsWorldHandle                                        world_ = physics::PhysicsWorldHandle::invalid();
    physics::PhysicsBodyHandle                                         body_ = physics::PhysicsBodyHandle::invalid();
    std::uint64_t                                                      generation_ = 1;
    ClimbingAnchorReservationId                                        nextReservationId_{1};
    std::unordered_map<ClimbingAnchorReservationId, ReservationRecord> reservations_;
};
 
struct ClimbingAnchorGraphHandleTag {};
using ClimbingAnchorGraphHandleRef = eve::script::RuntimeHandleRef<ClimbingAnchorGraphHandleTag>;
 
}  // namespace eve::climbing