/* * SPDX-License-Identifier: Apache-2.0 * * Patterns that span the rig, ported from the MicroPython led-driver (rig.py and patterns folder). * The rig geometry is the MicroPython default for a lone strip: the bar runs from (-1, 0) to (1, 0), so * LED i sits at x = -1 + 2 (i + 0.5) / n. The rig placement (place) is not configurable on this board. */ #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; } // Position of LED i on the bar static float led_x(int i, int n) { return -1.0f + 2.0f * (i + 0.5f) / n; } // Distance from the centre, 0..1 static float led_r(int i, int n) { float x = led_x(i, n); return x < 0 ? -x : x; } // Angle round the centre, 0..1 of a turn: the left half is at 1/2, the right at 0 static float led_a(int i, int n) { return led_x(i, n) < 0 ? 0.5f : 0.0f; } // Position of LED i along a direction across the rig, 0..1 static float along(int i, int n, float angle_deg) { float rad = angle_deg * 3.14159265f / 180.0f; return (led_x(i, n) * cosf(rad) + 1.0f) / 2.0f; } static int shade_of(float p) { int s = (int)(p * (RIG_SHADES - 1) + 0.5f); return s < 0 ? 0 : (s > RIG_SHADES - 1 ? RIG_SHADES - 1 : s); } // Shade of a brightness-free sine: 0..15 static int sin_shade(int i) { float v = (sinf(i * 6.2831853f / 256.0f) + 1.0f) / 2.0f * (RIG_SHADES - 1) + 0.5f; return (int)v; } // ---- field wave -------------------------------------------------------------------------------- bool fx_field_wave(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 n = f.n; int kind = f.pr->n[3]; int lam = nz(f.pr->n[2], 1000); uint32_t period = dur(f, (int)f.pr->delay); if (period < 1) period = 1; (void)first_call(s); uint32_t t = f.t; bool done = !f.pr->autorun && t >= period; int ph = done ? 256 : (int)((t % period) * 256 / period); for (int i = 0; i < n; i++) { int shade; if (kind == 3) { // Plasma: two sines of the position, summed // Lone bar: y is always 0, so the second sine is taken at -p13 int px = (int)(led_x(i, n) * 3 * 256000 / (lam * 6.283f)); int p13 = ph * 13 / 10; float v = sinf(((px + ph) & 255) * 6.2831853f / 256.0f) + sinf(((-p13) & 255) * 6.2831853f / 256.0f); // -2..2 shade = sin_shade(((int)(v * 41) + ph) & 255); } else { float m = kind == 1 ? led_r(i, n) : (kind == 2 ? led_a(i, n) : along(i, n, (float)f.pr->n[1])); int mi = (int)(m * 256000 / lam); shade = sin_shade((mi - ph) & 255); } put(f, i, rig_entry(f, c, nc, RIG_SHADES, shade, RIG_LEVELS - 1)); } return done; } // ---- grow -------------------------------------------------------------------------------------- bool fx_grow(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 n = f.n; int mode = f.pr->n[1]; const int top = RIG_LEVELS - 1; const float edge = 0.06f; (void)first_call(s); for (int i = 0; i < n; i++) { float m; if (mode == 1) { m = 1 - led_r(i, n); } else if (mode == 2) { m = led_a(i, n); } else if (mode == 3) { m = along(i, n, (float)f.pr->n[3]); } else { m = led_r(i, n); } s.m[i] = m; s.shade[i] = shade_of(m); } uint32_t total = dur(f, (int)f.pr->delay); if (total < 1) total = 1; bool empties = f.pr->n[2] == 1 || f.pr->n[2] == 2 || f.pr->autorun; int phases = empties ? 2 : 1; uint32_t t = f.t; if (!f.pr->autorun && t >= total * phases) { if (f.pr->n[2] == 3 || empties) { fill(f, ab(mk(f.pr->bg[0], f.pr->bg[1], f.pr->bg[2]), f.pr->brightness)); } else { for (int i = 0; i < n; i++) { put(f, i, rig_entry(f, c, nc, RIG_SHADES, s.shade[i], top)); } } return true; } float ph; if (f.pr->autorun) { ph = (float)(t % (total * phases)) / total; } else { ph = (float)t / total; if (ph > phases) ph = (float)phases; } float front; bool rising; if (ph <= 1) { front = ph * (1 + edge); rising = true; } else if (f.pr->n[2] == 2) { front = (ph - 1) * (1 + edge); rising = false; } else { front = (2 - ph) * (1 + edge); rising = true; } for (int i = 0; i < n; i++) { float v = (rising ? (front - s.m[i]) : (s.m[i] - front)) / edge; int lv = v <= 0 ? 0 : (v >= 1 ? top : (int)(v * top)); put(f, i, rig_entry(f, c, nc, RIG_SHADES, s.shade[i], lv)); } return false; } // ---- ripple ------------------------------------------------------------------------------------ bool fx_ripple(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 n = f.n; int b = f.pr->brightness; const int top = RIG_LEVELS - 1; (void)first_call(s); uint32_t period = dur(f, (int)f.pr->delay); if (period < 1) period = 1; float hw = (f.pr->n[1] > 0 ? f.pr->n[1] : 150) / 2000.0f; int rings = f.pr->autorun ? nz(f.pr->n[2], 1) : 1; if (rings > 8) rings = 8; float fade = (f.pr->n[4] > 0 ? f.pr->n[4] : 0) / 1000.0f; uint32_t t = f.t; if (!f.pr->autorun && t >= period) { fill(f, ab(mk(f.pr->bg[0], f.pr->bg[1], f.pr->bg[2]), b)); return true; } float base = f.pr->autorun ? (float)(t % period) / period : (float)t / period; float span = 1 + 4 * hw; float rads[8]; for (int k = 0; k < rings; k++) { float x = base + (float)k / rings; x = x - floorf(x); rads[k] = -2 * hw + x * span; } int shade = (int)((t / period) % (uint32_t)nc); for (int i = 0; i < n; i++) { float r = (f.pr->n[3] == 1) ? (1 - led_r(i, n)) : led_r(i, n); float best = 0; for (int k = 0; k < rings; k++) { float v = 1 - fabsf(r - rads[k]) / hw; if (v > best) best = v; } if (fade > 0 && best > 0) { best *= 1 - fade * r; if (best < 0) best = 0; } put(f, i, rig_entry(f, c, nc, nc, shade, (int)(best * top))); } return false; } // ---- spin -------------------------------------------------------------------------------------- bool fx_spin(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 n = f.n; const int top = RIG_LEVELS - 1; (void)first_call(s); uint32_t period = dur(f, (int)f.pr->delay); if (period < 1) period = 1; float span = 1.0f / (f.pr->n[1] > 0 ? f.pr->n[1] : 1); float width = (f.pr->n[2] > 0 ? f.pr->n[2] : 20) / 360.0f; float tail = (f.pr->n[3] > 0 ? f.pr->n[3] : 90) / 360.0f; uint32_t t = f.t; if (!f.pr->autorun && t >= period) { fill(f, ab(mk(f.pr->bg[0], f.pr->bg[1], f.pr->bg[2]), f.pr->brightness)); return true; } float rot = fmodf((float)t / period, 1.0f); for (int i = 0; i < n; i++) { float ang = f.pr->n[4] == 1 ? 1 - led_a(i, n) : led_a(i, n); float x = rot - ang; float behind = x - floorf(x / span) * span; if (behind < width) { put(f, i, rig_entry(f, c, nc, RIG_SHADES, 0, top)); } else { float fr = (behind - width) / tail; if (fr >= 1) { put(f, i, rig_entry(f, c, nc, RIG_SHADES, 0, 0)); } else { int shade = (int)(fr * (RIG_SHADES - 1)); int lv = (int)((1 - fr) * top); put(f, i, rig_entry(f, c, nc, RIG_SHADES, shade, lv)); } } } return false; } // ---- sweep ------------------------------------------------------------------------------------- bool fx_sweep(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 n = f.n; const int top = RIG_LEVELS - 1; (void)first_call(s); for (int i = 0; i < n; i++) { s.m[i] = along(i, n, (float)f.pr->n[1]); s.shade[i] = shade_of(s.m[i]); } uint32_t total = dur(f, (int)f.pr->delay); if (total < 1) total = 1; float hw = (f.pr->n[2] > 0 ? f.pr->n[2] : 200) / 2000.0f; float trail = (f.pr->n[3] > 0 ? f.pr->n[3] : 0) / 1000.0f; bool keep = f.pr->n[4] == 1; uint32_t t = f.t; bool done = !f.pr->autorun && t >= total; float p = done ? 1.0f : (float)(t % total) / total; float head = -hw + p * (1 + 2 * hw + trail); for (int i = 0; i < n; i++) { float d = s.m[i] - head; float k; if (d > hw) { k = 0; } else if (d >= -hw) { k = (keep && d < 0) ? 1.0f : 1 - fabsf(d) / hw; } else if (keep) { k = 1; } else if (trail > 0) { k = 1 + (d + hw) / trail; if (k < 0) k = 0; } else { k = 0; } put(f, i, rig_entry(f, c, nc, RIG_SHADES, s.shade[i], (int)(k * top))); } return done; }