TrajectoryCollision.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include "common/AttachmentPoint.h"
#include "common/Result.h"
#include "common/SubjectRef.h"
#include "common/Time.h"
#include "physics/OwnedQuery3D.h"
#include "physics/PhysicsHandles.h"
#include "physics/trajectory/BoneCollider.h"
 
#include <cstdint>
#include <map>
#include <memory>
#include <string>
#include <string_view>
#include <tuple>
#include <vector>
 
namespace eve {
class IAttachmentPointSource;
}
 
namespace eve::physics {
class World3D;
}
 
namespace eve::physics::trajectory {
 
struct TrajectorySample {
    AttachmentPoint start{};
    AttachmentPoint end{};
    bool            valid = false;
};
 
struct EVENGINE_API_DOMAINS TrajectoryHit {
    SubjectRef         subject;
    std::string        colliderId;
    PhysicsWorldHandle world  = PhysicsWorldHandle::invalid();
    PhysicsBodyHandle  body   = PhysicsBodyHandle::invalid();
    PhysicsShapeHandle shape  = PhysicsShapeHandle::invalid();
    int                bodyId = -1;
    int                shapeId = -1;
    int                shapeTag = 0;
    int                materialId = 0;
    float              x = 0.f, y = 0.f, z = 0.f;
    float              normalX = 0.f, normalY = 0.f, normalZ = 0.f;
    float              fraction = 1.f;
};
 
struct EVENGINE_API_DOMAINS TrajectoryFrame {
    SimulationTick             tick = SimulationTick::zero();
    std::vector<TrajectoryHit> hits;
};
 
class EVENGINE_API_DOMAINS TrajectoryCollisionRuntime {
public:
    explicit TrajectoryCollisionRuntime(World3D& world);
    ~TrajectoryCollisionRuntime();
 
    TrajectoryCollisionRuntime(const TrajectoryCollisionRuntime&)            = delete;
    TrajectoryCollisionRuntime& operator=(const TrajectoryCollisionRuntime&) = delete;
 
    [[nodiscard]] Result<void> registerCollider(BoneColliderDefinition definition);
    [[nodiscard]] Result<void> unregisterCollider(std::string_view colliderId);
 
    [[nodiscard]] Result<void> bindPoseSource(SubjectRef subject, IAttachmentPointSource& source);
    [[nodiscard]] Result<void> clearPoseSource(SubjectRef subject);
 
    [[nodiscard]] Result<void> arm(SubjectRef subject, std::string_view colliderId);
    [[nodiscard]] Result<void> disarm(SubjectRef subject, std::string_view colliderId);
 
    [[nodiscard]] Result<TrajectoryFrame> advance(SimulationTick tick);
 
    [[nodiscard]] Result<TrajectorySample> sampleArmed(SubjectRef subject,
                                                       std::string_view colliderId) const;
 
    [[nodiscard]] std::size_t colliderCount() const noexcept { return colliders_.size(); }
    [[nodiscard]] std::size_t armedCount() const noexcept { return armed_.size(); }
    [[nodiscard]] std::size_t poseSourceCount() const noexcept { return poses_.size(); }
 
private:
    struct ArmedCollider {
        SubjectRef        subject;
        std::string       colliderId;
        TrajectorySample  previous{};
        TrajectorySample  current{};
        bool              hasSample = false;
    };
    using ArmedKey     = std::tuple<std::string, std::string>;
    using HitMemoryKey = std::tuple<std::string, std::string, int, int>;
 
    [[nodiscard]] World3D* liveWorld() const noexcept;
    [[nodiscard]] Result<TrajectorySample> sampleCollider(SubjectRef subject,
                                                          const BoneColliderDefinition& def) const;
    [[nodiscard]] Result<void> sweepArmed(World3D& world, ArmedCollider& armed,
                                          const BoneColliderDefinition& def,
                                          std::vector<TrajectoryHit>& outHits);
 
    World3D*                      world_       = nullptr;
    std::weak_ptr<const void>     worldLifetime_;
    PhysicsWorldHandle            worldHandle_ = PhysicsWorldHandle::invalid();
    std::map<std::string, BoneColliderDefinition, std::less<>> colliders_;
    std::map<std::string, IAttachmentPointSource*, std::less<>> poses_;
    std::map<ArmedKey, ArmedCollider>                           armed_;
    std::map<HitMemoryKey, bool>                                hitMemory_;
    SimulationTick                                              lastTick_ = SimulationTick::zero();
};
 
}  // namespace eve::physics::trajectory