cuju-render 0.1.0__py3-none-any.whl

cuju/render/web/js/export/mp4-mux.js

@@ -0,0 +1,295 @@
+// Copyright 2026 The cuju Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// A small writer of MP4 files of one H.264 video track, for the video export of the page. It
+// takes the encoded frames in the order of decoding with their times in microseconds and writes
+// the boxes of ISO/IEC 14496-12 and 14496-15 that a player needs, the file type, the movie with
+// its sample tables, and the frames in one media box. The movie comes before the frames, so a
+// player starts before the whole file has arrived. The frames gather into blobs as they come, so
+// a browser may keep a long video on its disk rather than in memory.
+
+const textBytes = (text) => Uint8Array.from(text, (c) => c.charCodeAt(0));
+
+// A writer of big-endian fields into a growing list of bytes.
+class Bytes {
+    constructor() {
+        this.parts = [];
+        this.length = 0;
+    }
+
+    push(array) {
+        this.parts.push(array);
+        this.length += array.length;
+        return this;
+    }
+
+    u8(value) {
+        return this.push(Uint8Array.of(value & 255));
+    }
+
+    u16(value) {
+        const b = new Uint8Array(2);
+        new DataView(b.buffer).setUint16(0, value);
+        return this.push(b);
+    }
+
+    u32(value) {
+        const b = new Uint8Array(4);
+        new DataView(b.buffer).setUint32(0, value >>> 0);
+        return this.push(b);
+    }
+
+    i32(value) {
+        const b = new Uint8Array(4);
+        new DataView(b.buffer).setInt32(0, value);
+        return this.push(b);
+    }
+
+    u64(value) {
+        const b = new Uint8Array(8);
+        new DataView(b.buffer).setBigUint64(0, BigInt(value));
+        return this.push(b);
+    }
+
+    zeros(count) {
+        return this.push(new Uint8Array(count));
+    }
+
+    text(value) {
+        return this.push(textBytes(value));
+    }
+
+    bytes() {
+        const out = new Uint8Array(this.length);
+        let at = 0;
+        for (const part of this.parts) {
+            out.set(part, at);
+            at += part.length;
+        }
+        return out;
+    }
+}
+
+// A box of a type and a body that fill writes, or of children given as bytes.
+function box(type, fill, ...children) {
+    const body = new Bytes();
+    if (fill) {
+        fill(body);
+    }
+    for (const child of children) {
+        body.push(child);
+    }
+    const out = new Bytes().u32(8 + body.length).text(type);
+    out.push(body.bytes());
+    return out.bytes();
+}
+
+// A full box, a box whose body starts with a version and flags.
+function fullBox(type, version, flags, fill, ...children) {
+    return box(type, (b) => {
+        b.u8(version).u8(flags >> 16).u16(flags & 0xffff);
+        if (fill) {
+            fill(b);
+        }
+    }, ...children);
+}
+
+// The matrix of a track that shows as it was encoded.
+const MATRIX = [0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000];
+
+// Runs of equal values, as the sample tables count them.
+function runs(values) {
+    const out = [];
+    for (const value of values) {
+        const last = out[out.length - 1];
+        if (last && last[1] === value) {
+            last[0]++;
+        } else {
+            out.push([1, value]);
+        }
+    }
+    return out;
+}
+
+// Gathers the encoded frames of one video track and writes the file.
+export class Mp4Writer {
+    // width and height are the picture's, fps the frame rate, which sets the time scale.
+    constructor({ width, height, fps }) {
+        this.width = width;
+        this.height = height;
+        this.timescale = Math.max(1, Math.round(fps)) * 1000;
+        this.samples = [];
+        this.description = null;
+        this.pending = [];
+        this.pendingBytes = 0;
+        this.blobs = [];
+        this.bytes = 0;
+    }
+
+    // Adds one encoded frame, its bytes, its time and length in microseconds and whether it is a
+    // key frame. description is the AVC decoder configuration that the encoder gives with its
+    // first frame.
+    add(data, { timestamp, duration, key, description }) {
+        if (description && !this.description) {
+            this.description = new Uint8Array(description instanceof ArrayBuffer ? description : description.buffer.slice(description.byteOffset, description.byteOffset + description.byteLength));
+        }
+        const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+        this.samples.push({ size: bytes.length, timestamp, duration, key: !!key });
+        this.pending.push(bytes);
+        this.pendingBytes += bytes.length;
+        this.bytes += bytes.length;
+        // The frames gather into a blob every few megabytes.
+        if (this.pendingBytes >= 8 << 20 && typeof Blob === 'function') {
+            this.flushPending();
+        }
+    }
+
+    flushPending() {
+        if (this.pending.length) {
+            this.blobs.push(typeof Blob === 'function' ? new Blob(this.pending) : this.pending.slice());
+            this.pending = [];
+            this.pendingBytes = 0;
+        }
+    }
+
+    // The times of the samples in the units of the track, in the order of decoding, with their
+    // offsets to the order of showing.
+    timing() {
+        const scale = this.timescale / 1e6;
+        const shown = this.samples.map((s) => Math.round(s.timestamp * scale));
+        const decoded = [...shown].sort((a, b) => a - b);
+        const deltas = decoded.map((t, i) => (i + 1 < decoded.length ? decoded[i + 1] - t : Math.max(1, Math.round(this.samples[i].duration * scale))));
+        const offsets = shown.map((t, i) => t - decoded[i]);
+        const total = decoded.length ? decoded[decoded.length - 1] - decoded[0] + deltas[deltas.length - 1] : 0;
+        return { deltas, offsets, total, start: decoded.length ? decoded[0] : 0 };
+    }
+
+    // The file type, the movie and the head of the media box, with the frames placed after them.
+    head(large) {
+        if (!this.description) {
+            throw new Error('The encoder gave no decoder configuration of H.264.');
+        }
+        const { deltas, offsets, total } = this.timing();
+        const ftyp = box('ftyp', (b) => b.text('isom').u32(512).text('isom').text('iso2').text('avc1').text('mp41'));
+        const movieDuration = Math.round((total * 1000) / this.timescale);
+        const mdatHead = large ? 16 : 8;
+        // The offsets of the frames follow the movie, whose size changes with the offsets only when
+        // they outgrow 32 bits, so the movie is built again until its size holds.
+        const build = (first) => {
+            const count = this.samples.length;
+            let at = first;
+            const offsetsOfChunks = this.samples.map((s) => {
+                const here = at;
+                at += s.size;
+                return here;
+            });
+            const wide = at > 0xffffffff;
+            const stsd = fullBox('stsd', 0, 0, (b) => b.u32(1), box('avc1', (b) => {
+                b.zeros(6).u16(1).zeros(16).u16(this.width).u16(this.height)
+                    .u32(0x00480000).u32(0x00480000).u32(0).u16(1).zeros(32).u16(0x0018).u16(0xffff);
+            }, box('avcC', (b) => b.push(this.description)),
+            box('pasp', (b) => b.u32(1).u32(1))));
+            const stts = fullBox('stts', 0, 0, (b) => {
+                const list = runs(deltas);
+                b.u32(list.length);
+                for (const [n, delta] of list) {
+                    b.u32(n).u32(delta);
+                }
+            });
+            const tables = [stsd, stts];
+            if (offsets.some((o) => o !== 0)) {
+                tables.push(fullBox('ctts', 1, 0, (b) => {
+                    const list = runs(offsets);
+                    b.u32(list.length);
+                    for (const [n, offset] of list) {
+                        b.u32(n).i32(offset);
+                    }
+                }));
+            }
+            if (this.samples.some((s) => !s.key)) {
+                tables.push(fullBox('stss', 0, 0, (b) => {
+                    const keys = [];
+                    this.samples.forEach((s, i) => s.key && keys.push(i + 1));
+                    b.u32(keys.length);
+                    for (const k of keys) {
+                        b.u32(k);
+                    }
+                }));
+            }
+            tables.push(fullBox('stsc', 0, 0, (b) => b.u32(1).u32(1).u32(1).u32(1)));
+            tables.push(fullBox('stsz', 0, 0, (b) => {
+                b.u32(0).u32(count);
+                for (const s of this.samples) {
+                    b.u32(s.size);
+                }
+            }));
+            tables.push(wide
+                ? fullBox('co64', 0, 0, (b) => {
+                    b.u32(count);
+                    for (const o of offsetsOfChunks) {
+                        b.u64(o);
+                    }
+                })
+                : fullBox('stco', 0, 0, (b) => {
+                    b.u32(count);
+                    for (const o of offsetsOfChunks) {
+                        b.u32(o);
+                    }
+                }));
+            const stbl = box('stbl', null, ...tables);
+            const dinf = box('dinf', null, fullBox('dref', 0, 0, (b) => b.u32(1), fullBox('url ', 0, 1)));
+            const minf = box('minf', null, fullBox('vmhd', 0, 1, (b) => b.zeros(8)), dinf, stbl);
+            const hdlr = fullBox('hdlr', 0, 0, (b) => b.u32(0).text('vide').zeros(12).text('VideoHandler').u8(0));
+            const mdhd = fullBox('mdhd', 0, 0, (b) => b.u32(0).u32(0).u32(this.timescale).u32(total).u16(0x55c4).u16(0));
+            const mdia = box('mdia', null, mdhd, hdlr, minf);
+            const tkhd = fullBox('tkhd', 0, 3, (b) => {
+                b.u32(0).u32(0).u32(1).u32(0).u32(movieDuration).zeros(8).u16(0).u16(0).u16(0).u16(0);
+                for (const value of MATRIX) {
+                    b.u32(value);
+                }
+                b.u32(this.width * 65536).u32(this.height * 65536);
+            });
+            const trak = box('trak', null, tkhd, mdia);
+            const mvhd = fullBox('mvhd', 0, 0, (b) => {
+                b.u32(0).u32(0).u32(1000).u32(movieDuration).u32(0x00010000).u16(0x0100).zeros(10);
+                for (const value of MATRIX) {
+                    b.u32(value);
+                }
+                b.zeros(24).u32(2);
+            });
+            return box('moov', null, mvhd, trak);
+        };
+        let moov = build(ftyp.length + mdatHead);
+        for (let tries = 0; tries < 3; tries++) {
+            const next = build(ftyp.length + moov.length + mdatHead);
+            const settled = next.length === moov.length;
+            moov = next;
+            if (settled) {
+                break;
+            }
+        }
+        const mdatSize = mdatHead + this.bytes;
+        const mdat = new Bytes();
+        if (large) {
+            mdat.u32(1).text('mdat').u64(mdatSize);
+        } else {
+            mdat.u32(mdatSize).text('mdat');
+        }
+        return [ftyp, moov, mdat.bytes()];
+    }
+
+    // The finished file as a blob of the type video/mp4, or as a list of byte arrays where the
+    // runtime has no Blob.
+    finish() {
+        if (!this.samples.length) {
+            throw new Error('The video holds no frames.');
+        }
+        const large = 8 + this.bytes > 0xffffffff;
+        const head = this.head(large);
+        this.flushPending();
+        if (typeof Blob === 'function') {
+            return new Blob([...head, ...this.blobs], { type: 'video/mp4' });
+        }
+        return [...head, ...this.blobs.flat()];
+    }
+}

