The hub's living backgrounds in the app: the mark at sign-in, Your sky on the dashboard, live runs pulse (refs #23) 1dfa631436b6

package io.oxygenhub.android.ui.backdrop

import android.content.Context

import android.os.PowerManager

import android.provider.Settings

import androidx.compose.animation.core.animateFloatAsState

import androidx.compose.animation.core.tween

import androidx.compose.foundation.Canvas

import androidx.compose.foundation.layout.Box

import androidx.compose.foundation.layout.BoxScope

import androidx.compose.foundation.layout.fillMaxSize

import androidx.compose.foundation.layout.offset

import androidx.compose.foundation.layout.padding

import androidx.compose.material3.MaterialTheme

import androidx.compose.material3.Surface

import androidx.compose.material3.Text

import androidx.compose.runtime.Composable

import androidx.compose.runtime.DisposableEffect

import androidx.compose.runtime.LaunchedEffect

import androidx.compose.runtime.getValue

import androidx.compose.runtime.mutableIntStateOf

import androidx.compose.runtime.mutableLongStateOf

import androidx.compose.runtime.mutableStateOf

import androidx.compose.runtime.remember

import androidx.compose.runtime.setValue

import androidx.compose.ui.Modifier

import androidx.compose.ui.draw.alpha

import androidx.compose.ui.geometry.Offset

import androidx.compose.ui.graphics.Brush

import androidx.compose.ui.graphics.Color

import androidx.compose.ui.graphics.Path

import androidx.compose.ui.graphics.drawscope.DrawScope

import androidx.compose.ui.graphics.drawscope.Stroke

import androidx.compose.ui.graphics.luminance

import androidx.compose.ui.input.pointer.PointerEventPass

import androidx.compose.ui.input.pointer.pointerInput

import androidx.compose.ui.layout.onSizeChanged

import androidx.compose.ui.platform.LocalContext

import androidx.compose.ui.platform.LocalDensity

import androidx.compose.ui.unit.IntOffset

import androidx.compose.ui.unit.IntSize

import androidx.compose.ui.unit.dp

import io.oxygenhub.android.ui.theme.LocalStatusColors

import kotlinx.coroutines.isActive

import uniffi.rust_core.BackdropLabel

import java.nio.ByteBuffer

import java.nio.ByteOrder

import kotlin.math.roundToInt

import uniffi.rust_core.Backdrop as Scene

/**

 * The website's living backgrounds (#23, the hub's docs/backgrounds.md):

 * one of the hub's own scenes, stepped in rust-core and drawn here as its

 * WebGL draws them in a browser, behind [content]. A finger is its cursor:

 * the touches pass through to the content and the scene sees them too.

 *

 * As on the web, drawing halves its rate 3 s after the last touch and stops

 * after 2 minutes, until the next; it holds still when the system's

 * animations are off or battery saver is on.

 */

@Composable

fun Backdrop(

    key: Any?,

    make: (still: Boolean) -> Scene,

    modifier: Modifier = Modifier,

    content: @Composable BoxScope.() -> Unit,

) {

    val context = LocalContext.current

    val still = remember(context) { backdropStill(context) }

    val scene = remember(key, still) { make(still) }

    DisposableEffect(scene) { onDispose { scene.close() } }

    val colours = backdropColours()

    val dark = MaterialTheme.colorScheme.background.luminance() < 0.5f

    val density = LocalDensity.current.density

    var size by remember { mutableStateOf(IntSize.Zero) }

    var frame by remember(scene) { mutableStateOf(Frame.EMPTY) }

    var label by remember(scene) { mutableStateOf<BackdropLabel?>(null) }

    var touchedAt by remember(scene) { mutableLongStateOf(System.nanoTime()) }

    var running by remember(scene) { mutableStateOf(false) }

    var wake by remember(scene) { mutableIntStateOf(0) }

    LaunchedEffect(scene, colours) { scene.colours(colours) }

    LaunchedEffect(scene, size, colours, wake) {

        if (size == IntSize.Zero) return@LaunchedEffect

        scene.resize(size.width / density, size.height / density)

        running = true

        var last = -1L

        var n = 0

        while (isActive) {

            val more = androidx.compose.runtime.withFrameNanos { t ->

                val idle = (System.nanoTime() - touchedAt) / 1e9

                n++

                if (!still && idle > HALF_RATE_AFTER_S && n % 2 == 1) return@withFrameNanos true

                val dt = if (last < 0) 0f else ((t - last) / 1e9).toFloat()

                last = t

                val busy = scene.step(dt)

                frame = Frame.of(scene.frame())

                label = scene.label()

                if (still) busy else idle < STOP_AFTER_S || busy

            }

            if (!more) break

        }

        running = false

    }

    Box(

        modifier

            .onSizeChanged { size = it }

            .pointerInput(scene) {

                awaitPointerEventScope {

                    while (true) {

                        // Seen on the way down, never consumed: the content scrolls and taps as before.

                        val e = awaitPointerEvent(PointerEventPass.Initial)

                        val p = e.changes.firstOrNull() ?: continue

                        scene.point(p.position.x / density, p.position.y / density, p.pressed)

                        touchedAt = System.nanoTime()

                        if (!running) wake++

                    }

                }

            },

    ) {

        Canvas(Modifier.fillMaxSize()) { draw(frame, density, dark) }

        Label(label, density)

        content()

    }

}

/** The name a resting finger shows, centred above the cluster, fading in and out (the web's `.backdrop-label`). */

@Composable

private fun Label(label: BackdropLabel?, density: Float) {

    // The last name stays while it fades out.

    val held = remember { arrayOfNulls<BackdropLabel>(1) }

    if (label != null) held[0] = label

    val alpha by animateFloatAsState(if (label != null) 1f else 0f, tween(220), label = "label")

    val l = held[0] ?: return

    var box by remember { mutableStateOf(IntSize.Zero) }

    Surface(

        shape = MaterialTheme.shapes.small,

        color = MaterialTheme.colorScheme.surface.copy(alpha = 0.85f),

        tonalElevation = 2.dp,

        modifier = Modifier

            .offset { IntOffset((l.x * density - box.width / 2f).roundToInt(), (l.y * density - box.height - 8 * density).roundToInt()) }

            .onSizeChanged { box = it }

            .alpha(alpha),

    ) {

        Text(l.text, style = MaterialTheme.typography.labelMedium, modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp))

    }

}

/** A frame's floats: marks 8 each (x, y, size, shape, premultiplied rgba), links 12 each (two ends of x, y, rgba). */

internal class Frame(val marks: FloatArray, val links: FloatArray) {

