feat(web): every scene as dense as the sky: knots, fuller streams, 1.4x (refs #167) f993f792537e

            arg0.viewport(arg1, arg2, arg3, arg4);

        },

        __wbindgen_generic_0000000000000001: function(arg0, arg1) {

            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_ef67fbc5f0a8b406___convert__closures_____invoke___f64______true_);

            return ret;

        },

        __wbindgen_generic_0000000000000002: function(arg0, arg1) {

            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_ef67fbc5f0a8b406___convert__closures_____invoke___web_sys_793942649ef82f98___features__gen_MouseEvent__MouseEvent______true_);

            return ret;

        },

        __wbindgen_generic_0000000000000003: function(arg0, arg1) {

            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_ef67fbc5f0a8b406___convert__closures_____invoke_______true_);

            return ret;

        },

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

//! and sets out again. No data.

use crate::scene::Scene;

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

impl Adrift {

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

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

        for k in 0..CLUSTER {

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

            d.group = 0;

            d.order = k as u32;

        }

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

        field.dots.push(Dot::new(0.0, 0.0, 8.0, 4.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 };

    fn place(&mut self) {

        let (cx, cy) = self.centre;

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

        }

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

        core.x = cx;

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

        let p = self.t % DRIFT_S;

        let dir: f32 = -0.35;

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

    ((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)> {

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

//! core. Brand only: no data.

use crate::scene::Scene;

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

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

/// Dots on the two rings.

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

const RIM_SPEED: f32 = 9.0;

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

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

            d.group = ring as u32;

            field.dots.push(d);

//! 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::scene::Scene;

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

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

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

pub struct Node {

    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,

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

                d.tone = n.tone;

                d.group = i as u32;

                d.order = k as u32;

                field.dots.push(d);

            }

        }

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

            };

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

            for _ in 0..FLOW {

                d.tone = node.tone;

                field.dots.push(d);

            }

        }

        let ripple_at = field.dots.len();

        for _ in 0..RIPPLE_DOTS {

            d.bright = 0.0;

            field.dots.push(d);

        }

        r.layout(None);

        r

    }

            })

            .collect();

        self.field.named =

    }

    fn place(&mut self) {

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

        }

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

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

        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;

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

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

//! 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::scene::Scene;

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

/// the most streams drawn.

const CHUNK_SPEED: f32 = 40.0;

const MAX_STREAMS: usize = 40;

struct Held {

    node: usize,

}

pub struct Swarm {

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

        }

        let mut held = Vec::new();

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

                count[node] += 1;

                d.group = node as u32;

                field.dots.push(d);

            }

        }

        let mut streams = Vec::new();

                    }

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

                    for _ in 0..CHUNKS {

                        d.bright = 0.0;

                        field.dots.push(d);

                    }

            .zip(&self.pos)

            .enumerate()

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

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

            })

            .collect();

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

        }

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

        }

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

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

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