helix-selector.hh

Go to the documentation of this file.

/*
 
MIT License
 
Copyright (c) 2026 PCSX-Redux authors
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
 
*/
 
#pragma once
 
#include <EASTL/functional.h>
#include <stdint.h>
 
#include "psyqo/fixed-point.hh"
#include "psyqo/primitives/common.hh"
#include "psyqo/trigonometry.hh"
 
namespace psyqo {
 
class HelixSelector {
  public:
    struct Event {
        enum Type { SelectionChanged, Activated } type;
        unsigned index;
    };
 
    struct Slot {
        unsigned index;
        Vertex a, b, c, d;
        Vertex glyph;
        FixedPoint<> scale;
        FixedPoint<> fade;
    };
 
    struct Cursor {
        Vertex tip, left, right;
    };
 
    struct Config {
        Vertex center = {{.x = 160, .y = 120}};
        FixedPoint<> innerRadius = 44.0;  // cylinder radii, before projection
        FixedPoint<> outerRadius = 68.0;
        FixedPoint<> cameraDistance = 128.0;  // h in the r = R * h / z divide
        FixedPoint<> cursorZ = 150.0;         // z of the item under the cursor
        FixedPoint<> pitch = 10.0;            // z travelled per item
        FixedPoint<> gap = 0.88;              // fraction of the angular step drawn
        FixedPoint<> settleRate = 0.3;        // per frame, toward the target
        unsigned itemsPerTurn = 20;
        // How much helix is on screen, in items. Since spokes are fixed, these do
        // not decide WHETHER two quads share an angle - `i` and `i + itemsPerTurn`
        // always do - they decide how many LAPS of that are visible either side of
        // the cursor. `(nearSpan + farSpan + 1) / itemsPerTurn` turns, roughly.
        unsigned nearSpan = 13;           // items emitted toward the camera
        unsigned farSpan = 13;            // items emitted away from it
        unsigned fadeItems = 5;           // far-end fade ramp, in items
        FixedPoint<> cursorGap = 5.0;     // from the inner ring to the marker's tip
        FixedPoint<> cursorLength = 9.0;  // tip to base, along the spoke
        FixedPoint<> cursorHalfWidth = 5.0;
    };
 
    static constexpr unsigned c_maxSlots = 48;
 
    void setup(unsigned itemCount, const Config& config);
 
    void setOnEvent(eastl::function<void(Event)>&& callback) { m_callback = eastl::move(callback); }
 
    void setStickAngle(Angle a);
 
    void step(int32_t items) { m_target += FixedPoint<>(items, int32_t(0)); }
 
    void activate();
 
    void update(const Trig<>& trig);
 
    unsigned currentIndex() const { return m_selected; }
    unsigned visibleCount() const { return m_slotCount; }
    const Slot& slot(unsigned n) const { return m_slots[n]; }
    const Cursor& cursor() const { return m_cursor; }
    Angle cursorAngle() const { return m_cursorAngle; }
 
  private:
    // Slide BOTH by whole laps together, so their difference (which is what the
    // settle animation rides on) is untouched and neither can drift out of range
    // after a few million frames of cranking.
    void normalize();
 
    unsigned wrap(int32_t i) const;
 
    unsigned resolve() const {
        FixedPoint<> half(int32_t(0), int32_t(FixedPoint<>::scale / 2));
        return wrap((m_position + half).integer<int32_t>());
    }
 
    void emit(Event e) {
        if (m_callback) m_callback(e);
    }
 
    void build(const Trig<>& trig);
 
    FixedPoint<> fadeFor(FixedPoint<> d) const;
 
    static Vertex vtx(FixedPoint<> x, FixedPoint<> y) {
        return Vertex{{.x = int16_t(x.integer<int32_t>()), .y = int16_t(y.integer<int32_t>())}};
    }
 
    Vertex at(FixedPoint<> r, FixedPoint<> cosT, FixedPoint<> sinT) const {
        int16_t x = int16_t(m_config.center.x + (r * cosT).integer<int32_t>());
        int16_t y = int16_t(m_config.center.y + (r * sinT).integer<int32_t>());
        return Vertex{{.x = x, .y = y}};
    }
 
    Config m_config;
    eastl::function<void(Event)> m_callback = nullptr;
    Angle m_cursorAngle;
    FixedPoint<> m_angleStep;
    FixedPoint<> m_position;
    FixedPoint<> m_target;
    Cursor m_cursor = {};
    Slot m_slots[c_maxSlots];
    unsigned m_slotCount = 0;
    unsigned m_itemCount = 0;
    unsigned m_selected = 0;
};
 
}  // namespace psyqo