    companion object {

        val EMPTY = Frame(FloatArray(0), FloatArray(0))

        fun of(f: uniffi.rust_core.BackdropFrame) = Frame(floats(f.marks), floats(f.links))

        fun floats(b: ByteArray): FloatArray {

            val out = FloatArray(b.size / 4)

            ByteBuffer.wrap(b).order(ByteOrder.LITTLE_ENDIAN).asFloatBuffer().get(out)

            return out

        }

    }

}

/** A premultiplied colour back to a straight one. */

internal fun straight(r: Float, g: Float, b: Float, a: Float): Color =

    if (a <= 0f) Color.Transparent else Color((r / a).coerceIn(0f, 1f), (g / a).coerceIn(0f, 1f), (b / a).coerceIn(0f, 1f), a.coerceIn(0f, 1f))

private val path = Path()

private fun DrawScope.draw(f: Frame, density: Float, dark: Boolean) {

    val l = f.links

    var i = 0

    while (i + 12 <= l.size) {

        val a = Offset(l[i] * density, l[i + 1] * density)

        val b = Offset(l[i + 6] * density, l[i + 7] * density)

        val ca = straight(l[i + 2], l[i + 3], l[i + 4], l[i + 5])

        val cb = straight(l[i + 8], l[i + 9], l[i + 10], l[i + 11])

        drawLine(Brush.linearGradient(listOf(ca, cb), a, b), a, b, strokeWidth = density)

        i += 12

    }

    val m = f.marks

    i = 0

    while (i + 8 <= m.size) {

        val c = Offset(m[i] * density, m[i + 1] * density)

        val s = m[i + 2] * density

        val colour = straight(m[i + 4], m[i + 5], m[i + 6], m[i + 7])

        // On a dark page a lit mark glows a little, as the web's do on a bright screen.

        if (dark && colour.alpha > 0.5f) drawCircle(colour.copy(alpha = colour.alpha * 0.14f), s * 2.6f, c)

        mark(c, s, m[i + 3].roundToInt(), colour)

        i += 8

    }

}

/** One mark, as the hub's fragment shader draws it (crates/backdrop/src/gl.rs). */

private fun DrawScope.mark(c: Offset, s: Float, shape: Int, colour: Color) {

    when (shape) {

        0 -> drawCircle(colour, s, c) // a push: a dot

        1 -> polygon(c, colour, floatArrayOf(1f, 0f, 0f, 1f, -1f, 0f, 0f, -1f), s / 0.85f) // a proposal: a diamond

        2 -> drawCircle(colour, s * 0.72f, c, style = Stroke(s * 0.56f)) // an issue: a ring

        3 -> polygon(c, colour, STAR, s) // a release: a star

        4 -> drawCircle(colour, s * 0.85f, c, style = Stroke(s * 0.24f)) // a repository: a thin ring

        else -> { // a Flow run: a square

            val h = s / 1.15f

            drawRect(colour, Offset(c.x - h, c.y - h), androidx.compose.ui.geometry.Size(2 * h, 2 * h))

        }

    }

}

/** The shader's four-pointed star: two thin diamonds crossed, meeting at 1/4.5. */

private val STAR = (1f / 4.5f).let { k -> floatArrayOf(1f, 0f, k, k, 0f, 1f, -k, k, -1f, 0f, -k, -k, 0f, -1f, k, -k) }

private fun DrawScope.polygon(c: Offset, colour: Color, unit: FloatArray, r: Float) {

    path.reset()

    path.moveTo(c.x + unit[0] * r, c.y + unit[1] * r)

    var j = 2

    while (j < unit.size) {

        path.lineTo(c.x + unit[j] * r, c.y + unit[j + 1] * r)

        j += 2

    }

    path.close()

    drawPath(path, colour)

}

/**

 * The scene's colours from the theme, as the hub's CSS gives the web's:

 * `--bd-mark`, `--bd-lit` and `--bd-link`, then ok, warn and bad.

 */

@Composable

private fun backdropColours(): List<Float> {

    val dark = MaterialTheme.colorScheme.background.luminance() < 0.5f

    val s = LocalStatusColors.current

    val (mark, lit, link) = if (dark) {

        Triple(Color(0, 224, 240).copy(alpha = 0.12f), Color(0, 240, 255).copy(alpha = 0.85f), Color(0, 240, 255).copy(alpha = 0.35f))

    } else {

        Triple(Color(95, 106, 129).copy(alpha = 0.18f), Color(0, 100, 224).copy(alpha = 0.7f), Color(0, 100, 224).copy(alpha = 0.25f))

    }

    return remember(dark, s) { listOf(mark, lit, link, s.ok, s.warn, s.bad).flatMap { listOf(it.red, it.green, it.blue, it.alpha) } }

}

/** Still, as the web is under prefers-reduced-motion: the system's animations off, or battery saver on. */

private fun backdropStill(context: Context): Boolean {

    val scale = Settings.Global.getFloat(context.contentResolver, Settings.Global.ANIMATOR_DURATION_SCALE, 1f)

    val saver = context.getSystemService(PowerManager::class.java)?.isPowerSaveMode == true

    return scale == 0f || saver

}

/** As the hub's engine (crates/backdrop/src/lib.rs): a still finger halves the rate after 3 s; 2 minutes stops it. */

private const val HALF_RATE_AFTER_S = 3.0

private const val STOP_AFTER_S = 120.0

package io.oxygenhub.android.ui.backdrop

import io.oxygenhub.android.api.UserSky

import uniffi.rust_core.SkyEvent

import uniffi.rust_core.Backdrop as Scene

/** Your sky's events for the scene: each aged by the hub's clock, in days; malformed ones left out. */

fun skyEvents(sky: UserSky): List<SkyEvent> = sky.events.mapNotNull { e ->

    if (e.size < 4 || e[0] !in sky.repos.indices || e[1] !in 0L..4L) return@mapNotNull null

    SkyEvent(e[0].toUInt(), e[1].toUInt(), ((sky.now - e[2]).coerceAtLeast(0) / 86_400_000.0).toFloat(), e[3].coerceIn(1, 10_000).toUInt())

}

/** Your sky, as on the hub's dashboard; the quiet field when there is nothing of yours to draw. */

fun skyScene(sky: UserSky?, still: Boolean): Scene =

    if (sky == null || sky.repos.isEmpty()) Scene.adrift(still) else Scene.sky(sky.repos, skyEvents(sky), 0f, 0f, still)

// Copied from OxygenHub crates/backdrop/src/adrift.rs (6dc080f6) by

// scripts/sync-backdrop.sh: change it there, never here.

//! Adrift (docs/backgrounds.md §2): the not-found and server-error pages.

//! A quiet cluster in the margin, and one mark drifting away from it, as

//! the page drifted from what was asked for. It drifts for a minute, fades

//! and sets out again. No data.

use crate::backdrop::field::{knot, margins, unit, Dot, Field, Orbit, ZOOM};

use crate::backdrop::scene::Scene;

