SplinePath.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
 
#include <cstdint>
#include <string_view>
#include <utility>
#include <vector>
 
namespace eve::procgen {
 
struct SplinePoint {
    float x = 0.f, y = 0.f, z = 0.f;
    float inX = 0.f, inY = 0.f, inZ = 0.f;
    float outX = 0.f, outY = 0.f, outZ = 0.f;
    float rollDegrees = 0.f;
    float scaleX = 1.f, scaleY = 1.f;
    bool  breakBefore  = false;
    float pitchDegrees = 0.f, yawDegrees = 0.f;
};
 
struct SplineSample {
    float x = 0.f, y = 0.f, z = 0.f;
    float tangentX = 1.f, tangentY = 0.f, tangentZ = 0.f;
    float normalizedDistance = 0.f;
    float rollDegrees        = 0.f;
    float scaleX = 1.f, scaleY = 1.f;
    int   chunkIndex   = 0;
    float pitchDegrees = 0.f, yawDegrees = 0.f;
};
 
struct SplineFrameSample {
    SplineSample sample;
    float        sideX = 1.f, sideY = 0.f, sideZ = 0.f;
    float        upX = 0.f, upY = 1.f, upZ = 0.f;
    float        forwardX = 0.f, forwardY = 0.f, forwardZ = 1.f;
};
 
class EVENGINE_API_DOMAINS SplineDistribution {
public:
    explicit SplineDistribution(std::vector<SplineFrameSample> frames = {}) : frames_(std::move(frames)) {}
    [[nodiscard]] int count() const noexcept { return static_cast<int>(frames_.size()); }
    [[nodiscard]] Result<SplineSample> sampleResult(int index) const;
    [[nodiscard]] Result<SplineFrameSample> frameResult(int index) const;
 
private:
    std::vector<SplineFrameSample> frames_;
};
 
class EVENGINE_API_DOMAINS SplinePolyline {
public:
    explicit SplinePolyline(std::vector<std::vector<SplineSample>> chunks = {}, bool closed = false)
        : chunks_(std::move(chunks)), closed_(closed) {}
    [[nodiscard]] int count() const noexcept;
    [[nodiscard]] Result<SplineSample> pointResult(int index) const;
    [[nodiscard]] int chunkCount() const noexcept { return static_cast<int>(chunks_.size()); }
    [[nodiscard]] int chunkPointCount(int chunk) const noexcept;
    [[nodiscard]] Result<SplineSample> chunkPointResult(int chunk, int index) const;
    [[nodiscard]] bool isClosed() const noexcept { return closed_; }
 
private:
    std::vector<std::vector<SplineSample>> chunks_;
    bool                                   closed_ = false;
};
 
class EVENGINE_API_DOMAINS SplinePath {
public:
    [[nodiscard]] Result<void> setKindResult(std::string_view kind);
    void setClosed(bool closed);
    [[nodiscard]] Result<void> addPointResult(const SplinePoint& point);
    [[nodiscard]] Result<void> setPointResult(int index, const SplinePoint& point);
    [[nodiscard]] Result<void> setPointProfileResult(int index, float rollDegrees, float scaleX, float scaleY);
    [[nodiscard]] Result<void> setPointRotationResult(int index, float pitchDegrees, float yawDegrees,
                                                      float rollDegrees);
    [[nodiscard]] Result<void> setPointChunkBreakResult(int index, bool disconnected);
    [[nodiscard]] Result<void> removePointResult(int index);
    void clear();
 
    [[nodiscard]] Result<SplineSample> evaluateResult(float t) const;
    [[nodiscard]] Result<SplineSample> evaluateDistanceResult(float distance, int samplesPerSegment = 24) const;
    [[nodiscard]] Result<float> lengthResult(int samplesPerSegment = 24) const;
    [[nodiscard]] Result<SplineSample> closestPointResult(float x, float y, float z, int samplesPerSegment = 32) const;
    [[nodiscard]] Result<std::vector<SplineFrameSample>> sampleFramesResult(int sampleCount, bool uniformByDistance,
                                                                            float rollDegrees       = 0.f,
                                                                            int   samplesPerSegment = 24) const;
    [[nodiscard]] Result<SplineSample> travelResult(float distance, std::string_view wrapMode = "clamp",
                                                    int samplesPerSegment = 24) const;
    [[nodiscard]] Result<SplineFrameSample> travelFrameResult(float distance, std::string_view wrapMode = "clamp",
                                                              int samplesPerSegment = 24) const;
    [[nodiscard]] Result<SplineDistribution> distributeResult(int instanceCount, bool includeEnd = true,
                                                              int samplesPerSegment = 24) const;
    [[nodiscard]] Result<SplinePolyline> polylineResult(int sampleCount = 64, bool uniformByDistance = true,
                                                        int samplesPerSegment = 24) const;
    [[nodiscard]] Result<void> applyShapePresetResult(std::string_view preset, int pointCount, float radius,
                                                      float height, float turns = 1.f);
 
    [[nodiscard]] int pointCount() const noexcept { return static_cast<int>(points_.size()); }
    [[nodiscard]] int segmentCount() const noexcept;
    [[nodiscard]] int chunkCount() const noexcept;
    [[nodiscard]] Result<SplinePath> chunkPathResult(int chunk) const;
    [[nodiscard]] std::string_view kind() const noexcept { return kind_; }
    [[nodiscard]] bool isClosed() const noexcept { return closed_; }
    [[nodiscard]] std::uint64_t revision() const noexcept { return revision_; }
 
private:
    struct ArcEntry {
        int   segment  = 0;
        float u        = 0.f;
        float distance = 0.f;
    };
    [[nodiscard]] Result<void> validateReady() const;
    [[nodiscard]] SplineSample evaluateUnchecked(float t) const;
    [[nodiscard]] SplineSample evaluateSegmentUnchecked(int segment, float u, float normalized) const;
    [[nodiscard]] std::vector<std::pair<int, int>> segmentEndpoints() const;
    [[nodiscard]] Result<void>                     ensureArcTable(int samplesPerSegment) const;
    void                                           invalidate();
 
    std::vector<SplinePoint>      points_;
    std::string                   kind_     = "catmullRom";
    bool                          closed_   = false;
    std::uint64_t                 revision_ = 0;
    mutable std::vector<ArcEntry> arcTable_;
    mutable int                   arcSamplesPerSegment_ = 0;
};
 
}  // namespace eve::procgen