feat(web): the mark, ripples, the swarm and adrift (closes #167) 6246d1e51f4f

//! 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::field::{margins, unit, Dot, Field};

use crate::scene::Scene;

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

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

const CLUSTER: usize = 70;

/// 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;

struct Orbit {

    radius: f32,

    angle: f32,

    speed: f32,

}

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 mut orbits = Vec::new();

        for k in 0..CLUSTER {

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

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

            orbits.push(Orbit { radius, angle: unit(h, 16) * TAU, speed: (MAX_SPEED / radius).min(0.25) * (0.5 + 0.5 * unit(h, 32)) });

            let mut d = Dot::new(0.0, 0.0, 2.6, 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, 4.2, 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 a = o.angle + o.speed * self.t;

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

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

        }

        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 = 70.0 * 1.4;

        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.still || 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");

    }

}

//! 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::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

}

/// 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);

    }

}

//! 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::field::{unit, Dot, Field};

use crate::scene::Scene;

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

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

/// Dots on the two rings.

const DOTS: usize = 560;

/// 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, 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.

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

        let r = (self.w.min(self.h * 1.6) * 0.17).clamp(110.0, 330.0);

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

        (r, [(cx - r, cy), (cx + r, 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.still || 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");

    }

}

//! 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::field::{margins, unit, Dot, Field, Named, Tone};

use crate::scene::Scene;

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

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

/// Dots round each repository, how far out, and how fast they turn.

const RING: usize = 18;

const RING_R: f32 = 30.0;

const RING_SPEED: f32 = 6.0;

/// 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 = 10;

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 = 40;

/// 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)>,

    /// 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);

        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 k in 0..RING {

                let mut d = Dot::new(0.0, 0.0, 2.2, 0.0);

                d.tone = n.tone;

                d.group = i as u32;

                d.order = k as u32;

                d.bright = 0.6 + 0.4 * unit(hash(&format!("{}#{k}", n.name)), 0);

                field.dots.push(d);

            }

        }

        // 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, 2.0, 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.8, 0.0);

            d.bright = 0.0;

            field.dots.push(d);

        }

        let mut r = Ripples { field, nodes, ups, pos: Vec::new(), 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: RING_R + 6.0 }).collect();

    }

    fn place(&mut self) {

        let mut at = 0;

        let spin = RING_SPEED / RING_R * self.t;

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

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

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

            at += 1;

            for k in 0..RING {

                let a = k as f32 / RING as f32 * TAU + if i % 2 == 0 { spin } else { -spin };

                self.field.dots[at].x = x + a.cos() * RING_R;

                self.field.dots[at].y = y + a.sin() * RING_R;

                at += 1;

            }

        }

        // 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 = RING_R + 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.still || 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");

        assert_eq!(r.streams, vec![(1, 0, 4 * (RING + 1)), (0, 2, 4 * (RING + 1) + FLOW), (0, 3, 4 * (RING + 1) + 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));

    }

}

//! 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::sky::Colours;

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)>;

    /// Whether a frame would show anything new.

    fn busy(&self) -> bool;

    fn still(&self) -> bool;

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

}

impl Scene for crate::sky::Sky {

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

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

    }

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

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

    }

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

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

    }

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

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

    }

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

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

    }

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

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

    }

    fn busy(&self) -> bool {

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

    }

    fn still(&self) -> bool {

        self.still

    }

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

        (self.w, self.h)

    }

}

//! The swarm (docs/backgrounds.md §2): Admin › Runners › Images. The hub

//! and the runners as nodes, each ringed by a dot for every image it

//! holds; while a runner fetches an image, chunks (small squares) stream

//! to it from every holder, the hub and its peers alike, as Jetstream's

//! swarm fetches them. The data is the page's own snapshot.

use crate::field::{margins, unit, Dot, Field, Named};

use crate::scene::Scene;

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

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

/// Chunks streaming along each holder-to-fetcher path, their speed, and

/// the most streams drawn.

const CHUNKS: usize = 8;

const CHUNK_SPEED: f32 = 40.0;

const MAX_STREAMS: usize = 40;

/// One image: the nodes that hold it and those fetching it now.

pub struct Image {

    pub held: Vec<usize>,

    pub fetching: Vec<usize>,

}

struct Held {

    node: usize,

    radius: f32,

    angle: f32,

    speed: f32,

}

pub struct Swarm {

    field: Field,

    /// The hub first, then the runners.

    names: Vec<String>,

    pos: Vec<(f32, f32)>,

    held: Vec<Held>,

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

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

    w: f32,

    h: f32,

    t: f32,

}

impl Swarm {