use crate::backdrop::sky::{hash, Colours};

const CLUSTER: usize = 160;

/// The lost mark's speed, and how long one drift lasts, fade included.

const DRIFT_SPEED: f32 = 7.0;

const DRIFT_S: f32 = 70.0;

const FADE_S: f32 = 5.0;

pub struct Adrift {

    field: Field,

    orbits: Vec<Orbit>,

    centre: (f32, f32),

    w: f32,

    h: f32,

    t: f32,

}

impl Adrift {

    pub fn new(still: bool) -> Adrift {

        let mut field = Field::new(still);

        let orbits = knot("adrift", CLUSTER);

        for k in 0..CLUSTER {

            let h = hash(&format!("adrift@{k}"));

            let mut d = Dot::new(0.0, 0.0, 2.0 * ZOOM, if k % 7 == 0 { 2.0 } else { 0.0 });

            d.bright = 0.5 + 0.5 * unit(h, 48);

            d.group = 0;

            d.order = k as u32;

            field.dots.push(d);

        }

        // The cluster's core, and the lost mark, a little larger.

        field.dots.push(Dot::new(0.0, 0.0, 8.0, 4.0));

        let mut lost = Dot::new(0.0, 0.0, 3.4 * ZOOM, 0.0);

        lost.bright = 1.0;

        field.dots.push(lost);

        let mut a = Adrift { field, orbits, centre: (0.0, 0.0), w: 0.0, h: 0.0, t: 12.0 };

        a.place();

        a

    }

    fn place(&mut self) {

        let (cx, cy) = self.centre;

        for (i, o) in self.orbits.iter().enumerate() {

            let (x, y) = o.at((cx, cy), self.t);

            self.field.dots[i].x = x;

            self.field.dots[i].y = y;

        }

        let core = &mut self.field.dots[CLUSTER];

        core.x = cx;

        core.y = cy;

        // The lost mark leaves up and to the right, fading at the end of

        // each drift and setting out again from the cluster's edge.

        let p = self.t % DRIFT_S;

        let dir: f32 = -0.35;

        let from = self.orbits.iter().map(|o| o.radius).fold(0.0, f32::max) + 14.0;

        let lost = &mut self.field.dots[CLUSTER + 1];

        lost.x = cx + dir.cos() * (from + p * DRIFT_SPEED);

        lost.y = cy + dir.sin() * (from + p * DRIFT_SPEED);

        lost.bright = ((DRIFT_S - p) / FADE_S).min(p / FADE_S).clamp(0.0, 1.0);

    }

}

impl Scene for Adrift {

    fn resize(&mut self, w: f32, h: f32, avoid: Option<(f32, f32)>) {

        self.w = w;

        self.h = h;

        self.centre = match margins(w, avoid) {

            Some((l, _)) => (l * 0.45, h * 0.62),

            None => (w * 0.15, h * 0.7),

        };

        self.place();

    }

    fn point(&mut self, at: Option<(f32, f32)>) {

        self.field.point(at);

    }

    fn step(&mut self, dt: f32) {

        if !self.field.still {

            self.t += dt.clamp(0.0, 0.1);

        }

        self.place();

        self.field.light(dt);

    }

    fn instances(&self, c: &Colours, out: &mut Vec<f32>) {

        self.field.instances(c, out)

    }

    fn links(&self, c: &Colours, out: &mut Vec<f32>) {

        self.field.links(c, out)

    }

    fn label(&self) -> Option<(&str, f32, f32)> {

        None

    }

    fn busy(&self) -> bool {

        self.field.easing()

    }

    fn still(&self) -> bool {

        self.field.still

    }

    fn size(&self) -> (f32, f32) {

        (self.w, self.h)

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn one_mark_drifts_away_from_the_cluster_and_sets_out_again() {

        let mut a = Adrift::new(false);

        a.resize(2560.0, 1270.0, Some((707.0, 1838.0)));

        assert!(a.centre.0 < 707.0, "the cluster sits in the margin");

        let dist = |a: &Adrift| {

            let l = &a.field.dots[CLUSTER + 1];

            (l.x - a.centre.0).hypot(l.y - a.centre.1)

        };

        let early = dist(&a);

        for _ in 0..200 {

            a.step(0.1);

        }

        assert!(dist(&a) > early + 100.0, "it drifts away");

        for _ in 0..500 {

            a.step(0.1);

        }

        assert!(dist(&a) < early + 100.0, "and sets out again");

    }

}

// Copied from OxygenHub crates/backdrop/src/field.rs (6dc080f6) by

// scripts/sync-backdrop.sh: change it there, never here.

//! What every scene but the sky shares (docs/backgrounds.md §4): a field

//! of dots that its scene places each frame, lit by the cursor without

//! being moved, joined within a group in order, and named things that a

//! resting cursor names. Dots of a scene with a status (Diffusion's pills)

//! take the page's status colours; every other dot the backdrop tokens.

use crate::backdrop::sky::{Colours, Rgba};

/// How far the cursor lights dots, in CSS pixels, as in the sky.

pub const LIGHT_RADIUS: f32 = 170.0;

const LIT_IN: f32 = 0.15;

const LIT_OUT: f32 = 0.6;

/// The longest link drawn between two dots of a group.

const LINK_MAX: f32 = 85.0;

const LINK_REST: f32 = 2.0;

const LABEL_NEAR: f32 = 110.0;

const LABEL_REST: f32 = 0.4;

/// A dot's colour: the backdrop's own, or a status where the data has one.

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub enum Tone {

    Mark,

    Ok,

    Warn,

    Bad,

}

impl Tone {

    /// A Diffusion pill half's tone as the page names it.

    pub fn from_name(s: &str) -> Tone {

        match s {

            "green" => Tone::Ok,

            "amber" => Tone::Warn,

            "red" => Tone::Bad,

            _ => Tone::Mark,

        }

    }

}

/// One drawn dot.

#[derive(Clone, Copy, Debug)]

pub struct Dot {

    pub x: f32,

    pub y: f32,

    /// Radius in CSS pixels.

    pub size: f32,

    /// The shader's shape (sky::Kind::shape).

    pub shape: f32,

    pub tone: Tone,

    /// 0 to 1: how strongly it shows at rest.

    pub bright: f32,

    pub lit: f32,

    /// Dots of one group are joined in `order` when lit; `NONE` never.

    pub group: u32,

    pub order: u32,

}

impl Dot {

    pub const NONE: u32 = u32::MAX;

    pub fn new(x: f32, y: f32, size: f32, shape: f32) -> Dot {

        Dot { x, y, size, shape, tone: Tone::Mark, bright: 1.0, lit: 0.0, group: Dot::NONE, order: 0 }

    }

}

/// Something with a name the cursor can rest by.

#[derive(Clone, Debug)]

pub struct Named {

