Rail.hh

#pragma once
 
#include "game/system/map/MapdataPointInfo.hh"
 
namespace Kinoko::Field {
 
struct RailLineTransition {
    f32 m_length;
    f32 m_lengthInv;
    EGG::Vector3f m_dir;
};
 
struct RailSplineTransition {
    EGG::Vector3f m_p0;
    EGG::Vector3f m_p1;
    EGG::Vector3f m_p2;
    EGG::Vector3f m_p3;
    f32 m_length;
    f32 m_lengthInv;
};
 
class Rail {
public:
    Rail(u16 idx, System::MapdataPointInfo *info);
    virtual ~Rail();
 
    virtual f32 getPathLength() const = 0;
    virtual std::span<const RailLineTransition> getLinearTransitions() const = 0;
    virtual std::span<const RailSplineTransition> getSplineTransitions() const = 0;
    virtual std::span<const f32> getPathPercentages() const = 0;
 
    void addPoint(f32 scale, const EGG::Vector3f &point);
    void checkSphereFull();
 
    [[nodiscard]] u16 pointCount() const {
        return m_pointCount;
    }
 
    [[nodiscard]] bool isOscillating() const {
        return m_isOscillating;
    }
 
    [[nodiscard]] std::span<const System::MapdataPointInfo::Point> points() const {
        return m_points.view();
    }

    [[nodiscard]] const EGG::Vector3f &pointPos(u16 idx) const {
        ASSERT(idx < m_pointCount);
        return m_points[idx].pos;
    }
 
    [[nodiscard]] const EGG::Vector3f &floorNrm(u16 idx) const {
        ASSERT(!m_floorNrms.empty() && idx < m_floorNrms.size());
        return m_floorNrms[idx];
    }
 
protected:
    virtual void onPointsChanged() = 0;
    virtual void onPointAdded() = 0;
 
    u16 m_pointCount;
    bool m_isOscillating;
    owning_span<System::MapdataPointInfo::Point> m_points;
    f32 m_someScale;
 
private:
    u16 m_idx;
    u16 m_pointCapacity;
    bool m_hasCheckedCol;
    owning_span<EGG::Vector3f> m_floorNrms;
};
 
class RailLine : public Rail {
public:
    RailLine(u16 idx, System::MapdataPointInfo *info);
    ~RailLine() override;

    [[nodiscard]] std::span<const f32> getPathPercentages() const override {
        static owning_span<f32> EMPTY_PERCENTAGES;
        return EMPTY_PERCENTAGES.view();
    }
 
private:
    [[nodiscard]] f32 getPathLength() const override {
        return m_pathLength;
    }

    [[nodiscard]] std::span<const RailLineTransition> getLinearTransitions() const override {
        return m_transitions.view();
    }

    [[nodiscard]] std::span<const RailSplineTransition> getSplineTransitions() const override {
        static owning_span<RailSplineTransition> EMPTY_TRANSITIONS;
        return EMPTY_TRANSITIONS.view();
    }
 
    void onPointsChanged() override {}
    void onPointAdded() override {}
 
    u16 m_dirCount;
    owning_span<RailLineTransition> m_transitions;
    f32 m_pathLength;
};
 
class RailSpline : public Rail {
public:
    RailSpline(u16 idx, System::MapdataPointInfo *info);
    ~RailSpline() override;

    [[nodiscard]] std::span<const f32> getPathPercentages() const override {
        return m_pathPercentages.view();
    }
 
    [[nodiscard]] static consteval u32 getEstimatorSampleCount() {
        return ESTIMATOR_SAMPLE_COUNT;
    }

    [[nodiscard]] static consteval f32 getEstimatorStep() {
        return ESTIMATOR_STEP;
    }
 
private:
    [[nodiscard]] f32 getPathLength() const override {
        return m_pathLength;
    }

    [[nodiscard]] std::span<const RailLineTransition> getLinearTransitions() const override {
        static owning_span<RailLineTransition> EMPTY_TRANSITIONS;
        return EMPTY_TRANSITIONS.view();
    }

    [[nodiscard]] std::span<const RailSplineTransition> getSplineTransitions() const override {
        return m_transitions.view();
    }
 
    void onPointsChanged() override;
    void onPointAdded() override;
 
    void invalidateTransitions(bool lastOnly);
    void calcCubicBezierControlPoints(const EGG::Vector3f &p0, const EGG::Vector3f &p1,
            const EGG::Vector3f &p2, const EGG::Vector3f &p3, s32 count,
            RailSplineTransition &transition);
    [[nodiscard]] f32 estimateLength(const RailSplineTransition &transition, s32 count);
    [[nodiscard]] EGG::Vector3f calcCubicBezierP1(const EGG::Vector3f &p0, const EGG::Vector3f &p1,
            const EGG::Vector3f &p2) const;
    [[nodiscard]] EGG::Vector3f calcCubicBezierP2(const EGG::Vector3f &p0, const EGG::Vector3f &p1,
            const EGG::Vector3f &p2) const;
    [[nodiscard]] EGG::Vector3f cubicBezier(f32 t, const RailSplineTransition &transition) const;
 
    u16 m_transitionCount;
    owning_span<RailSplineTransition> m_transitions;
    owning_span<f32> m_pathPercentages;
    s32 m_segmentCount;
    f32 m_pathLength;
    bool m_doNotAllocatePathPercentages;
 
    static constexpr u32 ESTIMATOR_SAMPLE_COUNT = 10;
    static constexpr f32 ESTIMATOR_STEP = 1.0f / static_cast<f32>(ESTIMATOR_SAMPLE_COUNT);
};
 
} // namespace Kinoko::Field