/* * SPDX-License-Identifier: Apache-2.0 * * Pattern engine shared by the effect files. Ports the MicroPython led-driver patterns: each pattern * gets the same preset fields (colours, delay d, brightness b, auto a, reverse, n1..n6) and renders into * a shadow frame, which patterns.cpp shows (with crossfade) on the strip. */ #pragma once #include #include "patterns.h" #define FX_LEDS_MAX 512 // largest strip the engine supports (per-LED buffers are sized at run time) struct rgb { int r, g, b; }; // Per-frame view handed to a pattern struct fx_t { int n; // LEDs in the strip const preset_t *pr; // the running preset (copy) uint32_t now; // ms now uint32_t t; // ms since the pattern started rgb *px; // shadow frame, physical order; persists between frames (n entries) }; // Per-pattern state. Patterns run one at a time, so one instance is reset on each select. struct flake_t { int pos, ci, wj; }; struct star_t { int h, ci; }; struct spark_t { int p, lv, ci; }; struct bug_t { int pos, ph; }; struct drop_t { int pos, age; }; struct st_t { bool done; // one-shot finished: hold the frame bool started; // one-time setup done uint32_t last, aux; // timers uint32_t t0; // start time int ci; // colour index int phase, dir, pause; // animation state int head, tail; // moving head / tail int p1, p2; // comet heads int cnt; // counters int sc; // chase step count int stage; // state machine stage int flash_idx; int rise; // flame int cj[8]; // flame cluster jitter uint32_t breath_origin, last_cluster, next_spark, spark_start; int spark_dur; bool spark_active; int breath_ms, lo, hi, gap_lo, gap_hi; bool sparks_on; int centers[32]; int ncent; int *glow; // per-LED buffers, n entries each (see frame_alloc) flake_t flakes[64]; int nflakes; star_t stars[8]; int nstars; spark_t sparks[32]; int nsparks; bug_t bugs[16]; int nbugs; drop_t drops[32]; int ndrops; uint8_t *on, *next_on; int *col_i, *next_ci; int *light, *dark; int nlight, ndark; float *m; // rig: position of each LED along the pattern int *shade; // rig: shade of each LED }; extern st_t g_st; // Allocate the per-LED buffers for n LEDs (frame and pattern state). False if out of memory, in which // case the old buffers are kept. Call with the pattern lock held. bool frame_alloc(int n); // Reset the pattern state for a new pattern, keeping the buffers and clearing them. void st_reset(void); // ---- helpers ------------------------------------------------------------------------------ int clampi(int v, int lo, int hi); int fdiv(int a, int b); // floor division, as Python's // int pmod(int a, int m); // non-negative modulo, as Python's % int nz(int v, int def); // v when v > 0, else def rgb mk(int r, int g, int b); // clamped rgb ab(rgb c, int level); // c scaled by level/255 rgb mix(rgb a, rgb b, int k); // a -> b, k 0..255 int sgn(const fx_t &f, int v); // v, negated when reversed int led_at(const fx_t &f, int i); // logical index -> physical (reverse) void put(fx_t &f, int phys, rgb c); void putl(fx_t &f, int logical, rgb c); void fill(fx_t &f, rgb c); bool due(uint32_t now, uint32_t &last, uint32_t d); // true (and last += d) once d ms have passed uint32_t dur(const fx_t &f, int v); // ms, or quarter beats with beat_time int get_colours(const fx_t &f, const rgb *def, int ndef, rgb *out); // preset colours or the default int rnd(int lo, int hi); // random integer, inclusive rgb grad_at(const rgb *cols, int ncols, float t); // colour at t (0..1) along the list rgb wheel(int pos); // hue wheel, 0..255 -> colour // Colour table for the rig patterns: shades of the colour list, at LEVELS brightness steps #define RIG_SHADES 16 #define RIG_LEVELS 16 rgb rig_entry(const fx_t &f, const rgb *cols, int ncols, int shades, int shade, int level); // Pattern entry points (return true once a one-shot has finished) bool fx_off(fx_t &f, st_t &s); bool fx_on(fx_t &f, st_t &s); bool fx_blink(fx_t &f, st_t &s); bool fx_aurora(fx_t &f, st_t &s); bool fx_bar_graph(fx_t &f, st_t &s); bool fx_blizzard(fx_t &f, st_t &s); bool fx_candle_glow(fx_t &f, st_t &s); bool fx_chase(fx_t &f, st_t &s); bool fx_circle(fx_t &f, st_t &s); bool fx_clock_sweep(fx_t &f, st_t &s); bool fx_colour_cycle(fx_t &f, st_t &s); bool fx_flicker(fx_t &f, st_t &s); bool fx_gradient_wipe(fx_t &f, st_t &s); bool fx_hit(fx_t &f, st_t &s); bool fx_icicles(fx_t &f, st_t &s); bool fx_keyframes(fx_t &f, st_t &s); bool fx_orbit(fx_t &f, st_t &s); bool fx_pulse(fx_t &f, st_t &s); bool fx_transition(fx_t &f, st_t &s); bool fx_strobe_burst(fx_t &f, st_t &s); bool fx_plasma(fx_t &f, st_t &s); bool fx_meteor(fx_t &f, st_t &s); bool fx_particles(fx_t &f, st_t &s); bool fx_sparkle(fx_t &f, st_t &s); bool fx_rain_drops(fx_t &f, st_t &s); bool fx_rime(fx_t &f, st_t &s); bool fx_twinkle(fx_t &f, st_t &s); bool fx_radiate(fx_t &f, st_t &s); bool fx_palette_morph(fx_t &f, st_t &s); bool fx_flame(fx_t &f, st_t &s); bool fx_field_wave(fx_t &f, st_t &s); bool fx_grow(fx_t &f, st_t &s); bool fx_ripple(fx_t &f, st_t &s); bool fx_spin(fx_t &f, st_t &s); bool fx_sweep(fx_t &f, st_t &s);