    pub fn new(names: Vec<String>, images: Vec<Image>, still: bool) -> Swarm {

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

        for i in 0..names.len() {

            field.dots.push(Dot::new(0.0, 0.0, if i == 0 { 10.0 } else { 8.0 }, 4.0));

        }

        let mut held = Vec::new();

        let mut count = vec![0u32; names.len()];

        for (n, img) in images.iter().enumerate() {

            for &node in img.held.iter().filter(|&&n| n < names.len()) {

                let k = count[node];

                count[node] += 1;

                let h = hash(&format!("{}#{n}", names[node]));

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

                held.push(Held {

                    node,

                    radius,

                    angle: unit(h, 16) * TAU,

                    speed: (MAX_SPEED / radius).min(0.2) * (0.5 + 0.5 * unit(h, 32)),

                });

                let mut d = Dot::new(0.0, 0.0, 2.6, 0.0);

                d.group = node as u32;

                d.order = k;

                d.bright = 0.7;

                field.dots.push(d);

            }

        }

        let mut streams = Vec::new();

        'images: for img in &images {

            for &to in img.fetching.iter().filter(|&&n| n < names.len()) {

                for &from in img.held.iter().filter(|&&n| n < names.len() && n != to) {

                    if streams.len() == MAX_STREAMS {

                        break 'images;

                    }

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

                    for _ in 0..CHUNKS {

                        let mut d = Dot::new(0.0, 0.0, 2.2, 5.0);

                        d.bright = 0.0;

                        field.dots.push(d);

                    }

                }

            }

        }

        let mut s = Swarm { field, names, pos: Vec::new(), held, streams, w: 0.0, h: 0.0, t: 0.0 };

        s.layout(None);

        s

    }

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

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

        let runners = self.names.len().saturating_sub(1);

        let (hub_x, run_x) = match margins(w, avoid) {

            Some((l, x1)) => (l * 0.5, x1 + (w - x1) * 0.5),

            None => (w * 0.1, w * 0.9),

        };

        self.pos = (0..self.names.len())

            .map(|i| match i {

                0 => (hub_x, h * 0.5),

                _ if runners <= 1 => (run_x, h * 0.5),

                i => (run_x, h * 0.2 + h * 0.6 * (i - 1) as f32 / (runners - 1) as f32),

            })

            .collect();

        self.field.named = self

            .names

            .iter()

            .zip(&self.pos)

            .enumerate()

            .map(|(i, (name, &(x, y)))| {

                let reach = self.held.iter().filter(|h| h.node == i).map(|h| h.radius).fold(12.0, f32::max);

                Named { name: name.clone(), x, y, reach }

            })

            .collect();

    }

    fn place(&mut self) {

        let n = self.names.len();

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

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

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

        }

        for (k, hd) in self.held.iter().enumerate() {

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

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

            self.field.dots[n + k].x = x + a.cos() * hd.radius;

            self.field.dots[n + k].y = y + a.sin() * hd.radius;

        }

        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);

            // Peers' streams bow one way, the hub's the other, so they

            // read as separate sources.

            let bow = if from == 0 { -0.12 } else { 0.12 };

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

            for k in 0..CHUNKS {

                let s = (k as f32 / CHUNKS as f32 + self.t * CHUNK_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();

            }

        }

    }

}

impl Scene for Swarm {

    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.still || 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 chunks_stream_to_a_fetching_runner_from_every_holder() {

        let names = vec!["hub".to_string(), "earth-1".to_string(), "plex-1".to_string()];

        let images = vec![Image { held: vec![0, 1], fetching: vec![2] }, Image { held: vec![0, 1, 2], fetching: vec![] }];

        let mut s = Swarm::new(names, images, false);

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

        assert!(s.pos[0].0 < 707.0 && s.pos[1].0 > 1838.0 && s.pos[2].0 > 1838.0, "the hub on one side, runners on the other");

        assert_eq!(s.held.len(), 5, "a dot for every image each node holds");

        assert_eq!(s.streams.iter().map(|&(a, b, _)| (a, b)).collect::<Vec<_>>(), vec![(0, 2), (1, 2)], "from the hub and the peer");

        let first = s.streams[0].2;

        let before = s.field.dots[first].x;

        s.step(0.1);

        assert_ne!(before, s.field.dots[first].x);

        s.point(Some(s.pos[1]));

        for _ in 0..30 {

            s.step(0.02);

        }

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

    }

}