    pub name: String,

    pub x: f32,

    pub y: f32,

    /// How far its dots reach: the label sits just above.

    pub reach: f32,

}

pub struct Field {

    pub dots: Vec<Dot>,

    pub named: Vec<Named>,

    pub cursor: Option<(f32, f32)>,

    pub rested: f32,

    pub still: bool,

    link_fade: f32,

}

impl Field {

    pub fn new(still: bool) -> Field {

        Field { dots: Vec::new(), named: Vec::new(), cursor: None, rested: 0.0, still, link_fade: 0.0 }

    }

    pub fn point(&mut self, at: Option<(f32, f32)>) {

        self.cursor = at;

        self.rested = 0.0;

    }

    /// Light the dots near the cursor, after the scene has placed them.

    pub fn light(&mut self, dt: f32) {

        let dt = dt.clamp(0.0, 0.1);

        self.rested += dt;

        let cursor = self.cursor;

        let still = self.still;

        for d in &mut self.dots {

            let target = match cursor {

                Some((x, y)) if (d.x - x).hypot(d.y - y) <= LIGHT_RADIUS => 1.0,

                _ => 0.0,

            };

            d.lit = if still {

                target

            } else if target > d.lit {

                (d.lit + dt / LIT_IN).min(target)

            } else {

                (d.lit - dt / LIT_OUT).max(target)

            };

        }

        let fade_to = if cursor.is_some() && self.rested < LINK_REST { 1.0 } else { 0.0 };

        self.link_fade = if still {

            fade_to

        } else if fade_to > self.link_fade {

            (self.link_fade + dt / LIT_IN).min(1.0)

        } else {

            (self.link_fade - dt / LIT_OUT).max(0.0)

        };

    }

    /// Whether lighting or links are still easing.

    pub fn easing(&self) -> bool {

        self.dots.iter().any(|d| d.lit > 0.0 && d.lit < 1.0) || (self.link_fade > 0.0 && self.link_fade < 1.0)

    }

    fn colour(c: &Colours, tone: Tone, bright: f32, lit: f32) -> Rgba {

        let (rest, hot) = match tone {

            Tone::Mark => (c.mark, c.lit),

            Tone::Ok => (with_alpha(c.ok, 0.45), with_alpha(c.ok, 0.95)),

            Tone::Warn => (with_alpha(c.warn, 0.45), with_alpha(c.warn, 0.95)),

            Tone::Bad => (with_alpha(c.bad, 0.45), with_alpha(c.bad, 0.95)),

        };

        let rest = [rest[0], rest[1], rest[2], rest[3] * bright];

        let t = lit.clamp(0.0, 1.0);

        [

            rest[0] + (hot[0] - rest[0]) * t,

            rest[1] + (hot[1] - rest[1]) * t,

            rest[2] + (hot[2] - rest[2]) * t,

            rest[3] + (hot[3] - rest[3]) * t,

        ]

    }

    /// 8 floats a dot, as sky::Sky::instances lays them out.

    pub fn instances(&self, c: &Colours, out: &mut Vec<f32>) {

        out.clear();

        for d in &self.dots {

            let col = Field::colour(c, d.tone, d.bright, d.lit);

            let size = d.size * (1.0 + 0.35 * d.lit);

            out.extend_from_slice(&[d.x, d.y, size, d.shape, col[0] * col[3], col[1] * col[3], col[2] * col[3], col[3]]);

        }

    }

    /// Lit dots of a group joined in order, where near each other.

    pub fn links(&self, c: &Colours, out: &mut Vec<f32>) {

        out.clear();

        if self.link_fade <= 0.0 {

            return;

        }

        let mut lit: Vec<&Dot> = self.dots.iter().filter(|d| d.group != Dot::NONE && d.lit > 0.05).collect();

        lit.sort_by_key(|d| (d.group, d.order));

        for pair in lit.windows(2) {

            let (a, b) = (pair[0], pair[1]);

            if a.group != b.group || (a.x - b.x).hypot(a.y - b.y) > LINK_MAX {

                continue;

            }

            let alpha = c.link[3] * a.lit.min(b.lit) * self.link_fade;

            let col = [c.link[0] * alpha, c.link[1] * alpha, c.link[2] * alpha, alpha];

            out.extend_from_slice(&[a.x, a.y, col[0], col[1], col[2], col[3], b.x, b.y, col[0], col[1], col[2], col[3]]);

        }

    }

    /// The name above the named thing a resting cursor is by.

    pub fn label(&self) -> Option<(&str, f32, f32)> {

        let (x, y) = self.cursor?;

        if self.rested < LABEL_REST {

            return None;

        }

        self.named

            .iter()

            .map(|n| (n, (n.x - x).hypot(n.y - y)))

            .filter(|(n, d)| *d <= LABEL_NEAR.max(n.reach))

            .min_by(|a, b| a.1.total_cmp(&b.1))

            .map(|(n, _)| (n.name.as_str(), n.x, n.y - n.reach - 10.0))

    }

}

fn with_alpha(c: Rgba, a: f32) -> Rgba {

    [c[0], c[1], c[2], a]

}

/// A number from 0 to 1 from bits of a hash (sky::hash).

pub fn unit(h: u64, shift: u32) -> f32 {

    ((h >> shift) & 0xffff) as f32 / 65536.0

}

/// One dot of a knot: its orbit about the knot's centre.

#[derive(Clone, Copy, Debug)]

pub struct Orbit {

    pub radius: f32,

    pub angle: f32,

    /// Radians a second, signed.

    pub speed: f32,

}

impl Orbit {

