Files
jimmyandClaude Opus 5.5 24dd5ffb15 feat: ESP-NOW link, beat sync and control messages in the C++ driver
- espnow_link, ctrl_msg and beat_sync: the reliable link, envelopes and
  beat-synced timing.
- ctrl_msg: accept an envelope with the trailing save byte.
- patterns_frame() and espnow_link_poll() split out of their tasks, so the
  WebAssembly simulator can drive one frame and one link pass from a timer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 19:32:36 +13:00

897 lines
26 KiB
C++

/*
* SPDX-License-Identifier: Apache-2.0
*
* Moving lights, particles and sparkles, ported from the MicroPython led-driver (patterns folder).
*/
#include <cstdlib>
#include "effects.h"
static const rgb WHITE = { 255, 255, 255 };
static bool first_call(st_t &s)
{
if (s.started) {
return false;
}
s.started = true;
return true;
}
static uint32_t period_of(const fx_t &f)
{
return f.pr->delay < 1 ? 1 : f.pr->delay;
}
// Fade every LED's stored colour towards black (the shadow frame persists between frames)
static void fade_frame(fx_t &f, int amount)
{
for (int i = 0; i < f.n; i++) {
rgb c = f.px[i];
f.px[i] = { c.r * amount / 255, c.g * amount / 255, c.b * amount / 255 };
}
}
// ---- meteor / comet / scanner ------------------------------------------------------------------
static bool meteor_run(fx_t &f, st_t &s, const rgb *cols, int nc)
{
int b = f.pr->brightness;
int tail = nz(f.pr->n[1], 8);
int speed = nz(f.pr->n[2], 1);
int fade_amount = clampi(nz(f.pr->n[3], 192), 1, 255);
if (first_call(s)) {
s.last = f.now;
s.dir = f.pr->reverse ? -1 : 1;
s.head = f.pr->reverse ? (f.n > 0 ? f.n - 1 : 0) : 0;
s.ci = 0;
}
if (!due(f.now, s.last, period_of(f))) {
return false;
}
fade_frame(f, fade_amount);
rgb lit = ab(cols[s.ci % nc], b);
if (s.head >= 0 && s.head < f.n) {
putl(f, s.head, lit);
}
s.head += sgn(f, s.dir * speed);
if (s.head >= f.n + tail) {
s.head = f.n - 1;
s.dir = -1;
s.ci++;
} else if (s.head < -tail) {
s.head = 0;
s.dir = 1;
s.ci++;
}
return !f.pr->autorun;
}
static bool comet_run(fx_t &f, st_t &s, const rgb *cols, int nc)
{
int b = f.pr->brightness;
int nled = f.n;
int tail = nz(f.pr->n[1], 6);
int speed = nz(f.pr->n[2], 1);
int gap = f.pr->n[3] > 0 ? f.pr->n[3] : 0;
if (first_call(s)) {
s.last = f.now;
if (f.pr->reverse) {
s.p1 = nled - 1;
s.p2 = gap;
} else {
s.p1 = 0;
s.p2 = nled - 1 - gap;
}
}
if (!due(f.now, s.last, period_of(f))) {
return false;
}
rgb bgc = ab(mk(f.pr->bg[0], f.pr->bg[1], f.pr->bg[2]), b);
for (int i = 0; i < nled; i++) {
put(f, i, bgc);
}
rgb c1 = ab(cols[0], b);
rgb c2 = ab(nc > 1 ? cols[1] : cols[0], b);
int denom = tail > 1 ? tail : 1;
for (int t = 0; t < tail; t++) {
int i1 = s.p1 - t;
if (i1 >= 0 && i1 < nled) {
int k = (255 * (tail - t)) / denom;
putl(f, i1, { c1.r * k / 255, c1.g * k / 255, c1.b * k / 255 });
}
int i2 = s.p2 + t;
if (i2 >= 0 && i2 < nled) {
int k = (255 * (tail - t)) / denom;
putl(f, i2, { c2.r * k / 255, c2.g * k / 255, c2.b * k / 255 });
}
}
s.p1 += sgn(f, speed);
s.p2 -= sgn(f, speed);
if (s.p1 - tail > nled && s.p2 + tail < 0) {
s.p1 = 0;
s.p2 = nled - 1 - gap;
}
return !f.pr->autorun;
}
static bool scanner_run(fx_t &f, st_t &s, const rgb *cols, int nc)
{
int b = f.pr->brightness;
int nled = f.n;
int width = nz(f.pr->n[1], 4);
int end_pause = f.pr->n[2] > 0 ? f.pr->n[2] : 0;
if (first_call(s)) {
s.last = f.now;
s.ci = 0;
s.pause = 0;
s.dir = f.pr->reverse ? -1 : 1;
s.head = f.pr->reverse ? (nled > 0 ? nled - 1 : 0) : 0; // centre
}
if (!due(f.now, s.last, period_of(f))) {
return false;
}
rgb base = ab(cols[s.ci % nc], b);
rgb bgc = ab(mk(f.pr->bg[0], f.pr->bg[1], f.pr->bg[2]), b);
int denom = width > 1 ? width : 1;
for (int i = 0; i < nled; i++) {
int dist = abs(i - s.head);
if (dist > width) {
putl(f, i, bgc);
} else {
int sc = ((width - dist) * 255) / denom;
putl(f, i, { base.r * sc / 255, base.g * sc / 255, base.b * sc / 255 });
}
}
if (s.pause > 0) {
s.pause--;
} else {
s.head += sgn(f, s.dir);
if (s.head >= nled - 1) {
s.head = nled - 1;
s.dir = -1;
s.pause = end_pause;
s.ci++;
} else if (s.head <= 0) {
s.head = 0;
s.dir = 1;
s.pause = end_pause;
s.ci++;
}
}
return !f.pr->autorun;
}
bool fx_meteor(fx_t &f, st_t &s)
{
const rgb def[1] = { WHITE };
rgb c[PATTERN_MAX_COLOURS];
int nc = get_colours(f, def, 1, c);
switch (f.pr->n[6]) {
case 1:
return comet_run(f, s, c, nc);
case 2:
return scanner_run(f, s, c, nc);
default:
return meteor_run(f, s, c, nc);
}
}
// ---- particles: snowfall and starfall ----------------------------------------------------------
static bool snow_run(fx_t &f, st_t &s)
{
const rgb def[2] = { WHITE, { 180, 220, 255 } };
rgb c[PATTERN_MAX_COLOURS];
int nc = get_colours(f, def, 2, c);
int b = f.pr->brightness;
int density = nz(f.pr->n[1], 20);
int speed = abs(sgn(f, nz(f.pr->n[2], 1)));
if (speed < 1) speed = 1;
if (first_call(s)) {
s.last = f.now;
}
if (!due(f.now, s.last, period_of(f))) {
return false;
}
if (rnd(0, 255) < density && s.nflakes < 64) {
s.flakes[s.nflakes++] = { f.n - 1, rnd(0, nc - 1), 0 };
}
rgb bgc = ab(mk(f.pr->bg[0], f.pr->bg[1], f.pr->bg[2]), b);
for (int i = 0; i < f.n; i++) {
put(f, i, bgc);
}
int keep = 0;
for (int k = 0; k < s.nflakes; k++) {
flake_t fl = s.flakes[k];
if (fl.pos >= 0 && fl.pos < f.n) {
putl(f, fl.pos, ab(c[fl.ci], b));
}
fl.pos -= sgn(f, speed);
if (fl.pos >= -1) {
s.flakes[keep++] = fl;
}
}
s.nflakes = keep;
return !f.pr->autorun;
}
static bool starfall_run(fx_t &f, st_t &s)
{
const rgb def[3] = { WHITE, { 200, 230, 255 }, { 255, 248, 220 } };
rgb c[PATTERN_MAX_COLOURS];
int nc = get_colours(f, def, 3, c);
int b = f.pr->brightness;
int rate = clampi(nz(f.pr->n[1], 14), 1, 255);
int speed = abs(sgn(f, nz(f.pr->n[2], 2)));
if (speed < 1) speed = 1;
int tail = nz(f.pr->n[3], 10);
if (tail < 2) tail = 2;
if (first_call(s)) {
s.last = f.now;
}
if (!due(f.now, s.last, period_of(f))) {
return false;
}
rgb bgc = ab(mk(f.pr->bg[0], f.pr->bg[1], f.pr->bg[2]), b);
for (int i = 0; i < f.n; i++) {
put(f, i, bgc);
}
if (s.nstars < 4 && rnd(0, 255) < rate) {
int extra = f.n / 2;
if (extra > 8) extra = 8;
int top = f.n - 1 + rnd(0, extra);
s.stars[s.nstars++] = { top, rnd(0, nc - 1) };
}
int keep = 0;
for (int k = 0; k < s.nstars; k++) {
star_t st = s.stars[k];
for (int t = 0; t < tail; t++) {
int idx = st.h + t;
if (idx < 0 || idx >= f.n) {
continue;
}
int fade = 255 - (t * 255) / (tail - 1 > 1 ? tail - 1 : 1);
rgb base = c[st.ci];
rgb lit = ab({ base.r * fade / 255, base.g * fade / 255, base.b * fade / 255 }, b);
int pix = led_at(f, idx);
rgb o = f.px[pix];
f.px[pix] = { o.r > lit.r ? o.r : lit.r, o.g > lit.g ? o.g : lit.g, o.b > lit.b ? o.b : lit.b };
}
st.h -= sgn(f, speed);
if (st.h >= -tail) {
s.stars[keep++] = st;
}
}
s.nstars = keep;
return !f.pr->autorun;
}
bool fx_particles(fx_t &f, st_t &s)
{
return f.pr->n[6] == 1 ? starfall_run(f, s) : snow_run(f, s);
}
// ---- sparkle: trail, ice burst, fireflies ------------------------------------------------------
static bool sparkle_trail(fx_t &f, st_t &s)
{
const rgb def[1] = { { 120, 120, 255 } };
rgb c[PATTERN_MAX_COLOURS];
int nc = get_colours(f, def, 1, c);
int b = f.pr->brightness;
int density = nz(f.pr->n[1], 24);
int decay = clampi(nz(f.pr->n[2], 210), 1, 255);
if (first_call(s)) {
s.last = f.now;
}
if (!due(f.now, s.last, period_of(f))) {
return false;
}
fade_frame(f, decay);
int sparks = f.n * density / 255;
if (sparks < 1) sparks = 1;
for (int k = 0; k < sparks; k++) {
int idx = rnd(0, f.n > 0 ? f.n - 1 : 0);
put(f, idx, ab(c[rnd(0, nc - 1)], b));
}
return !f.pr->autorun;
}
static bool sparkle_ice(fx_t &f, st_t &s)
{
const rgb def[3] = { { 240, 248, 255 }, { 200, 235, 255 }, { 255, 255, 255 } };
rgb c[PATTERN_MAX_COLOURS];
int nc = get_colours(f, def, 3, c);
int b = f.pr->brightness;
int rate = clampi(nz(f.pr->n[1], 55), 1, 255);
int decay = clampi(nz(f.pr->n[2], 140), 1, 255);
int halo = clampi(f.pr->n[3], 0, 3);
const int cap = 28;
if (first_call(s)) {
s.last = f.now;
}
if (!due(f.now, s.last, period_of(f))) {
return false;
}
rgb bgc = ab(mk(f.pr->bg[0], f.pr->bg[1], f.pr->bg[2]), b);
for (int i = 0; i < f.n; i++) {
put(f, i, bgc);
}
int keep = 0;
for (int k = 0; k < s.nsparks; k++) {
spark_t sp = s.sparks[k];
sp.lv -= decay;
if (sp.lv > 0) {
s.sparks[keep++] = sp;
}
}
s.nsparks = keep;
if (s.nsparks < cap && rnd(0, 255) < rate) {
s.sparks[s.nsparks++] = { rnd(0, f.n > 0 ? f.n - 1 : 0), 255, rnd(0, nc - 1) };
}
for (int k = 0; k < s.nsparks; k++) {
spark_t sp = s.sparks[k];
rgb base = c[sp.ci];
for (int off = -halo; off <= halo; off++) {
int idx = sp.p + off;
if (idx < 0 || idx >= f.n) {
continue;
}
int dist = abs(off);
int fac = dist == 0 ? sp.lv : (sp.lv * (halo - dist + 1)) / (halo + 1);
rgb lit = ab({ base.r * fac / 255, base.g * fac / 255, base.b * fac / 255 }, b);
rgb o = f.px[idx];
f.px[idx] = { o.r + lit.r > 255 ? 255 : o.r + lit.r, o.g + lit.g > 255 ? 255 : o.g + lit.g,
o.b + lit.b > 255 ? 255 : o.b + lit.b };
}
}
return !f.pr->autorun;
}
static bool sparkle_fireflies(fx_t &f, st_t &s)
{
const rgb def[2] = { { 255, 210, 80 }, { 120, 255, 120 } };
rgb c[PATTERN_MAX_COLOURS];
int nc = get_colours(f, def, 2, c);
int b = f.pr->brightness;
int count = nz(f.pr->n[1], 6);
if (count > 16) count = 16;
int speed = nz(f.pr->n[2], 8);
if (first_call(s)) {
s.last = f.now;
s.nbugs = count;
for (int k = 0; k < count; k++) {
s.bugs[k] = { rnd(0, f.n > 0 ? f.n - 1 : 0), rnd(0, 255) };
}
}
if (!due(f.now, s.last, period_of(f))) {
return false;
}
rgb bgc = ab(mk(f.pr->bg[0], f.pr->bg[1], f.pr->bg[2]), b);
for (int i = 0; i < f.n; i++) {
put(f, i, bgc);
}
for (int k = 0; k < s.nbugs; k++) {
bug_t &bg = s.bugs[k];
int tri = 255 - abs(128 - bg.ph) * 2;
rgb col = ab(c[bg.pos % nc], b);
put(f, bg.pos, { col.r * tri / 255, col.g * tri / 255, col.b * tri / 255 });
bg.ph = (bg.ph + speed) & 255;
if (rnd(0, 31) == 0) {
bg.pos = rnd(0, f.n > 0 ? f.n - 1 : 0);
}
}
return !f.pr->autorun;
}
bool fx_sparkle(fx_t &f, st_t &s)
{
switch (f.pr->n[6]) {
case 1:
return sparkle_ice(f, s);
case 2:
return sparkle_fireflies(f, s);
default:
return sparkle_trail(f, s);
}
}
// ---- rain drops --------------------------------------------------------------------------------
bool fx_rain_drops(fx_t &f, st_t &s)
{
const rgb def[1] = { { 120, 180, 255 } };
rgb c[PATTERN_MAX_COLOURS];
int nc = get_colours(f, def, 1, c);
int b = f.pr->brightness;
int rate = nz(f.pr->n[1], 32);
int width = nz(f.pr->n[2], 3);
if (first_call(s)) {
s.last = f.now;
}
if (!due(f.now, s.last, period_of(f))) {
return false;
}
rgb bgc = ab(mk(f.pr->bg[0], f.pr->bg[1], f.pr->bg[2]), b);
for (int i = 0; i < f.n; i++) {
put(f, i, bgc);
}
if (rnd(0, 255) < rate && s.ndrops < 32) {
s.drops[s.ndrops++] = { rnd(0, f.n > 0 ? f.n - 1 : 0), 0 };
}
int keep = 0;
int denom = width + 1;
for (int k = 0; k < s.ndrops; k++) {
drop_t dr = s.drops[k];
for (int off = -width; off <= width; off++) {
int idx = dr.pos + off;
if (idx < 0 || idx >= f.n) {
continue;
}
int lvl = 255 - (abs(off) * 255 / (denom > 1 ? denom : 1) + dr.age * 40);
if (lvl < 0) lvl = 0;
rgb base = ab(c[dr.age % nc], b);
put(f, idx, { base.r * lvl / 255, base.g * lvl / 255, base.b * lvl / 255 });
}
dr.age++;
if (dr.age < 8) {
s.drops[keep++] = dr;
}
}
s.ndrops = keep;
return !f.pr->autorun;
}
// ---- rime: slow frost build-up -----------------------------------------------------------------
bool fx_rime(fx_t &f, st_t &s)
{
const rgb def[3] = { { 220, 235, 255 }, WHITE, { 185, 220, 255 } };
rgb c[PATTERN_MAX_COLOURS];
int nc = get_colours(f, def, 3, c);
int b = f.pr->brightness;
int num = f.n;
if (num <= 0) {
return false;
}
int chill = clampi(nz(f.pr->n[1], 36), 1, 255);
int melt = clampi(nz(f.pr->n[2], 12), 1, 255);
int spark_cap = clampi(nz(f.pr->n[3], 3), 1, num);
if (first_call(s)) {
for (int i = 0; i < num; i++) {
s.glow[i] = 0;
}
s.last = f.now;
}
if (!due(f.now, s.last, period_of(f))) {
return false;
}
rgb bgc = ab(mk(f.pr->bg[0], f.pr->bg[1], f.pr->bg[2]), b);
for (int i = 0; i < num; i++) {
s.glow[i] = s.glow[i] > melt ? s.glow[i] - melt : 0;
}
int spawned = 0;
int tries = spark_cap + num / 8;
for (int t = 0; t < tries; t++) {
if (spawned >= spark_cap) {
break;
}
if (rnd(0, 255) >= chill) {
continue;
}
int j = rnd(0, num - 1);
int g = s.glow[j] + rnd(80, 200);
s.glow[j] = g > 255 ? 255 : g;
spawned++;
}
for (int i = 0; i < num; i++) {
int g = clampi(s.glow[i], 0, 255);
rgb hi = ab(c[i % nc], b);
rgb px = { (hi.r * g + bgc.r * (255 - g)) / 255, (hi.g * g + bgc.g * (255 - g)) / 255,
(hi.b * g + bgc.b * (255 - g)) / 255 };
put(f, i, px);
}
return !f.pr->autorun;
}
// ---- twinkle -----------------------------------------------------------------------------------
static const rgb kCool[6] = {
{ 120, 200, 255 }, { 80, 140, 255 }, { 180, 120, 255 },
{ 100, 220, 240 }, { 160, 200, 255 }, { 90, 180, 220 },
};
static int cluster_lo(const fx_t &f, int *hi_out)
{
int lo = f.pr->n[3];
int hi = f.pr->n[4];
int num = f.n;
if (lo <= 0 && hi <= 0) {
lo = 1;
hi = num < 4 ? num : 4;
} else {
if (lo <= 0) lo = 1;
if (hi <= 0) hi = lo;
if (hi < lo) {
int t = lo;
lo = hi;
hi = t;
}
}
lo = clampi(lo, 1, num > 0 ? num : 1);
hi = clampi(hi, lo, num > 0 ? num : 1);
*hi_out = hi;
return lo;
}
static int cluster_len(const fx_t &f)
{
int hi;
int lo = cluster_lo(f, &hi);
return lo == hi ? lo : rnd(lo, hi);
}
static int cluster_base(const fx_t &f, int start, int k)
{
k = clampi(k, 0, f.n);
if (k <= 0) {
return 0;
}
int b = start < f.n - k ? start : f.n - k;
return b < 0 ? 0 : b;
}
bool fx_twinkle(fx_t &f, st_t &s)
{
rgb palette[PATTERN_MAX_COLOURS];
int np = get_colours(f, kCool, 6, palette);
int b = f.pr->brightness;
int num = f.n;
rgb bgc = ab(mk(f.pr->bg[0], f.pr->bg[1], f.pr->bg[2]), b);
if (num <= 0) {
return false;
}
if (first_call(s)) {
int dens0 = clampi(f.pr->n[2] > 0 ? f.pr->n[2] : 128, 0, 255);
for (int i = 0; i < num; i++) {
s.on[i] = rnd(0, 255) < dens0;
s.col_i[i] = rnd(0, np - 1);
}
s.last = f.now;
}
if (!f.pr->autorun) {
for (int i = 0; i < num; i++) {
put(f, i, s.on[i] ? ab(palette[s.col_i[i] % np], b) : bgc);
}
return true;
}
uint32_t d = period_of(f);
if (!due(f.now, s.last, d)) {
return false;
}
int rate = clampi(f.pr->n[1] > 0 ? f.pr->n[1] : 48, 1, 255);
int dens = clampi(f.pr->n[2] > 0 ? f.pr->n[2] : 128, 0, 255);
for (int i = 0; i < num; i++) {
s.next_on[i] = s.on[i];
s.next_ci[i] = s.col_i[i];
}
s.nlight = 0;
s.ndark = 0;
for (int i = 0; i < num; i++) {
if (rnd(0, 255) < rate) {
int r = rnd(0, 255);
if (!s.on[i]) {
if (r < dens) s.light[s.nlight++] = i;
} else {
if (r < 255 - dens) s.dark[s.ndark++] = i;
}
}
}
for (int k = 0; k < s.ndark; k++) {
int start = s.dark[k];
int len = cluster_len(f);
int base = cluster_base(f, start, len);
for (int dj = 0; dj < len; dj++) {
s.next_on[base + dj] = 0;
}
}
for (int k = 0; k < s.nlight; k++) {
int start = s.light[k];
int len = cluster_len(f);
int base = cluster_base(f, start, len);
for (int dj = 0; dj < len; dj++) {
s.next_on[base + dj] = 1;
s.next_ci[base + dj] = rnd(0, np - 1);
}
}
for (int i = 0; i < num; i++) {
put(f, i, s.next_on[i] ? ab(palette[s.next_ci[i] % np], b) : bgc);
s.on[i] = s.next_on[i];
s.col_i[i] = s.next_ci[i];
}
return false;
}
// ---- radiate: pulses from nodes ----------------------------------------------------------------
static int radiate_front(int age, int outward, int ret, int maxd)
{
if (age <= outward) {
return (age * maxd + outward - 1) / outward;
}
if (age <= outward + ret) {
int rem = ret - (age - outward);
return (rem * maxd + ret - 1) / ret;
}
return -1;
}
bool fx_radiate(fx_t &f, st_t &s)
{
const rgb def[1] = { WHITE };
rgb c[PATTERN_MAX_COLOURS];
int nc = get_colours(f, def, 1, c);
int b = f.pr->brightness;
rgb off_c = ab(mk(f.pr->bg[0], f.pr->bg[1], f.pr->bg[2]), b);
// n1 spacing (LEDs); n2/n3 rise and fall in ms, default half a period each so a ring is seen
int half = (int)(period_of(f) / 2) < 1 ? 1 : (int)(period_of(f) / 2);
int spacing = nz(f.pr->n[1], 24);
int outward = nz(f.pr->n[2], half);
int ret = nz(f.pr->n[3], half);
int maxd = spacing / 2;
int life = outward + ret;
int num = f.n;
if (!f.pr->autorun) {
// One pulse, then hold
if (first_call(s)) {
s.aux = f.now;
}
int age = (int)(f.now - s.aux);
if (age < 1) age = 1;
int front = radiate_front(age, outward, ret, maxd);
if (front < 0) front = 0;
rgb lit = ab(c[s.ci % nc], b);
for (int i = 0; i < num; i++) {
int offset = (i + spacing / 2) % spacing;
int dist = offset < spacing - offset ? offset : spacing - offset;
put(f, i, dist <= front ? lit : off_c);
}
if (age >= life) {
s.ci++;
return true;
}
return false;
}
uint32_t delay = period_of(f);
if (first_call(s)) {
s.last = f.now;
s.ncent = 1;
s.centers[0] = (int)f.now;
}
if ((int32_t)(f.now - s.last) >= (int32_t)delay) {
s.ncent = 1;
s.centers[0] = (int)f.now;
s.last += delay;
s.ci++;
}
int kept = 0;
for (int k = 0; k < s.ncent; k++) {
if ((int)(f.now - s.centers[k]) < life) {
s.centers[kept++] = s.centers[k];
}
}
s.ncent = kept;
rgb lit = ab(c[s.ci % nc], b);
for (int i = 0; i < num; i++) {
int offset = (i + spacing / 2) % spacing;
int dist = offset < spacing - offset ? offset : spacing - offset;
bool on = false;
for (int k = 0; k < s.ncent && !on; k++) {
int age = (int)(f.now - s.centers[k]);
if (age <= 0) {
continue;
}
int front = radiate_front(age, outward, ret, maxd);
if (front < 0) {
continue;
}
if (dist <= front) {
on = true;
}
}
put(f, i, on ? lit : off_c);
}
return false;
}
// ---- palette morph -----------------------------------------------------------------------------
bool fx_palette_morph(fx_t &f, st_t &s)
{
const rgb def[3] = { { 255, 0, 0 }, { 0, 255, 0 }, { 0, 0, 255 } };
rgb c[PATTERN_MAX_COLOURS];
int nc = get_colours(f, def, 3, c);
int b = f.pr->brightness;
int num = f.n;
if (nc < 2) {
fill(f, ab(c[0], b));
return false;
}
int morph = nz(f.pr->n[1], 1200);
if (morph < 50) morph = 50;
int warp = nz(f.pr->n[2], 3);
int turb = nz(f.pr->n[3], 24);
if (first_call(s)) {
s.aux = f.now; // morph start
s.last = f.now; // frame timer
s.ci = 0; // base colour index
s.phase = 0;
}
uint32_t delay = period_of(f);
if (!due(f.now, s.last, delay)) {
return false;
}
int age = (int)(f.now - s.aux);
int t = age < morph ? (age * 255) / morph : 255;
rgb a = c[s.ci % nc];
rgb bb = c[(s.ci + 1) % nc];
rgb anchor = mix(a, bb, t);
for (int i = 0; i < num; i++) {
int pos = (i * 256) / (num > 0 ? num : 1);
int wobble = (((pos * turb) / 32) + s.phase + (t / 2)) & 255;
int breath = 255 - abs(128 - wobble) * 2;
int local = (pos + breath / 3 + t / 4) % 256;
int idx = (s.ci + ((local * nc) / 256)) % nc;
int frac = (local * nc) & 255;
rgb grad = mix(c[idx], c[(idx + 1) % nc], frac);
rgb out = mix(grad, anchor, 80);
put(f, i, ab(out, b));
}
if (age >= morph) {
s.ci = (s.ci + 1) % nc;
s.aux = f.now;
if (!f.pr->autorun) {
return true;
}
}
s.phase = (s.phase + warp) & 255;
return false;
}
// ---- flame -------------------------------------------------------------------------------------
static int tri255(uint32_t elapsed, uint32_t period)
{
if (period < 400) period = 400;
uint32_t p = elapsed % period;
uint32_t half = period >> 1;
if (half == 0) return 128;
if (p < half) return (int)((p * 255) / half);
return (int)(((period - p) * 255) / (period - half));
}
static rgb palette_sample(const rgb *pal, int n, int pos)
{
if (n == 1) return pal[0];
int span = (n - 1) * pos;
int seg = span >> 8;
if (seg >= n - 1) return pal[n - 1];
int frac = span & 0xFF;
rgb a = pal[seg];
rgb b = pal[seg + 1];
rgb o = { a.r + (((b.r - a.r) * frac) >> 8), a.g + (((b.g - a.g) * frac) >> 8),
a.b + (((b.b - a.b) * frac) >> 8) };
return o;
}
static void flame_frame(fx_t &f, st_t &s, const rgb *pal, int np, uint32_t breath_el, bool spark_on)
{
int num = f.n;
int denom = num > 1 ? num - 1 : 1;
int breathe = tri255(breath_el, (uint32_t)s.breath_ms);
int base_level = s.lo + (((s.hi - s.lo) * breathe) >> 8);
int micro = 232 + rnd(0, 35);
int level = clampi((base_level * micro) >> 8, s.lo, s.hi);
int boost = 0;
rgb white = { 0, 0, 0 };
if (spark_on && s.spark_dur > 0) {
int el = (int)(f.now - s.spark_start);
if (el < 0) el = 0;
if (el < s.spark_dur) {
int env = 255 - (el * 255) / s.spark_dur;
boost = (env * 90) >> 8;
white = { (env * 55) >> 8, (env * 50) >> 8, (env * 40) >> 8 };
}
}
int cell = num >> 3;
if (cell < 1) cell = 1;
for (int i = 0; i < num; i++) {
int h = (i * 256) / denom;
int flow = (h + s.rise + (i / cell) * 17) & 255;
int pos = (flow + s.cj[(i >> 2) & 7]) & 255;
rgb c = palette_sample(pal, np, pos);
if (boost) {
c = { clampi(c.r + white.r + ((boost * 3) >> 2), 0, 255), clampi(c.g + white.g + (boost >> 1), 0, 255),
clampi(c.b + white.b + (boost >> 2), 0, 255) };
}
put(f, i, ab(c, level));
}
}
bool fx_flame(fx_t &f, st_t &s)
{
const rgb def[4] = { { 90, 8, 8 }, { 200, 40, 12 }, { 255, 120, 30 }, { 255, 220, 140 } };
rgb pal[PATTERN_MAX_COLOURS];
int np = get_colours(f, def, 4, pal);
int lo = clampi(f.pr->n[1], 0, 255);
int hi = clampi(f.pr->brightness, 0, 255);
if (lo > hi) {
int t = lo;
lo = hi;
hi = t;
}
int bp = f.pr->n[2];
int breath_ms = bp > 0 ? bp : 2500;
if (breath_ms < 800) breath_ms = 800;
int gap_lo = f.pr->n[3];
int gap_hi = f.pr->n[4];
if (gap_lo == 0 && gap_hi == 0) {
gap_lo = 10000;
gap_hi = 30000;
} else {
if (gap_lo < 500) gap_lo = 500;
}
if (gap_hi < gap_lo) gap_hi = gap_lo;
uint32_t delay = f.pr->delay < 16 ? 16 : f.pr->delay;
if (first_call(s)) {
s.breath_ms = breath_ms;
s.lo = lo;
s.hi = hi;
s.rise = rnd(0, 255);
for (int k = 0; k < 8; k++) {
s.cj[k] = rnd(-18, 18);
}
s.last = f.now; // last frame
s.breath_origin = f.now;
s.last_cluster = f.now;
s.spark_active = false;
s.spark_dur = 0;
s.next_spark = f.now + (uint32_t)rnd(gap_lo, gap_hi);
}
s.lo = lo;
s.hi = hi;
s.breath_ms = breath_ms;
if (!f.pr->autorun) {
flame_frame(f, s, pal, np, 0, false);
return true;
}
if ((int32_t)(f.now - s.last) < (int32_t)delay) {
return false;
}
s.last += delay;
s.rise = (s.rise + rnd(-10, 12)) & 255;
if ((int32_t)(f.now - s.last_cluster) >= (int32_t)(delay * 4)) {
s.last_cluster = f.now;
for (int k = 0; k < 8; k++) {
s.cj[k] = rnd(-18, 18);
}
}
if (s.spark_active) {
if ((int)(f.now - s.spark_start) >= s.spark_dur) {
s.spark_active = false;
s.next_spark = f.now + (uint32_t)rnd(gap_lo, gap_hi);
}
} else if ((int32_t)(f.now - s.next_spark) >= 0) {
s.spark_active = true;
s.spark_start = f.now;
s.spark_dur = rnd(180, 360);
}
flame_frame(f, s, pal, np, f.now - s.breath_origin, s.spark_active);
return false;
}