- **Every backdrop scene (#167, docs/backgrounds.md):** the Oxygen mark's two rings turning behind sign in, register and device sign-in; ripples on a repository's Diffusion tab, its upstreams flowing in and changes flowing out to its consumers in their pills' tones; the swarm on Admin › Runners › Images, chunks streaming to a fetching runner from every holder; and one mark adrift on a page not found or a server error.

 * Start a backdrop on `canvas` with the page's `data`: the scene it names

 * (docs/backgrounds.md §2), the dashboard's sky by default. `still`

pub mod adrift;

pub mod field;

pub mod mark;

pub mod ripples;

pub mod scene;

pub mod swarm;

use scene::Scene;

    scene: Box<dyn Scene>,

        self.scene.resize(w as f32, h as f32, avoid);

            ok: read("--ok", [0.1, 0.5, 0.22, 1.0]),

            warn: read("--warn", [0.6, 0.4, 0.0, 1.0]),

            bad: read("--bad", [0.82, 0.14, 0.18, 1.0]),

        if !self.scene.still() && idle > HALF_RATE_AFTER_S && self.frame % 2 == 1 {

        self.scene.step(dt);

        self.scene.instances(&self.colours, &mut self.inst);

        self.scene.links(&self.colours, &mut self.lines);

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

        self.renderer.draw(w, h, self.pw, self.ph, &self.inst, &self.lines);

        if self.scene.still() {

            self.scene.busy()

            idle < STOP_AFTER_S || self.scene.busy()

        let next = self.scene.label().map(|(name, x, y)| (name.to_string(), x, y));

fn strings(v: &JsValue) -> Vec<String> {

    js_sys::Array::from(v).iter().filter_map(|x| x.as_string()).collect()

}

/// A Diffusion node, `[name, tone]`.

fn ripple_nodes(v: &JsValue) -> Vec<ripples::Node> {

    js_sys::Array::from(v)

        .iter()

        .filter_map(|n| {

            let n = js_sys::Array::from(&n);

            Some(ripples::Node { name: n.get(0).as_string()?, tone: field::Tone::from_name(&n.get(1).as_string().unwrap_or_default()) })

        })

        .collect()

}

/// The scene the page's data names (`scene`), the sky when it names none.

fn read_scene(data: &JsValue, still: bool) -> Box<dyn Scene> {

    match get(data, "scene").as_string().as_deref() {

        Some("mark") => Box::new(mark::Mark::new(still)),

        Some("adrift") => Box::new(adrift::Adrift::new(still)),

        Some("ripples") => Box::new(ripples::Ripples::new(

            get(data, "repo").as_string().unwrap_or_default(),

            ripple_nodes(&get(data, "upstreams")),

            ripple_nodes(&get(data, "consumers")),

            still,

        )),

        Some("swarm") => {

            let images = js_sys::Array::from(&get(data, "images"))

                .iter()

                .map(|img| {

                    let idx =

                        |key: &str| js_sys::Array::from(&get(&img, key)).iter().filter_map(|v| v.as_f64()).map(|v| v as usize).collect();

                    swarm::Image { held: idx("held"), fetching: idx("fetching") }

                })

                .collect();

            Box::new(swarm::Swarm::new(strings(&get(data, "nodes")), images, still))

        }

        _ => {

            let (repos, events) = read_data(data);

            Box::new(Sky::new(&repos, &events, 0.0, 0.0, still))

        }

    }

}

/// Start a backdrop on `canvas` with the page's `data`: the scene it names

/// (docs/backgrounds.md §2), the dashboard's sky by default. `still`

    let scene = read_scene(&data, still);

    let colours = Colours::default();

        scene,

                e.scene.point(Some((ev.client_x() as f32, ev.client_y() as f32)));

                engine.borrow_mut().scene.point(None);

/// 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 ok: Rgba,

    pub warn: Rgba,

    pub bad: Rgba,

        let colours = Colours { mark: [0.5, 0.5, 0.5, 0.2], lit: [0.0, 0.4, 0.9, 0.7], link: [0.0, 0.4, 0.9, 0.3], ..Default::default() };

        let colours = Colours { mark: [1.0, 1.0, 1.0, 0.5], lit: [0.0, 0.0, 1.0, 1.0], link: [0.0, 0.0, 1.0, 0.3], ..Default::default() };

    /// The ripples backdrop's data (docs/backgrounds.md §2): this page's

    /// own repositories and pill tones, JSON safe in a script.

    backdrop: String,

/// The ripples' data: the repository, the upstreams it takes from (each in

/// its upstream half's tone) and the consumers it diffuses to (each in its

/// own half's tone), as `{scene, repo, upstreams: [[name, tone]],

/// consumers: [[name, tone]]}`.

fn ripples_json(slug: &str, used_by: &[Consumer], follows: &[(RepoRow, Consumer)]) -> String {

    let tone = |class: &str| class.trim_start_matches("df-").to_string();

    let upstreams: Vec<(String, String)> =

        follows.iter().map(|(up, c)| (format!("{}/{}", up.owner, up.name), tone(c.upstream.class))).collect();

    let consumers: Vec<(String, String)> = used_by.iter().map(|c| (format!("{}/{}", c.owner, c.name), tone(c.downstream.class))).collect();

    serde_json::json!({ "scene": "ripples", "repo": slug, "upstreams": upstreams, "consumers": consumers })

        .to_string()

        .replace('<', "\\u003c")