    pub fn at(&self, centre: (f32, f32), t: f32) -> (f32, f32) {

        let a = self.angle + self.speed * t;

        (centre.0 + a.cos() * self.radius, centre.1 + a.sin() * self.radius)

    }

}

/// `n` dots as a knot like a sky's cluster (sky::Sky, Andy's 2026-10-13

/// tuning): close lanes, more of them the busier, drawn 1.4 times larger,

/// turning one way at the sky's slow speed. `seed` makes it stable.

pub fn knot(seed: &str, n: usize) -> Vec<Orbit> {

    let lanes = (6 + n / 30).min(14) as u32;

    let dir = if crate::backdrop::sky::hash(seed) & 1 == 0 { 1.0 } else { -1.0 };

    (0..n as u32)

        .map(|k| {

            let h = crate::backdrop::sky::hash(&format!("{seed}#{k}"));

            let radius = (16.0 + (k % lanes) as f32 * 6.5 + unit(h, 0) * 4.0) * 1.4;

            let speed = dir * (crate::backdrop::sky::MAX_SPEED / radius).min(0.25) * (0.5 + 0.5 * unit(h, 16));

            Orbit { radius, angle: unit(h, 32) * std::f32::consts::TAU, speed }

        })

        .collect()

}

/// A dot's size drawn as the sky draws its marks (1.4 times larger).

pub const ZOOM: f32 = 1.4;

/// The page's margins beside its content column, when both are wide

/// enough to hold something: (left width, right start).

pub fn margins(w: f32, avoid: Option<(f32, f32)>) -> Option<(f32, f32)> {

    let (x0, x1) = avoid?;

    (x0 >= 180.0 && w - x1 >= 180.0).then_some((x0, x1))

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn the_cursor_lights_and_joins_a_group_and_names_what_it_rests_by() {

        let mut f = Field::new(false);

        for i in 0..4 {

            let mut d = Dot::new(100.0 + i as f32 * 20.0, 100.0, 3.0, 0.0);

            d.group = 0;

            d.order = i;

            f.dots.push(d);

        }

        f.dots.push(Dot::new(900.0, 900.0, 3.0, 0.0));

        f.named.push(Named { name: "earth-1".into(), x: 130.0, y: 100.0, reach: 40.0 });

        f.point(Some((130.0, 100.0)));

        for _ in 0..30 {

            f.light(1.0 / 60.0);

        }

        assert!(f.dots[..4].iter().all(|d| d.lit == 1.0) && f.dots[4].lit == 0.0);

        let c = Colours::default();

        let mut links = Vec::new();

        f.links(&c, &mut links);

        assert_eq!(links.len(), 3 * 12, "three links in order, none to the dot far away");

        assert_eq!(f.label().map(|l| l.0), Some("earth-1"));

        let mut inst = Vec::new();

        f.instances(&c, &mut inst);

        assert_eq!(inst.len(), 5 * 8);

    }

    #[test]

    fn status_tones_come_from_the_pill_names() {

        assert_eq!(Tone::from_name("green"), Tone::Ok);

        assert_eq!(Tone::from_name("amber"), Tone::Warn);

        assert_eq!(Tone::from_name("red"), Tone::Bad);

        assert_eq!(Tone::from_name("grey"), Tone::Mark);

        assert_eq!(margins(2560.0, Some((707.0, 1838.0))), Some((707.0, 1838.0)));

        assert_eq!(margins(1200.0, Some((100.0, 1100.0))), None);

    }

}

// Copied from OxygenHub crates/backdrop/src/mark.rs (6dc080f6) by

// scripts/sync-backdrop.sh: change it there, never here.

//! The mark (docs/backgrounds.md §2): sign in, register and device sign-in.

//! The Oxygen mark's two rings drawn in dots, turning opposite ways so the

//! stream runs through the middle like the mark's infinity, each with its

//! core. Brand only: no data.

use crate::backdrop::field::{unit, Dot, Field, ZOOM};

use crate::backdrop::scene::Scene;

use crate::backdrop::sky::{hash, Colours};

use std::f32::consts::TAU;

/// Dots on the two rings.

const DOTS: usize = 1400;

/// How fast the rings turn, at their rim, in CSS pixels a second.

const RIM_SPEED: f32 = 9.0;

struct Bead {

    ring: usize,

    angle: f32,

    /// Its distance off the ring's line, and its breathing's phase.

    off: f32,

    phase: f32,

}

pub struct Mark {

    field: Field,

    beads: Vec<Bead>,

    w: f32,

    h: f32,

    t: f32,

}

impl Mark {

    pub fn new(still: bool) -> Mark {

        let mut field = Field::new(still);

        let mut beads = Vec::new();

        for i in 0..DOTS {

            let h = hash(&format!("mark#{i}"));

            let ring = i % 2;

            // Off the ring's line by a bell-ish spread, most near it.

            let off = (unit(h, 16) + unit(h, 32) - 1.0) * 18.0;

            beads.push(Bead { ring, angle: unit(h, 0) * TAU, off, phase: unit(h, 48) * TAU });

            let mut d = Dot::new(0.0, 0.0, (1.5 + unit(h, 40) * 1.6) * ZOOM, if i % 11 == 0 { 1.0 } else { 0.0 });

            d.bright = 0.55 + 0.45 * unit(h, 24);

            d.group = ring as u32;

            field.dots.push(d);

        }

        // Join each ring's beads in the order round it.

        for ring in 0..2 {

            let mut idx: Vec<usize> = (0..DOTS).filter(|&i| beads[i].ring == ring).collect();

            idx.sort_by(|&a, &b| beads[a].angle.total_cmp(&beads[b].angle));

            for (k, i) in idx.into_iter().enumerate() {

                field.dots[i].order = k as u32;

            }

        }

        // The two cores.

        for _ in 0..2 {

            field.dots.push(Dot::new(0.0, 0.0, 7.0, 0.0));

        }

        let mut m = Mark { field, beads, w: 0.0, h: 0.0, t: 0.0 };

        m.place();

        m

    }

    /// The rings' radius and centres for this view: large enough to frame

    /// the page, out into its margins, their centres 1.1 radii either side

    /// of the middle, as the mark draws them.

    fn rings(&self) -> (f32, [(f32, f32); 2]) {

        let r = (self.w * 0.2).min(self.h * 0.42).clamp(110.0, 560.0);

        let (cx, cy) = (self.w / 2.0, self.h / 2.0);

        (r, [(cx - r * 1.1, cy), (cx + r * 1.1, cy)])

    }

    fn place(&mut self) {

        let (r, centres) = self.rings();

        let spin = RIM_SPEED / r * self.t;

        for (i, b) in self.beads.iter().enumerate() {

            // The left ring turns one way and the right the other.

            let a = b.angle + if b.ring == 0 { spin } else { -spin };

            let rr = r + b.off + 3.0 * (self.t * 0.4 + b.phase).sin();

            let (cx, cy) = centres[b.ring];

            self.field.dots[i].x = cx + a.cos() * rr;

            self.field.dots[i].y = cy + a.sin() * rr;

        }

        for (k, (cx, cy)) in centres.iter().enumerate() {

            let d = &mut self.field.dots[DOTS + k];

            d.x = *cx;

            d.y = *cy;

        }

    }

}

impl Scene for Mark {

    fn resize(&mut self, w: f32, h: f32, _avoid: Option<(f32, f32)>) {

        self.w = w;

        self.h = h;

        self.place();

    }

    fn point(&mut self, at: Option<(f32, f32)>) {

        self.field.point(at);

    }

    fn step(&mut self, dt: f32) {

        if !self.field.still {

            self.t += dt.clamp(0.0, 0.1);

        }

        self.place();

        self.field.light(dt);

    }

    fn instances(&self, c: &Colours, out: &mut Vec<f32>) {

        self.field.instances(c, out)

    }

    fn links(&self, c: &Colours, out: &mut Vec<f32>) {

        self.field.links(c, out)

    }

