/* * SPDX-License-Identifier: Apache-2.0 * * Moving lights, particles and sparkles, ported from the MicroPython led-driver (patterns folder). */ #include #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; }