rainfall.h

/*
 * Copyright © 2026 Synthstrom Audible Limited
 *
 * This file is part of The Synthstrom Audible Deluge Firmware.
 *
 * The Synthstrom Audible Deluge Firmware is free software: you can redistribute it and/or modify it under the
 * terms of the GNU General Public License as published by the Free Software Foundation,
 * either version 3 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
 
namespace deluge::hid::display {

class Rainfall {
public:
    static constexpr int32_t kWidth = 128;
    static constexpr int32_t kHeight = 48;
    static constexpr int32_t kTopmost = 5;
    static constexpr int32_t kVisibleHeight = kHeight - kTopmost;


    static constexpr size_t kNumDrops = 34;
    static constexpr float kSpeedFar = 0.5f;
    static constexpr float kSpeedNear = 1.5f;

    static constexpr float kSpeedStep = 0.25f;

    static constexpr float kSpawnFromTop = static_cast<float>(kWidth) / static_cast<float>(kWidth + kVisibleHeight);

    static constexpr int32_t kSpawnAttempts = 6;


    static constexpr size_t kLogoCells = 25;
    static constexpr int32_t kLogoGridWidth = 11;
    static constexpr int32_t kLogoGridHeight = 10;

    static constexpr int32_t kLogoIntervalMinFrames = 2400;
    static constexpr int32_t kLogoIntervalMaxFrames = 7200;

    static constexpr float kLogoSmallScaleChance = 0.10f;


    [[nodiscard]] static constexpr float minGapFor(int32_t size) {
        return (size == 3) ? 5.0f : ((size == 2) ? 4.0f : 3.0f);
    }


    struct Block {
        int32_t x;    
        int32_t y;    
        int32_t size; 
    };

    struct Streak {
        float x;        
        float y;        
        int32_t size;   
        int32_t length; 
    };

    [[nodiscard]] static float separationSquared(const Streak& a, const Streak& b);

    Rainfall() { scatter(); }

    void scatter();

    void advance();

    [[nodiscard]] size_t lengthOf(size_t drop) const { return drops_[drop].length; }

    [[nodiscard]] Block cellAt(size_t drop, size_t cell) const;

    [[nodiscard]] float speedOf(size_t drop) const { return drops_[drop].speed; }


    [[nodiscard]] bool logoActive() const { return logo_.active; }

    [[nodiscard]] Block logoCellAt(size_t cell) const;

    [[nodiscard]] int32_t logoScale() const { return logo_.active ? logo_.size : 0; }

    [[nodiscard]] float logoSpeed() const { return logo_.active ? logo_.speed : 0.0f; }

    void forceLogo() { logoCountdown_ = 0; }

 
private:
    struct Drop {
        float x{};            
        float y{};            
        int32_t axisOffset{}; 
        float speed{};        
        uint8_t size{};       
        uint8_t length{};     
    };

    [[nodiscard]] static constexpr float reachOf(int32_t size, int32_t length) {
        return static_cast<float>((length - 1) * size);
    }

    [[nodiscard]] static Streak streakOf(const Drop& drop) {
        return {.x = drop.x, .y = drop.y, .size = drop.size, .length = drop.length};
    }

    uint32_t nextRandom();

    float nextRandomFloat();

    void roll(Drop& drop);

    void place(Drop& drop, bool seeded);

    struct Logo {
        float x{};            
        float y{};            
        int32_t axisOffset{}; 
        float speed{};        
        uint8_t size{};       
        bool active{};
    };

    void emitLogo();

    void advanceLogo();

    int32_t nextLogoInterval();

    void spawn(size_t index, bool seeded);
 
    std::array<Drop, kNumDrops> drops_{};
    Logo logo_{};
    int32_t logoCountdown_{kLogoIntervalMinFrames};
    uint32_t rngState_{0x1EAF7A11};
};
 
} // namespace deluge::hid::display