    fn label(&self) -> Option<(&str, f32, f32)> {

        None

    }

    fn busy(&self) -> bool {

        self.field.easing()

    }

    fn still(&self) -> bool {

        self.field.still

    }

    fn size(&self) -> (f32, f32) {

        (self.w, self.h)

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn two_rings_turn_opposite_ways_about_their_cores() {

        let mut m = Mark::new(false);

        m.resize(1600.0, 900.0, None);

        let (r, centres) = m.rings();

        assert!(centres[0].0 < 800.0 && centres[1].0 > 800.0);

        for (i, b) in m.beads.iter().enumerate() {

            let (cx, cy) = centres[b.ring];

            let d = (m.field.dots[i].x - cx).hypot(m.field.dots[i].y - cy);

            assert!((d - r).abs() <= 22.0, "on its ring: {d} against {r}");

        }

        let before = (m.field.dots[0].x, m.field.dots[0].y);

        m.step(0.1);

        let moved = (m.field.dots[0].x - before.0).hypot(m.field.dots[0].y - before.1);

        assert!(moved > 0.0 && moved < 2.0, "slow: {moved} px in a tenth of a second");

        assert!(m.label().is_none(), "brand only: nothing to name");

    }

}

//! The hub's backdrop scenes (OxygenHub crates/backdrop), copied by

//! scripts/sync-backdrop.sh: the website's living backgrounds, stepped here

//! and drawn by the app (ui/backdrop).

#![allow(dead_code)]

pub mod adrift;

pub mod field;

pub mod mark;

pub mod ripples;

pub mod scene;

pub mod sky;

pub mod swarm;

// Copied from OxygenHub crates/backdrop/src/ripples.rs (6dc080f6) by

// scripts/sync-backdrop.sh: change it there, never here.

//! Ripples (docs/backgrounds.md §2): a repository's Diffusion tab. The

//! repository in one margin, the upstreams it takes from beside it and the

//! consumers it diffuses to in the other; its changes flow out along arcs

//! to its consumers and its upstreams' flow in, each stream and node in

//! the status of its Diffusion pill, and a ripple widens from the

//! repository every few seconds. The data is the page's own.

use crate::backdrop::field::{knot, margins, unit, Dot, Field, Named, Orbit, Tone, ZOOM};

use crate::backdrop::scene::Scene;

use crate::backdrop::sky::Colours;

use std::f32::consts::{PI, TAU};

/// Dots in the repository's knot and in each other's, as dense as a sky's

/// clusters.

const KNOT_REPO: usize = 90;

const KNOT: usize = 60;

/// Dots flowing along each stream, and their speed in CSS pixels a second:

/// a stream is a flow, quicker than the drift of marks.

const FLOW: usize = 28;

const FLOW_SPEED: f32 = 40.0;

/// A ripple every this many seconds, widening this far over this long.

const RIPPLE_EVERY: f32 = 5.0;

const RIPPLE_R: f32 = 280.0;

const RIPPLE_S: f32 = 3.2;

const RIPPLE_DOTS: usize = 72;

/// One repository on the page: its name and the tone its dots take.

pub struct Node {

    pub name: String,

    pub tone: Tone,

}

pub struct Ripples {

    field: Field,

    /// The repository first, then its upstreams, then its consumers.

    nodes: Vec<Node>,

    ups: usize,

    pos: Vec<(f32, f32)>,

    /// Each knot's dots: its node, and its orbit.

    orbits: Vec<(usize, Orbit)>,

    /// Streams: from, to, and their dots' first index.

    streams: Vec<(usize, usize, usize)>,

    ripple_at: usize,

    w: f32,

    h: f32,

    t: f32,

}

impl Ripples {

    pub fn new(repo: String, upstreams: Vec<Node>, consumers: Vec<Node>, still: bool) -> Ripples {

        let ups = upstreams.len();

        let mut nodes = vec![Node { name: repo, tone: Tone::Mark }];

        nodes.extend(upstreams);

        nodes.extend(consumers);

        let mut field = Field::new(still);

        let mut orbits = Vec::new();

        for (i, n) in nodes.iter().enumerate() {

            let mut core = Dot::new(0.0, 0.0, if i == 0 { 9.0 } else { 7.0 }, 4.0);

            core.tone = n.tone;

            field.dots.push(core);

        }

        for (i, n) in nodes.iter().enumerate() {

            for (k, o) in knot(&n.name, if i == 0 { KNOT_REPO } else { KNOT }).into_iter().enumerate() {

                let mut d = Dot::new(0.0, 0.0, 2.0 * ZOOM, if k % 9 == 0 { 1.0 } else { 0.0 });

                d.tone = n.tone;

                d.group = i as u32;

                d.order = k as u32;

                d.bright = 0.55 + 0.45 * unit(crate::backdrop::sky::hash(&format!("{}@{k}", n.name)), 0);

                field.dots.push(d);

                orbits.push((i, o));

            }

        }

        // Upstreams flow into the repository; the repository flows out to

        // each consumer, the stream in the consumer's tone.

        let mut streams = Vec::new();

        for (i, node) in nodes.iter().enumerate() {

            let (from, to) = match i {

                0 => continue,

                i if i <= ups => (i, 0),

                i => (0, i),

            };

            streams.push((from, to, field.dots.len()));

            for _ in 0..FLOW {

                let mut d = Dot::new(0.0, 0.0, 1.8 * ZOOM, 0.0);

                d.tone = node.tone;

                field.dots.push(d);

            }

        }

        let ripple_at = field.dots.len();

        for _ in 0..RIPPLE_DOTS {

            let mut d = Dot::new(0.0, 0.0, 1.6 * ZOOM, 0.0);

            d.bright = 0.0;

            field.dots.push(d);

        }

        let mut r = Ripples { field, nodes, ups, pos: Vec::new(), orbits, streams, ripple_at, w: 0.0, h: 0.0, t: 0.0 };

        r.layout(None);

        r

    }

    fn layout(&mut self, avoid: Option<(f32, f32)>) {

        let (w, h) = (self.w, self.h);

        let n = self.nodes.len();

        let cons = n - 1 - self.ups;

        let spread = |i: usize, of: usize, top: f32, bottom: f32| {

            if of <= 1 {

                (top + bottom) / 2.0

            } else {

                top + (bottom - top) * i as f32 / (of - 1) as f32

            }

        };

        let (repo_x, up_x, con_x) = match margins(w, avoid) {

            Some((l, x1)) => (l * 0.62, l * 0.22, x1 + (w - x1) * 0.45),

            None => (w * 0.12, w * 0.04, w * 0.88),

        };

        self.pos = (0..n)

            .map(|i| match i {

                0 => (repo_x, h * 0.5),

                i if i <= self.ups => (up_x, spread(i - 1, self.ups, h * 0.25, h * 0.75)),

                i => (con_x, spread(i - 1 - self.ups, cons, h * 0.15, h * 0.85)),

            })

            .collect();

        self.field.named =

            self.nodes.iter().zip(&self.pos).map(|(nd, &(x, y))| Named { name: nd.name.clone(), x, y, reach: 90.0 }).collect();

    }

