/* ============================================================================= * SleelaUI Mood / Wash / Calculus-8 / millimetre light placement. * * Backs sleela_ui_mood.h. * * CALCULUS-8. The 100 differentiable inputs x[0..99] are partitioned into eight * groups. Each of the eight stages forms a weighted aggregate a_s = sum(w_i*x_i) * over its group and applies a smooth, analytically-differentiable basis phi_s: * * stage 0 identity phi(a) = a * stage 1 quadratic phi(a) = a^2 * stage 2 smoothstep phi(a) = 3a^2 - 2a^3 * stage 3 sine phi(a) = (sin(2pi a)+1)/2 * stage 4 cosine phi(a) = (cos(2pi a)+1)/2 * stage 5 logistic phi(a) = 1/(1+e^-k(a-.5)) * stage 6 gaussian phi(a) = e^-((a-.5)^2 / 2s^2) * stage 7 tanh phi(a) = (tanh(k(a-.5))+1)/2 * * The mood scalar is M = logistic( sum_s beta_s * phi_s(a_s) ). Every function * is C-infinity, so dM/dx_j exists and is computed by the chain rule (no finite * differences). Nudging any input moves the mood smoothly; eval returns the * slope dM/dx[wrt] so an adjuster can walk the gradient into a mood. * * WASH. A multi-stop colour field sampled with smoothstep between stops -> a * soft "excellent wash" rather than hard bands. * * TANOR. A portrait glow for lightless bulbs; its refresh + a little-left bias * freshen the wash sample point over time. * * Max Rupplin -- MEARVK LLC -- 2026 * ===========================================================================*/ #include "sleela_ui_mood.h" #include "slui_geometry.hpp" #include #include #include #include using slui::Color; namespace { constexpr double kPi = 3.14159265358979323846; Color decode(SLUIColor c) { return Color{static_cast((c >> 24) & 0xFF), static_cast((c >> 16) & 0xFF), static_cast((c >> 8) & 0xFF), static_cast(c & 0xFF)}; } double clampd(double v, double lo, double hi) { return v < lo ? lo : (v > hi ? hi : v); } double logistic(double z) { return 1.0 / (1.0 + std::exp(-z)); } } // namespace /* ========================================================================== * Millimetre placement * ========================================================================== */ extern "C" { SLUIMm slui_mm(double right_mm, double down_mm, double height_mm) { SLUIMm m; m.right_mm = right_mm; m.down_mm = down_mm; m.height_mm = height_mm; return m; } SLUIMm slui_mm_left(double mm, double height_mm) { return slui_mm(-mm, 0, height_mm); } SLUIMm slui_mm_right(double mm, double height_mm) { return slui_mm(mm, 0, height_mm); } SLUIMm slui_mm_up(double mm, double height_mm) { return slui_mm(0, -mm, height_mm); } SLUIMm slui_mm_down(double mm, double height_mm) { return slui_mm(0, mm, height_mm); } double slui_mm_to_px(double mm, double dpi) { if (dpi <= 0) dpi = 96.0; return mm * dpi / 25.4; /* 25.4 mm per inch */ } SLUILight slui_light_place_mm(SLUILight* light, double ref_x, double ref_y, SLUIMm mm, double dpi) { SLUILight l = light ? *light : SLUILight{}; double px = slui_mm_to_px(mm.right_mm, dpi); double py = slui_mm_to_px(mm.down_mm, dpi); double pz = slui_mm_to_px(mm.height_mm, dpi); /* The ground point directly under the light is the font origin shifted by * the horizontal/vertical mm; the light shines down from height pz. */ l.x = ref_x + px; l.y = ref_y + py; l.z = pz > 0 ? pz : l.z; if (light) *light = l; return l; } /* ========================================================================== * Excellent Wash * ========================================================================== */ SLUIWash slui_wash_begin(void) { SLUIWash w; std::memset(&w, 0, sizeof(w)); w.softness = 0.5; return w; } SLUIWash slui_wash_stop(SLUIWash w, double position, SLUIColor color) { if (w.count < SLUI_WASH_MAX_STOPS) { w.pos[w.count] = clampd(position, 0.0, 1.0); w.color[w.count] = color; ++w.count; } return w; } SLUIWash slui_wash_linear(SLUIColor a, SLUIColor b) { SLUIWash w = slui_wash_begin(); w = slui_wash_stop(w, 0.0, a); w = slui_wash_stop(w, 1.0, b); return w; } SLUIWash slui_wash_triad(SLUIColor a, SLUIColor b, SLUIColor c) { SLUIWash w = slui_wash_begin(); w = slui_wash_stop(w, 0.0, a); w = slui_wash_stop(w, 0.5, b); w = slui_wash_stop(w, 1.0, c); return w; } SLUIColor slui_wash_sample(const SLUIWash* wash, double t) { if (!wash || wash->count == 0) return 0x000000FF; if (wash->count == 1) return wash->color[0]; t = clampd(t, 0.0, 1.0); /* copy + sort stops by position */ int n = wash->count; int idx[SLUI_WASH_MAX_STOPS]; for (int i = 0; i < n; ++i) idx[i] = i; std::sort(idx, idx + n, [&](int a, int b) { return wash->pos[a] < wash->pos[b]; }); if (t <= wash->pos[idx[0]]) return wash->color[idx[0]]; if (t >= wash->pos[idx[n - 1]]) return wash->color[idx[n - 1]]; for (int i = 1; i < n; ++i) { double p0 = wash->pos[idx[i - 1]], p1 = wash->pos[idx[i]]; if (t <= p1) { double u = (p1 > p0) ? (t - p0) / (p1 - p0) : 0.0; /* smoothstep for a soft wash, extra-softened by `softness` */ double s = u * u * (3.0 - 2.0 * u); s = u + (s - u) * clampd(wash->softness, 0.0, 1.0); Color a = decode(wash->color[idx[i - 1]]); Color b = decode(wash->color[idx[i]]); return slui::lerp(a, b, s).to_abi(); } } return wash->color[idx[n - 1]]; } /* ========================================================================== * Natural Tanor * ========================================================================== */ SLUITanor slui_tanor_default(void) { SLUITanor t; t.warmth = 0.72; /* warm */ t.diffusion = 0.8; /* soft, portrait */ t.refresh_hz = 0.5; /* a gentle freshen twice a second */ t.left_bias = 0.2; /* a little left */ t.depth = 0.6; t.tone = slui_rgb(0xFF, 0xE6, 0xC6); /* warm portrait tone */ return t; } } // extern "C" /* ========================================================================== * Calculus-8 * ========================================================================== */ struct SLUICalculus8 { double x[SLUI_CALC8_INPUTS]; /* per-stage group weights and the stage mixing weights beta. Fixed, chosen * for a balanced "careful" feel; deterministic so moods are reproducible. */ double beta[SLUI_CALC8_STAGES]; SLUICalculus8() { for (int i = 0; i < SLUI_CALC8_INPUTS; ++i) x[i] = 0.5; /* stages weighted so no single basis dominates the mood */ const double b[SLUI_CALC8_STAGES] = {0.9, 0.7, 1.1, 0.8, 0.8, 1.2, 1.0, 1.0}; for (int s = 0; s < SLUI_CALC8_STAGES; ++s) beta[s] = b[s]; } /* input i belongs to stage i%8; its weight within the stage is a smooth * 1/(1+rank) taper so early inputs in a group matter a little more. */ static int stage_of(int i) { return i % SLUI_CALC8_STAGES; } static double in_weight(int i) { int rank = i / SLUI_CALC8_STAGES; /* 0..12 */ return 1.0 / (1.0 + 0.25 * rank); } }; namespace { /* basis value and derivative wrt its aggregate a, for stage s. */ void basis(int s, double a, double& val, double& dval) { switch (s) { case 0: /* identity */ val = a; dval = 1.0; break; case 1: /* quadratic */ val = a * a; dval = 2.0 * a; break; case 2: /* smoothstep */ val = a * a * (3.0 - 2.0 * a); dval = 6.0 * a - 6.0 * a * a; break; case 3: /* sine, mapped to [0,1] */ val = (std::sin(2.0 * kPi * a) + 1.0) * 0.5; dval = kPi * std::cos(2.0 * kPi * a); break; case 4: /* cosine, mapped to [0,1] */ val = (std::cos(2.0 * kPi * a) + 1.0) * 0.5; dval = -kPi * std::sin(2.0 * kPi * a); break; case 5: { /* logistic around 0.5, steepness k */ double k = 6.0; double z = k * (a - 0.5); double L = logistic(z); val = L; dval = k * L * (1.0 - L); break; } case 6: { /* gaussian around 0.5 */ double s2 = 0.12; /* variance-ish */ double d = a - 0.5; double g = std::exp(-(d * d) / (2.0 * s2)); val = g; dval = g * (-d / s2); break; } case 7: { /* tanh around 0.5 */ double k = 5.0; double th = std::tanh(k * (a - 0.5)); val = (th + 1.0) * 0.5; dval = 0.5 * k * (1.0 - th * th); break; } default: val = a; dval = 1.0; break; } } } // namespace extern "C" { SLUICalculus8* slui_calc8_create(void) { return new SLUICalculus8(); } void slui_calc8_destroy(SLUICalculus8* c) { delete c; } void slui_calc8_set(SLUICalculus8* c, int i, double v) { if (c && i >= 0 && i < SLUI_CALC8_INPUTS) c->x[i] = clampd(v, 0.0, 1.0); } double slui_calc8_get(const SLUICalculus8* c, int i) { if (!c || i < 0 || i >= SLUI_CALC8_INPUTS) return 0.0; return c->x[i]; } void slui_calc8_set_all(SLUICalculus8* c, const double* v, int n) { if (!c || !v) return; int m = std::min(n, SLUI_CALC8_INPUTS); for (int i = 0; i < m; ++i) c->x[i] = clampd(v[i], 0.0, 1.0); } /* Shared evaluation: aggregates a_s, basis values g_s, and the pre-squash sum. * Fills optional per-stage g[] and the aggregates and their basis derivatives * so the derivative wrt any input is a chain-rule away. */ static double calc8_core(const SLUICalculus8* c, double g[SLUI_CALC8_STAGES], double dbasis[SLUI_CALC8_STAGES], double agg[SLUI_CALC8_STAGES]) { double a[SLUI_CALC8_STAGES] = {0, 0, 0, 0, 0, 0, 0, 0}; double wsum[SLUI_CALC8_STAGES] = {0, 0, 0, 0, 0, 0, 0, 0}; for (int i = 0; i < SLUI_CALC8_INPUTS; ++i) { int s = SLUICalculus8::stage_of(i); double w = SLUICalculus8::in_weight(i); a[s] += w * c->x[i]; wsum[s] += w; } double pre = 0.0; for (int s = 0; s < SLUI_CALC8_STAGES; ++s) { double as = wsum[s] > 0 ? a[s] / wsum[s] : 0.0; /* normalise to [0,1] */ agg[s] = as; double val, dval; basis(s, as, val, dval); g[s] = val; dbasis[s] = dval / (wsum[s] > 0 ? wsum[s] : 1.0); /* d a_s / d x within */ pre += c->beta[s] * val; } return pre; } double slui_calc8_eval(const SLUICalculus8* c, int wrt, double* derivative) { if (!c) { if (derivative) *derivative = 0.0; return 0.5; } double g[SLUI_CALC8_STAGES], db[SLUI_CALC8_STAGES], agg[SLUI_CALC8_STAGES]; double pre = calc8_core(c, g, db, agg); double M = logistic(pre - static_cast(SLUI_CALC8_STAGES) * 0.5); if (derivative) { double dM = 0.0; if (wrt >= 0 && wrt < SLUI_CALC8_INPUTS) { int s = SLUICalculus8::stage_of(wrt); double w = SLUICalculus8::in_weight(wrt); /* d pre / d x_wrt = beta_s * phi'_s(a_s) * (w / wsum_s). db[s] * already folded (1/wsum_s); multiply by this input's weight. */ double dpre = c->beta[s] * db[s] * w; dM = M * (1.0 - M) * dpre; /* logistic chain rule */ } *derivative = dM; } return M; } int slui_calc8_stages(const SLUICalculus8* c, double* out, int cap) { if (!c || !out) return 0; double g[SLUI_CALC8_STAGES], db[SLUI_CALC8_STAGES], agg[SLUI_CALC8_STAGES]; calc8_core(c, g, db, agg); int n = std::min(cap, SLUI_CALC8_STAGES); for (int s = 0; s < n; ++s) out[s] = c->beta[s] * g[s]; return n; } } // extern "C" /* ========================================================================== * Mood * ========================================================================== */ struct SLUIMood { SLUIMoodKind kind = SLUI_MOOD_CALM; SLUIWash wash; SLUITanor tanor; const SLUICalculus8* calc = nullptr; /* borrowed */ }; /* Build the tasteful default wash for a built-in mood kind. */ static SLUIWash default_wash(SLUIMoodKind k) { switch (k) { case SLUI_MOOD_WARM: return slui_wash_triad(slui_rgb(0xFF, 0xD9, 0x9A), slui_rgb(0xFF, 0xA8, 0x4C), slui_rgb(0xC8, 0x5A, 0x22)); case SLUI_MOOD_COOL: return slui_wash_triad(slui_rgb(0xBF, 0xE6, 0xFF), slui_rgb(0x6E, 0xA8, 0xE8), slui_rgb(0x3A, 0x5C, 0xA8)); case SLUI_MOOD_VIVID: return slui_wash_triad(slui_rgb(0xFF, 0xE0, 0x66), slui_rgb(0xFF, 0x5E, 0x8A), slui_rgb(0x7A, 0x4C, 0xFF)); case SLUI_MOOD_SOMBER: return slui_wash_linear(slui_rgb(0x3A, 0x2E, 0x2A), slui_rgb(0x15, 0x10, 0x0E)); case SLUI_MOOD_TENDER: return slui_wash_triad(slui_rgb(0xFF, 0xE4, 0xEC), slui_rgb(0xF2, 0xB8, 0xC6), slui_rgb(0xD6, 0x8F, 0xA6)); case SLUI_MOOD_RADIANT: return slui_wash_triad(slui_rgb(0xFF, 0xFB, 0xE8), slui_rgb(0xFF, 0xD9, 0x7A), slui_rgb(0xFF, 0xAE, 0x3C)); case SLUI_MOOD_CALM: default: return slui_wash_triad(slui_rgb(0xEF, 0xE6, 0xD8), slui_rgb(0xCF, 0xB8, 0x9C), slui_rgb(0x9A, 0x7E, 0x62)); } } extern "C" { SLUIMood* slui_mood_create(SLUIMoodKind kind) { auto* m = new (std::nothrow) SLUIMood(); if (!m) return nullptr; m->kind = kind; m->tanor = slui_tanor_default(); if (kind != SLUI_MOOD_CUSTOM) m->wash = default_wash(kind); else m->wash = slui_wash_begin(); /* temper the default tanor to the mood */ if (kind == SLUI_MOOD_COOL) { m->tanor.warmth = 0.25; m->tanor.tone = slui_rgb(0xCF,0xE4,0xFF); } else if (kind == SLUI_MOOD_SOMBER) { m->tanor.depth = 0.9; m->tanor.refresh_hz = 0.2; } else if (kind == SLUI_MOOD_VIVID) { m->tanor.refresh_hz = 1.5; m->tanor.left_bias = 0.35; } return m; } void slui_mood_destroy(SLUIMood* m) { delete m; } void slui_mood_set_wash(SLUIMood* m, SLUIWash w) { if (m) m->wash = w; } void slui_mood_set_tanor(SLUIMood* m, SLUITanor t) { if (m) m->tanor = t; } void slui_mood_set_calculus(SLUIMood* m, const SLUICalculus8* c) { if (m) m->calc = c; } SLUIWash slui_mood_wash(const SLUIMood* m) { return m ? m->wash : slui_wash_begin(); } SLUITanor slui_mood_tanor(const SLUIMood* m) { return m ? m->tanor : slui_tanor_default(); } SLUIColor slui_mood_color(const SLUIMood* m, double time_s) { if (!m) return 0xFFFFFFFF; /* where to sample the wash: the calculus's mood scalar, drifted by the * tanor's refresh + a little-left bias so a lightless bulb freshens. */ double base = 0.5; if (m->calc) base = slui_calc8_eval(m->calc, -1, nullptr); double phase = (m->tanor.refresh_hz > 0) ? std::sin(2.0 * kPi * m->tanor.refresh_hz * time_s) : 0.0; /* "a little left": the drift is biased negative (toward the wash start). */ double drift = phase * 0.08 - m->tanor.left_bias * 0.06; double t = clampd(base + drift, 0.0, 1.0); SLUIColor washed = slui_wash_sample(&m->wash, t); /* fold the tanor tone in by its warmth so the portrait glow tints it */ Color w = decode(washed), tone = decode(m->tanor.tone); double k = clampd(m->tanor.warmth * 0.35, 0.0, 1.0); return slui::lerp(w, tone, k).to_abi(); } void slui_light_apply_mood(SLUILight* light, const SLUIMood* m, double time_s) { if (!light || !m) return; light->color = slui_mood_color(m, time_s); /* the tanor's diffusion softens the light; its depth lifts intensity a bit * so a lightless-bulb glow reads as present without a hard source. */ light->softness = clampd(0.3 + m->tanor.diffusion * 0.6, 0.0, 1.0); light->intensity *= (0.85 + m->tanor.depth * 0.3); } SLUILight slui_light_for_text(double font_x, double font_baseline, SLUIMm mm, double dpi, const SLUIMood* mood, double time_s, SLUILightRole role, SLUIPolarity polarity, double reach_px, double intensity) { SLUILight l = slui_light_point(font_x, font_baseline, reach_px, intensity, 0xFFFFFFFF); l.role = role; l.polarity = polarity; slui_light_place_mm(&l, font_x, font_baseline, mm, dpi); if (mood) slui_light_apply_mood(&l, mood, time_s); return l; } } // extern "C"