cuju/render/web/js/export/photo-core.js

@@ -0,0 +1,313 @@
+// Copyright 2026 The cuju Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// The parts of photo mode that need no page and no three.js, the film looks, the frame guides,
+// the sizes of a saved photo, its file name, the checked settings and the reading of a
+// controller. photo.js draws and steers with them, and tests/web/photo.mjs tests them.
+
+import { SIZE_ALIASES, SIZE_PRESETS } from './sizes.js';
+
+// A look grades the finished picture. Exposure is in stops, temperature and tint lean the white
+// balance from minus one to one, contrast and saturation scale around their neutral value of one,
+// fade lifts the blacks, mono turns the picture to black and white, shadows and highlights tint
+// the dark and the bright parts, and gain scales each channel.
+export const LOOKS = Object.freeze([
+    look('natural', 'Natural', {}),
+    look('warm', 'Warm', {
+        exposure: 0.05, temperature: 0.45, tint: 0.05, contrast: 1.05, saturation: 1.08,
+        highlights: [0.03, 0.015, -0.01],
+    }),
+    look('cold', 'Cold', {
+        exposure: -0.03, temperature: -0.45, contrast: 1.06, saturation: 0.9,
+        shadows: [-0.01, 0.01, 0.04],
+    }),
+    look('noir', 'Noir', {
+        exposure: -0.05, contrast: 1.4, saturation: 0, mono: 1, gain: [1.04, 1.04, 1.04],
+    }),
+    look('vintage', 'Vintage', {
+        temperature: 0.2, contrast: 0.9, saturation: 0.7, fade: 0.08,
+        shadows: [0.02, 0.03, 0.01], highlights: [0.03, 0.02, -0.03], gain: [1.02, 0.99, 0.88],
+    }),
+    look('vivid', 'Vivid', {
+        exposure: 0.05, contrast: 1.15, saturation: 1.4,
+    }),
+    look('matchday', 'Matchday', {
+        exposure: 0.04, temperature: 0.1, contrast: 1.12, saturation: 1.2,
+        shadows: [-0.02, 0.01, 0.035], highlights: [0.035, 0.015, -0.015],
+    }),
+]);
+
+function look(id, label, values) {
+    return Object.freeze({
+        id,
+        label,
+        exposure: 0,
+        temperature: 0,
+        tint: 0,
+        contrast: 1,
+        saturation: 1,
+        fade: 0,
+        mono: 0,
+        shadows: [0, 0, 0],
+        highlights: [0, 0, 0],
+        gain: [1, 1, 1],
+        ...values,
+    });
+}
+
+export function lookById(id) {
+    return LOOKS.find((l) => l.id === id) || LOOKS[0];
+}
+
+// The look after or before the given one, round the list.
+export function nextLook(id, step = 1) {
+    const i = Math.max(0, LOOKS.findIndex((l) => l.id === id));
+    return LOOKS[(((i + step) % LOOKS.length) + LOOKS.length) % LOOKS.length].id;
+}
+
+export const GUIDES = Object.freeze([
+    { id: 'off', label: 'Off' },
+    { id: 'thirds', label: 'Rule of thirds' },
+    { id: 'golden', label: 'Golden ratio' },
+    { id: 'center', label: 'Center cross' },
+    { id: 'crop-16-9', label: 'Crop frame, 16 by 9' },
+    { id: 'crop-4-5', label: 'Crop frame, 4 by 5' },
+]);
+
+export function nextGuide(id, step = 1) {
+    const i = Math.max(0, GUIDES.findIndex((g) => g.id === id));
+    return GUIDES[(((i + step) % GUIDES.length) + GUIDES.length) % GUIDES.length].id;
+}
+
+// The window's own size and the shared sizes of sizes.js, each named by its width and height.
+export const RESOLUTIONS = Object.freeze([
+    { id: 'window', label: 'Window size' },
+    ...SIZE_PRESETS.map((p) => Object.freeze({ id: `${p.width}x${p.height}`, width: p.width, height: p.height, label: p.label, preset: p.id })),
+]);
+
+// The smallest and largest side of a saved photo.
+export const MIN_SIDE = 16;
+export const MAX_SIDE = 8192;
+
+// The width and height of a photo for a choice of RESOLUTIONS, a string such as '1280x720', or
+// an object with width and height. Window is the window's own size. A size out of range throws.
+export function resolveResolution(choice, windowWidth, windowHeight, max = MAX_SIDE) {
+    let width;
+    let height;
+    if (choice == null || choice === 'window') {
+        width = Math.round(windowWidth);
+        height = Math.round(windowHeight);
+    } else if (typeof choice === 'object') {
+        ({ width, height } = choice);
+    } else {
+        const named = String(choice).toLowerCase();
+        const known = RESOLUTIONS.find((r) => r.id === choice || r.preset === (SIZE_ALIASES[named] || named));
+        const m = String(choice).match(/^(\d+)\s*[x×]\s*(\d+)$/i);
+        if (known) {
+            ({ width, height } = known);
+        } else if (m) {
+            width = Number(m[1]);
+            height = Number(m[2]);
+        } else {
+            throw new RangeError(`Unknown resolution ${JSON.stringify(choice)}, use window, a width and height such as 1280x720, or a size of ${SIZE_PRESETS.map((p) => p.id).join(', ')}.`);
+        }
+    }
+    const limit = Math.min(MAX_SIDE, Math.max(MIN_SIDE, Math.floor(max)));
+    for (const [name, value] of [['width', width], ['height', height]]) {
+        if (!Number.isInteger(value) || value < MIN_SIDE || value > limit) {
+            throw new RangeError(`The ${name} of a photo is a whole number from ${MIN_SIDE} to ${limit}, not ${value}.`);
+        }
+    }
+    return { width, height };
+}
+
+// The part of a view of the given size that a photo of another shape shows, centered. A narrower
+// photo keeps the height of the view and a wider one keeps its width.
+export function captureRegion(viewWidth, viewHeight, outWidth, outHeight) {
+    return fitAspect({ x: 0, y: 0, width: viewWidth, height: viewHeight }, outWidth / outHeight);
+}
+
+// The vertical field of view in degrees of a photo of another shape, so it shows exactly the
+// region of captureRegion.
+export function captureFov(fov, viewAspect, outAspect) {
+    if (!(outAspect > viewAspect)) {
+        return fov;
+    }
+    const half = Math.tan((fov * Math.PI) / 360) * (viewAspect / outAspect);
+    return (Math.atan(half) * 360) / Math.PI;
+}
+
+// The largest rectangle of the given aspect inside a rectangle, centered in it.
+export function fitAspect(rect, aspect) {
+    if (rect.width / rect.height > aspect) {
+        const width = rect.height * aspect;
+        return { x: rect.x + (rect.width - width) / 2, y: rect.y, width, height: rect.height };
+    }
+    const height = rect.width / aspect;
+    return { x: rect.x, y: rect.y + (rect.height - height) / 2, width: rect.width, height };
+}
+
+const GOLDEN = (Math.sqrt(5) - 1) / 2;
+
+// The lines of a guide over a view of the given size, each [x1, y1, x2, y2] in pixels, and the
+// frame, the part of the view that a saved photo or a crop frame keeps, or null when that is the
+// whole view. Output is the size of the photo, or null for the window's size.
+export function guideGeometry(kind, width, height, output = null) {
+    const region = output ? captureRegion(width, height, output.width, output.height) : { x: 0, y: 0, width, height };
+    let frame = region;
+    if (kind === 'crop-16-9' || kind === 'crop-4-5') {
+        frame = fitAspect(region, kind === 'crop-16-9' ? 16 / 9 : 4 / 5);
+    }
+    const lines = [];
+    const cut = (fractions) => {
+        for (const f of fractions) {
+            const x = frame.x + f * frame.width;
+            const y = frame.y + f * frame.height;
+            lines.push([x, frame.y, x, frame.y + frame.height]);
+            lines.push([frame.x, y, frame.x + frame.width, y]);
+        }
+    };
+    if (kind === 'thirds') {
+        cut([1 / 3, 2 / 3]);
+    } else if (kind === 'golden') {
+        cut([1 - GOLDEN, GOLDEN]);
+    } else if (kind === 'center') {
+        const cx = frame.x + frame.width / 2;
+        const cy = frame.y + frame.height / 2;
+        const arm = Math.min(frame.width, frame.height) * 0.05;
+        lines.push([cx - arm, cy, cx + arm, cy], [cx, cy - arm, cx, cy + arm]);
+    }
+    const whole = frame.width >= width - 0.5 && frame.height >= height - 0.5;
+    return { kind, lines, frame: whole ? null : frame };
+}
+
+// The name of a saved photo, from the recording or source and the frame shown.
+export function photoFileName(recording, frame) {
+    const slug = String(recording ?? '').toLowerCase().replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/-{2,}/g, '-').replace(/^[-.]+|[-.]+$/g, '').slice(0, 64).replace(/[-.]+$/, '') || 'view';
+    const part = Number.isInteger(frame) && frame >= 0 ? `-${frame}` : '';
+    return `cuju-photo-${slug}${part}.png`;
+}
+
+// The focus distance in meters and its slider, from 0 to 1000 on a logarithmic scale.
+export const FOCUS_MIN = 0.5;
+export const FOCUS_MAX = 300;
+
+export function focusToSlider(meters) {
+    const m = Math.min(FOCUS_MAX, Math.max(FOCUS_MIN, meters));
+    return Math.round((1000 * Math.log(m / FOCUS_MIN)) / Math.log(FOCUS_MAX / FOCUS_MIN));
+}
+
+export function sliderToFocus(value) {
+    const v = Math.min(1000, Math.max(0, Number(value) || 0));
+    return Math.round(FOCUS_MIN * Math.pow(FOCUS_MAX / FOCUS_MIN, v / 1000) * 10) / 10;
+}
+
+export const DEFAULTS = Object.freeze({
+    look: 'natural',
+    vignette: 0.2,
+    grain: 0.05,
+    focus: 'auto',
+    aperture: 0.15,
+    fov: 40,
+    roll: 0,
+    guide: 'off',
+    resolution: 'window',
+});
+
+// The ranges of the numeric settings, field of view and roll in degrees.
+export const RANGES = Object.freeze({
+    vignette: [0, 1],
+    grain: [0, 1],
+    aperture: [0, 1],
+    fov: [10, 100],
+    roll: [-90, 90],
+});
+
+// The settings after a change, each value checked. An unknown name or a value out of place
+// throws with a message that says what fits, so a script learns its mistake. A number out of its
+// range throws when strict, as for a script, and is held to the range otherwise, as for the keys
+// and the controller that step a setting past its end.
+export function normalizeSettings(current, patch, { strict = false } = {}) {
+    const next = { ...DEFAULTS, ...current };
+    if (patch == null) {
+        return next;
+    }
+    if (typeof patch !== 'object') {
+        throw new TypeError('Photo settings are an object, such as { look: \'noir\', vignette: 0.4 }.');
+    }
+    for (const [key, value] of Object.entries(patch)) {
+        if (key === 'look') {
+            if (!LOOKS.some((l) => l.id === value)) {
+                throw new RangeError(`Unknown look ${JSON.stringify(value)}, use one of ${LOOKS.map((l) => l.id).join(', ')}.`);
+            }
+            next.look = value;
+        } else if (key === 'guide') {
+            if (!GUIDES.some((g) => g.id === value)) {
+                throw new RangeError(`Unknown guide ${JSON.stringify(value)}, use one of ${GUIDES.map((g) => g.id).join(', ')}.`);
+            }
+            next.guide = value;
+        } else if (key === 'focus') {
+            if (value === 'auto' || value === null) {
+                next.focus = 'auto';
+            } else if (typeof value === 'number' && Number.isFinite(value) && (!strict || (value >= FOCUS_MIN && value <= FOCUS_MAX))) {
+                next.focus = Math.min(FOCUS_MAX, Math.max(FOCUS_MIN, value));
+            } else {
+                throw new RangeError(`The focus is 'auto' or a distance in meters from ${FOCUS_MIN} to ${FOCUS_MAX}.`);
+            }
+        } else if (key === 'resolution') {
+            const size = resolveResolution(value, 1920, 1080);
+            // A preset's name keeps the identifier of its width and height, as the panel lists it.
+            const listed = RESOLUTIONS.find((r) => r.width === size.width && r.height === size.height);
+            next.resolution = typeof value === 'object' ? { width: value.width, height: value.height }
+                : typeof value === 'string' && value !== 'window' && listed ? listed.id : value;
+        } else if (key in RANGES) {
+            const [lo, hi] = RANGES[key];
+            if (typeof value !== 'number' || !Number.isFinite(value) || (strict && (value < lo || value > hi))) {
+                throw new RangeError(`The ${key} is a number from ${lo} to ${hi}, not ${JSON.stringify(value)}.`);
+            }
+            next[key] = Math.min(hi, Math.max(lo, value));
+        } else {
+            throw new RangeError(`Unknown photo setting ${JSON.stringify(key)}, use ${Object.keys(DEFAULTS).join(', ')}.`);
+        }
+    }
+    return next;
+}
+
+// The buttons of a controller with the standard mapping that photo mode uses, by index.
+export const PAD_BUTTONS = Object.freeze({
+    0: 'save', 1: 'leave', 2: 'interface', 3: 'guide', 4: 'previousLook', 5: 'nextLook',
+});
+
+function stick(x, y, deadzone) {
+    const length = Math.hypot(x, y);
+    if (!(length > deadzone)) {
+        return [0, 0];
+    }
+    const scale = Math.min(1, (length - deadzone) / (1 - deadzone)) / length;
+    return [x * scale, y * scale];
+}
+
+const buttonValue = (b) => (typeof b === 'number' ? b : (b ? (b.pressed ? Math.max(0.5, b.value || 1) : b.value || 0) : 0));
+
+// What a controller asks for, from its axes and buttons and the buttons held at the last poll.
+// Move and look are the sticks past the dead zone, rise is the right trigger less the left one,
+// zoom and roll are the vertical and horizontal pad, and pressed names the buttons of PAD_BUTTONS
+// pressed since the last poll.
+export function readPad(pad, before = [], deadzone = 0.15) {
+    const axes = (pad && pad.axes) || [];
+    const raw = (pad && pad.buttons) || [];
+    const value = (i) => buttonValue(raw[i]);
+    const buttons = raw.map((b, i) => value(i) > 0.5);
+    const pressed = Object.entries(PAD_BUTTONS)
+        .filter(([i]) => buttons[i] && !before[i]).map(([, name]) => name);
+    return {
+        move: stick(axes[0] || 0, axes[1] || 0, deadzone),
+        look: stick(axes[2] || 0, axes[3] || 0, deadzone),
+        rise: value(7) - value(6),
+        zoom: (buttons[13] ? 1 : 0) - (buttons[12] ? 1 : 0),
+        roll: (buttons[15] ? 1 : 0) - (buttons[14] ? 1 : 0),
+        pressed,
+        buttons,
+    };
+}