    fn place(&mut self) {

        let n = self.nodes.len();

        for (i, &(x, y)) in self.pos.iter().enumerate() {

            self.field.dots[i].x = x;

            self.field.dots[i].y = y;

        }

        for (k, (node, o)) in self.orbits.iter().enumerate() {

            let (x, y) = o.at(self.pos[*node], self.t);

            self.field.dots[n + k].x = x;

            self.field.dots[n + k].y = y;

        }

        // Streams: a gentle arc from each source to its destination, its

        // dots evenly spaced and moving along it, faded at the ends.

        for &(from, to, first) in &self.streams {

            let (a, b) = (self.pos[from], self.pos[to]);

            let len = (b.0 - a.0).hypot(b.1 - a.1).max(1.0);

            let ctrl = ((a.0 + b.0) / 2.0, (a.1 + b.1) / 2.0 - len * 0.18);

            for k in 0..FLOW {

                let s = (k as f32 / FLOW as f32 + self.t * FLOW_SPEED / len).fract();

                let u = 1.0 - s;

                let d = &mut self.field.dots[first + k];

                d.x = u * u * a.0 + 2.0 * u * s * ctrl.0 + s * s * b.0;

                d.y = u * u * a.1 + 2.0 * u * s * ctrl.1 + s * s * b.1;

                d.bright = (s * PI).sin();

            }

        }

        // The ripple: a ring of dots widening from the repository.

        let p = (self.t % RIPPLE_EVERY) / RIPPLE_S;

        let (x, y) = self.pos[0];

        for k in 0..RIPPLE_DOTS {

            let d = &mut self.field.dots[self.ripple_at + k];

            let a = k as f32 / RIPPLE_DOTS as f32 * TAU;

            let r = 40.0 + RIPPLE_R * p.min(1.0);

            d.x = x + a.cos() * r;

            d.y = y + a.sin() * r;

            d.bright = if self.field.still || p >= 1.0 { 0.0 } else { 0.8 * (1.0 - p) };

        }

    }

}

impl Scene for Ripples {

    fn resize(&mut self, w: f32, h: f32, avoid: Option<(f32, f32)>) {

        self.w = w;

        self.h = h;

        self.layout(avoid);

        self.place();

    }

    fn point(&mut self, at: Option<(f32, f32)>) {

        self.field.point(at);

    }

    fn step(&mut self, dt: f32) {

        if !self.field.still {

            self.t += dt.clamp(0.0, 0.1);

        }

        self.place();

        self.field.light(dt);

    }

    fn instances(&self, c: &Colours, out: &mut Vec<f32>) {

        self.field.instances(c, out)

    }

    fn links(&self, c: &Colours, out: &mut Vec<f32>) {

        self.field.links(c, out)

    }

    fn label(&self) -> Option<(&str, f32, f32)> {

        self.field.label()

    }

    fn busy(&self) -> bool {

        self.field.easing()

    }

    fn still(&self) -> bool {

        self.field.still

    }

    fn size(&self) -> (f32, f32) {

        (self.w, self.h)

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    fn node(name: &str, tone: Tone) -> Node {

        Node { name: name.into(), tone }

    }

    #[test]

    fn upstreams_flow_in_and_consumers_out_in_their_pills_tones() {

        let mut r = Ripples::new(

            "andy/api".into(),

            vec![node("andy/base", Tone::Ok)],

            vec![node("andy/game", Tone::Ok), node("andy/other", Tone::Bad)],

            false,

        );

        r.resize(2560.0, 1270.0, Some((707.0, 1838.0)));

        assert!(r.pos[0].0 < 707.0 && r.pos[1].0 < r.pos[0].0, "the repository and its upstream in the left margin");

        assert!(r.pos[2].0 > 1838.0 && r.pos[3].0 > 1838.0, "its consumers in the right");

        let knots = 4 + KNOT_REPO + 3 * KNOT;

        assert_eq!(r.streams, vec![(1, 0, knots), (0, 2, knots + FLOW), (0, 3, knots + 2 * FLOW)]);

        let bad_stream = r.streams[2].2;

        assert!(r.field.dots[bad_stream..bad_stream + FLOW].iter().all(|d| d.tone == Tone::Bad), "a failing consumer's stream is red");

        let before = r.field.dots[bad_stream].x;

        r.step(0.1);

        assert_ne!(before, r.field.dots[bad_stream].x, "streams flow");

        r.point(Some(r.pos[3]));

        for _ in 0..30 {

            r.step(0.02);

        }

        assert_eq!(r.label().map(|l| l.0), Some("andy/other"));

    }

    #[test]

    fn still_keeps_the_ripple_away() {

        let mut r = Ripples::new("andy/api".into(), vec![], vec![node("andy/game", Tone::Mark)], true);

        r.resize(1600.0, 900.0, None);

        r.step(0.1);

        assert!(r.field.dots[r.ripple_at..].iter().all(|d| d.bright == 0.0));

    }

}

// Copied from OxygenHub crates/backdrop/src/scene.rs (6dc080f6) by

// scripts/sync-backdrop.sh: change it there, never here.

//! A backdrop's scene (docs/backgrounds.md §2): what it draws and how it

//! moves. The engine (lib.rs) drives any of them the same way.

use crate::backdrop::sky::{Colours, Kind};

pub trait Scene {

    /// The view is now `w` by `h` CSS pixels, the page's content column

    /// between `avoid`'s left and right.

    fn resize(&mut self, w: f32, h: f32, avoid: Option<(f32, f32)>);

    /// The cursor moved to `(x, y)`, or left the page.

    fn point(&mut self, at: Option<(f32, f32)>);

    /// Move on by `dt` seconds.

    fn step(&mut self, dt: f32);

    /// The marks, 8 floats each (sky::Sky::instances).

    fn instances(&self, c: &Colours, out: &mut Vec<f32>);

    /// The links, 12 floats each (sky::Sky::links).

    fn links(&self, c: &Colours, out: &mut Vec<f32>);

    /// The name a resting cursor shows, and where.

    fn label(&self) -> Option<(&str, f32, f32)>;

    /// New activity in repository `repo` (§5, "Live"); only the sky shows it.

    fn arrive(&mut self, _repo: &str, _kind: Kind, _n: u32) {}

    /// Whether a frame would show anything new besides the drift, which

    /// the engine stops drawing a while after the last input (§6).

    fn busy(&self) -> bool;

    fn still(&self) -> bool;

    fn size(&self) -> (f32, f32);

}

impl Scene for crate::backdrop::sky::Sky {

    fn resize(&mut self, w: f32, h: f32, avoid: Option<(f32, f32)>) {

        crate::backdrop::sky::Sky::resize(self, w, h, avoid)

    }

    fn point(&mut self, at: Option<(f32, f32)>) {

        crate::backdrop::sky::Sky::point(self, at)

    }

    fn step(&mut self, dt: f32) {

        crate::backdrop::sky::Sky::step(self, dt)

    }

    fn instances(&self, c: &Colours, out: &mut Vec<f32>) {

        crate::backdrop::sky::Sky::instances(self, c, out)

    }

    fn links(&self, c: &Colours, out: &mut Vec<f32>) {

        crate::backdrop::sky::Sky::links(self, c, out)

    }

    fn label(&self) -> Option<(&str, f32, f32)> {

        crate::backdrop::sky::Sky::label(self)

    }

    fn arrive(&mut self, repo: &str, kind: Kind, n: u32) {

        crate::backdrop::sky::Sky::arrive(self, repo, kind, n)

    }

    fn busy(&self) -> bool {

        crate::backdrop::sky::Sky::busy(self)

    }

    fn still(&self) -> bool {

        self.still

    }

    fn size(&self) -> (f32, f32) {

        (self.w, self.h)

    }

}

// Copied from OxygenHub crates/backdrop/src/sky.rs (6dc080f6) by

// scripts/sync-backdrop.sh: change it there, never here.

//! Your sky (docs/backgrounds.md §5): the dashboard's scene, its layout

//! and its motion, with no browser in it so it is tested natively.

//!

//! Each repository is a cluster placed by a hash of its name, so a

//! viewer's sky is the same on every visit; its events of the last 30 days

//! orbit it as marks, brightest when newest, shaped by kind. The cursor

//! lights marks near it without moving them, and joins the lit marks of

//! one repository in the order they happened.

use std::f32::consts::TAU;

/// The scale of marks and orbits: the sky drawn 40% closer than first

/// built (Andy, 2026-10-13).

const ZOOM: f32 = 1.4;

/// How far the cursor lights marks, in CSS pixels (§4).

pub const LIGHT_RADIUS: f32 = 170.0;

/// Seconds a mark takes to light, and to fade.

const LIT_IN: f32 = 0.15;

const LIT_OUT: f32 = 0.6;

/// The fastest a mark drifts, in CSS pixels a second.

pub const MAX_SPEED: f32 = 12.0;

/// How far each depth layer shifts against the cursor, front to back.

const PARALLAX: [f32; 3] = [6.0, 3.0, 1.0];

/// The longest link: only marks that happened one after another and sit

/// near each other are joined, so a busy repository reads as a

/// constellation, not a scribble.

const LINK_MAX: f32 = 85.0;

/// Links fade when the cursor has rested this long, in seconds.

const LINK_REST: f32 = 2.0;

/// A resting cursor this near a cluster's core names it, after this long.

const LABEL_NEAR: f32 = 110.0;

const LABEL_REST: f32 = 0.4;

/// Events older than this many days are not drawn.

pub const DAYS: f32 = 30.0;

/// The most marks one push makes (one a change), and in all.

const PER_PUSH: u32 = 40;

const MAX_MARKS: usize = 3000;

/// A side margin narrower than this holds no clusters: the sky falls back

/// to a ring around the page.

const MIN_MARGIN: f32 = 180.0;

/// The width a cluster gets in a margin's grid.

const CELL: f32 = 260.0;

/// An arrival's ring (§4): seconds it lasts, and its radius from first to

/// last, in CSS pixels before the zoom.

const RING_S: f32 = 1.2;

const RING_FROM: f32 = 6.0;

const RING_TO: f32 = 46.0;

/// What a mark stands for, which decides its shape.

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub enum Kind {

    Push,

    Proposal,

    Issue,

    Release,

    /// A Flow run.

    Run,

    /// The repository itself, its cluster's core.

    Repo,

}

impl Kind {

    /// The code the page's data uses: 0 a push's change, 1 a proposal

    /// event, 2 an issue event, 3 a release, 4 a Flow run.

    pub fn from_code(code: u32) -> Kind {

        match code {

            1 => Kind::Proposal,

            2 => Kind::Issue,

            3 => Kind::Release,

            4 => Kind::Run,

            _ => Kind::Push,

        }

    }

    /// The shape the fragment shader draws: 0 dot, 1 diamond, 2 ring,

    /// 3 four-point star, 4 thin ring (a repository), 5 square.

    pub fn shape(self) -> f32 {

        match self {

            Kind::Push => 0.0,

            Kind::Proposal => 1.0,

            Kind::Issue => 2.0,

            Kind::Release => 3.0,

            Kind::Repo => 4.0,

            Kind::Run => 5.0,

        }

    }

    /// Its radius in CSS pixels.

    fn size(self) -> f32 {

        match self {

            Kind::Push => 2.0,

            Kind::Run => 2.2,

            Kind::Proposal => 3.2,

            Kind::Issue => 3.0,

            Kind::Release => 4.2,

            Kind::Repo => 6.0,

        }

    }

}

/// One repository, as the page gives it.

#[derive(Clone, Debug)]

pub struct Repo {

    pub name: String,

}

/// One event, as the page gives it: its repository (an index into the

/// repositories), its kind, how old it is, and how many marks it makes (a

/// push's changes; one otherwise).

#[derive(Clone, Copy, Debug)]

pub struct Event {

    pub repo: usize,

    pub kind: Kind,

    pub age_days: f32,

    pub n: u32,

}

/// A repository's place: a fraction of the view, and a depth layer.

#[derive(Clone, Debug)]

pub struct Cluster {

    pub name: String,

    pub fx: f32,

    pub fy: f32,

    pub layer: usize,

}

/// One drawn mark, orbiting its cluster.

#[derive(Clone, Debug)]

pub struct Mark {

    pub cluster: usize,

    pub kind: Kind,

    /// Its place in its cluster's history, 0 the newest; the core is 0

    /// too and has radius 0.

    pub order: u32,

    pub radius: f32,

    pub angle: f32,

    /// Radians a second, signed.

    pub speed: f32,

    /// 1 for today, fading to 0.3 for a month ago.

    pub bright: f32,

    /// How lit it is now, 0 to 1.

    pub lit: f32,

}

/// Straight RGBA, 0 to 1, as the page's tokens give them.

pub type Rgba = [f32; 4];

/// The three backdrop tokens (§3), and the page's status colours for the

/// scenes whose data has a status (Diffusion's pills).

#[derive(Clone, Copy, Debug, Default, PartialEq)]

pub struct Colours {

    pub mark: Rgba,

    pub lit: Rgba,

    pub link: Rgba,