pelican-engine 0.0.0-stage → 0.3.1

package/lib/renderer/ui.js

@@ -0,0 +1,446 @@
+export function createUIRenderer(definitions, callbacks) {
+    const root = document.createElement("div");
+    root.dataset.pelicanUi = "";
+    Object.assign(root.style, {
+        position: "absolute",
+        inset: "0",
+        pointerEvents: "none",
+        zIndex: "3",
+        fontFamily: "system-ui",
+        color: "white",
+    });
+    const rows = new Map();
+    let order = [];
+    let mounted = false;
+    let disposed = false;
+    let sequence = 0;
+    let reportedFocus = null;
+    const traces = [];
+    const listeners = [];
+    let previousPads = new Map();
+    let gamepad = {
+        source: "none",
+        hardwareVerified: false,
+        index: null,
+        connected: 0,
+    };
+    function selection(row) {
+        const node = row.input;
+        return node
+            ? {
+                start: node.selectionStart ?? 0,
+                end: node.selectionEnd ?? 0,
+                direction: node.selectionDirection ?? "none",
+            }
+            : null;
+    }
+    function trace(type, row, event) {
+        const source = event;
+        traces.push({
+            sequence: ++sequence,
+            type,
+            id: row?.definition.id ?? null,
+            value: row?.input?.value ?? null,
+            composing: row?.composing ?? false,
+            selection: row ? selection(row) : null,
+            data: typeof source?.data === "string" ? source.data : null,
+            inputType: source && "inputType" in source ? source.inputType : null,
+            trusted: event?.isTrusted ?? false,
+        });
+        if (traces.length > 128)
+            traces.splice(0, traces.length - 128);
+    }
+    function focused() {
+        return [...rows.values()].find((row) => row.node === document.activeElement);
+    }
+    function interactive(row) {
+        return (mounted &&
+            !disposed &&
+            row.shown &&
+            root.isConnected &&
+            (row.definition.kind === "button" || row.definition.kind === "input"));
+    }
+    function targetRow(event) {
+        return [...rows.values()].find((row) => row.node === event.target);
+    }
+    function emitText(row) {
+        if (!row.input || row.composing || !interactive(row))
+            return;
+        const text = row.input.value;
+        if (row.emittedText === text)
+            return;
+        row.emittedText = text;
+        row.pendingCommit = text;
+        callbacks.emit("ui.text", {
+            id: row.definition.id,
+            text,
+            composing: false,
+        });
+    }
+    function listen(type, action) {
+        const listener = (event) => {
+            const row = targetRow(event);
+            if (row && !disposed)
+                action(event, row);
+        };
+        listeners.push({ type, listener });
+        root.addEventListener(type, listener);
+    }
+    function reportFocus(id) {
+        if (reportedFocus === id)
+            return;
+        reportedFocus = id;
+        callbacks.emit("ui.focus", { id });
+    }
+    listen("focusin", (event, row) => {
+        trace("focusin", row, event);
+        reportFocus(row.definition.id);
+    });
+    listen("focusout", (event, row) => {
+        trace("focusout", row, event);
+        reportFocus(null);
+    });
+    listen("compositionstart", (event, row) => {
+        if (!row.input || !interactive(row))
+            return;
+        row.composing = true;
+        trace(event.type, row, event);
+    });
+    listen("compositionupdate", (event, row) => trace(event.type, row, event));
+    listen("compositionend", (event, row) => {
+        row.composing = false;
+        trace(event.type, row, event);
+        emitText(row);
+    });
+    for (const type of ["beforeinput", "paste", "select"])
+        listen(type, (event, row) => trace(type, row, event));
+    listen("input", (event, row) => {
+        trace("input", row, event);
+        if (!event.isComposing)
+            emitText(row);
+    });
+    listen("keydown", (event, row) => {
+        const key = event;
+        if (!row.input || !interactive(row))
+            return;
+        trace("keydown", row, event);
+        if (key.key === "Enter" &&
+            !key.isComposing &&
+            !row.composing &&
+            key.keyCode !== 229) {
+            key.preventDefault();
+            if (!key.repeat)
+                callbacks.emit("ui.submit", {
+                    id: row.definition.id,
+                    text: row.input.value,
+                });
+        }
+    });
+    listen("click", (event, row) => {
+        if (row.definition.kind !== "button" || !interactive(row))
+            return;
+        trace("activate", row, event);
+        callbacks.input("ui:" + row.definition.id, true);
+        callbacks.input("ui:" + row.definition.id, false);
+        callbacks.emit("ui.activate", { id: row.definition.id });
+    });
+    function retire(row) {
+        row.shown = false;
+        row.composing = false;
+        if (row.node === document.activeElement)
+            row.node.blur();
+        row.node.remove();
+    }
+    function render(elements, positions) {
+        const ids = new Set();
+        for (const definition of elements) {
+            if (ids.has(definition.id))
+                throw new Error("TC_UI_DUPLICATE_ID: " + definition.id);
+            ids.add(definition.id);
+        }
+        for (const [id, row] of rows) {
+            if (!ids.has(id)) {
+                retire(row);
+                rows.delete(id);
+            }
+        }
+        order = elements.map((element) => element.id);
+        for (const definition of elements) {
+            let row = rows.get(definition.id);
+            if (row && row.definition.kind !== definition.kind) {
+                retire(row);
+                rows.delete(definition.id);
+                row = undefined;
+            }
+            if (!row) {
+                const node = document.createElement(definition.kind === "button"
+                    ? "button"
+                    : definition.kind === "bar"
+                        ? "progress"
+                        : definition.kind === "input"
+                            ? "input"
+                            : "div");
+                node.dataset.pelicanElement = definition.id;
+                Object.assign(node.style, {
+                    position: "absolute",
+                    padding: "8px 12px",
+                    borderRadius: "8px",
+                    background: "rgba(12,20,31,0.82)",
+                    fontSize: "16px",
+                    boxSizing: "border-box",
+                    maxWidth: "90%",
+                });
+                const input = definition.kind === "input" ? node : null;
+                if (input) {
+                    input.type = "text";
+                    input.autocomplete = "off";
+                    input.value = definition.text;
+                }
+                if (definition.kind === "button")
+                    node.type = "button";
+                if (definition.kind === "bar")
+                    node.max = 1;
+                row = {
+                    definition,
+                    node,
+                    input,
+                    shown: false,
+                    composing: false,
+                    authoredText: definition.text,
+                    emittedText: null,
+                    pendingCommit: null,
+                };
+                rows.set(definition.id, row);
+                root.appendChild(node);
+            }
+            row.definition = {
+                ...definition,
+                world: definition.world
+                    ? {
+                        ...definition.world,
+                        offset: [...definition.world.offset],
+                    }
+                    : undefined,
+            };
+            const { node, input } = row;
+            // Per-element keys allow distinct offsets on the same world entity.
+            const position = definition.world
+                ? positions?.get(definition.id)
+                : undefined;
+            row.shown =
+                definition.visible &&
+                    (!definition.world ||
+                        (!!position &&
+                            position.visible &&
+                            Number.isFinite(position.x) &&
+                            Number.isFinite(position.y) &&
+                            (!definition.world.occlude || !position.occluded)));
+            if (!row.shown) {
+                // No hidden control can emit a blur commit or retain keyboard/gamepad focus.
+                row.composing = false;
+                if (node === document.activeElement)
+                    node.blur();
+            }
+            node.hidden = !row.shown;
+            node.style.display = row.shown ? "" : "none";
+            const control = definition.kind === "input" || definition.kind === "button";
+            if (control)
+                node.disabled = !row.shown;
+            node.tabIndex = control && row.shown ? 0 : -1;
+            node.style.pointerEvents = control && row.shown ? "auto" : "none";
+            node.style.width = definition.width + "px";
+            node.style.color = definition.color;
+            const style = node.style;
+            style.left =
+                style.right =
+                    style.top =
+                        style.bottom =
+                            style.transform =
+                                "";
+            if (definition.world) {
+                style.left = (position?.x ?? 0) + "px";
+                style.top = (position?.y ?? 0) + "px";
+            }
+            else if (definition.anchor === "center") {
+                Object.assign(style, {
+                    left: "50%",
+                    top: "50%",
+                    transform: "translate(-50%,-50%)",
+                });
+            }
+            else {
+                style[definition.anchor.endsWith("right") ? "right" : "left"] =
+                    definition.x + "px";
+                style[definition.anchor.startsWith("bottom") ? "bottom" : "top"] =
+                    definition.y + "px";
+            }
+            if (input) {
+                const active = document.activeElement === input;
+                const pending = row.pendingCommit !== null;
+                const echo = pending && definition.text === row.pendingCommit;
+                const allowWrite = !row.composing && !(active && pending);
+                // A game tick may still contain the pre-commit value. Wait for its exact echo while focused.
+                if (allowWrite &&
+                    (row.authoredText !== definition.text || pending) &&
+                    input.value !== definition.text) {
+                    const saved = selection(row);
+                    input.value = definition.text;
+                    input.setSelectionRange(Math.min(saved.start, input.value.length), Math.min(saved.end, input.value.length), saved.direction);
+                    row.emittedText = definition.text;
+                }
+                if (echo || (!active && !row.composing))
+                    row.pendingCommit = null;
+                row.authoredText = definition.text;
+            }
+            else if (definition.kind === "bar") {
+                node.value = definition.value;
+            }
+            else if (node.textContent !== definition.text)
+                node.textContent = definition.text;
+        }
+    }
+    function moveFocus(direction) {
+        const candidates = order.map((id) => rows.get(id)).filter(interactive);
+        if (!candidates.length)
+            return;
+        const index = candidates.indexOf(focused());
+        const next = index < 0
+            ? direction > 0
+                ? 0
+                : candidates.length - 1
+            : (index + direction + candidates.length) % candidates.length;
+        candidates[next].node.focus({ preventScroll: true });
+        trace("gamepad.focus", candidates[next]);
+    }
+    function pollGamepads() {
+        const samples = typeof navigator.getGamepads === "function"
+            ? navigator.getGamepads()
+            : [];
+        const nextPads = new Map();
+        gamepad = {
+            source: "none",
+            hardwareVerified: false,
+            index: null,
+            connected: 0,
+        };
+        for (const pad of samples) {
+            if (!pad?.connected || pad.mapping !== "standard")
+                continue;
+            gamepad.connected++;
+            if (gamepad.index === null) {
+                gamepad.index = pad.index;
+                gamepad.source =
+                    typeof Gamepad !== "undefined" && pad instanceof Gamepad
+                        ? "physical"
+                        : "virtual";
+            }
+            const pressed = (index) => pad.buttons[index]?.pressed === true ||
+                (pad.buttons[index]?.value ?? 0) > 0.5;
+            const state = [
+                pressed(12) || (pad.axes[1] ?? 0) < -0.5,
+                pressed(14) || (pad.axes[0] ?? 0) < -0.5,
+                pressed(13) || (pad.axes[1] ?? 0) > 0.5,
+                pressed(15) || (pad.axes[0] ?? 0) > 0.5,
+                pressed(0),
+            ];
+            const previous = previousPads.get(pad.index) ?? [
+                false,
+                false,
+                false,
+                false,
+                false,
+            ];
+            nextPads.set(pad.index, state);
+            // Consume edges during IME without moving focus or activating another control.
+            if ([...rows.values()].some((row) => row.composing))
+                continue;
+            const direction = state.findIndex((value, index) => index < 4 && value && !previous[index]);
+            if (direction >= 0)
+                moveFocus(direction < 2 ? -1 : 1);
+            if (state[4] && !previous[4]) {
+                const row = focused();
+                if (!row || !interactive(row))
+                    moveFocus(1);
+                else if (row.definition.kind === "button")
+                    row.node.click();
+            }
+        }
+        previousPads = nextPads;
+    }
+    render(definitions);
+    return {
+        mount() {
+            if (disposed || mounted)
+                return;
+            document.body.appendChild(root);
+            mounted = true;
+            trace("mount");
+        },
+        present(elements, positions) {
+            if (disposed)
+                return;
+            render(elements, positions);
+            if (mounted)
+                pollGamepads();
+        },
+        consumesKeyboard(event) {
+            if (disposed || !mounted)
+                return false;
+            return (event.isComposing ||
+                [...rows.values()].some((row) => row.composing) ||
+                !!focused()?.input ||
+                !!targetRow(event)?.input);
+        },
+        inspect() {
+            const focus = focused();
+            return {
+                mounted,
+                disposed,
+                focus: focus?.definition.id ?? null,
+                composing: [...rows.values()].some((row) => row.composing),
+                inputValue: focus?.input?.value ?? null,
+                selection: focus ? selection(focus) : null,
+                elements: order.map((id) => {
+                    const row = rows.get(id);
+                    return {
+                        id,
+                        kind: row.definition.kind,
+                        visible: row.shown,
+                        composing: row.composing,
+                        inputValue: row.input?.value ?? null,
+                        selection: selection(row),
+                        pendingCommit: row.pendingCommit,
+                    };
+                }),
+                trace: traces.map((entry) => ({
+                    ...entry,
+                    selection: entry.selection ? { ...entry.selection } : null,
+                })),
+                gamepad: { ...gamepad },
+            };
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            mounted = false;
+            reportFocus(null);
+            for (const { type, listener } of listeners)
+                root.removeEventListener(type, listener);
+            listeners.length = 0;
+            for (const row of rows.values())
+                retire(row);
+            rows.clear();
+            order = [];
+            previousPads.clear();
+            gamepad = {
+                source: "none",
+                hardwareVerified: false,
+                index: null,
+                connected: 0,
+            };
+            root.remove();
+            trace("dispose");
+        },
+    };
+}

package/lib/renderer/vertex-bounds.js

@@ -0,0 +1,127 @@
+import * as THREE from "three/webgpu";
+import { createSurfaceCapture } from "./surface-capture.js";
+import { createSurfaceAcceleration } from "./acceleration.js";
+const fail = (message) => { throw new Error("TC_VERTEX_BOUNDS: " + message + " Repair: Supply finite nonsingular transforms and valid vertex graphs."); };
+const entityName = (mesh) => {
+    for (let object = mesh; object; object = object.parent)
+        if (Object.hasOwn(object.userData, "pelicanPrefab"))
+            return object.name;
+    return mesh.parent?.name ?? "";
+};
+/** Content-owned derived bounds and render raycasts; explicit physics colliders are separate. */
+export function createVertexBoundsOwner() {
+    const capture = createSurfaceCapture();
+    const states = new Map();
+    let disposed = false, updates = 0;
+    const restore = (state) => {
+        for (const [name, descriptor] of [["boundingSphere", state.sphere], ["boundingBox", state.box], ["raycast", state.raycast]]) {
+            if (descriptor)
+                Object.defineProperty(state.mesh, name, descriptor);
+            else
+                delete state.mesh[name];
+        }
+        state.acceleration.dispose();
+    };
+    const install = (mesh, surface, triangles) => {
+        const state = { mesh, sphere: Object.getOwnPropertyDescriptor(mesh, "boundingSphere"), box: Object.getOwnPropertyDescriptor(mesh, "boundingBox"), raycast: Object.getOwnPropertyDescriptor(mesh, "raycast"), acceleration: createSurfaceAcceleration(), surface: { ...surface, triangles } };
+        mesh.raycast = (raycaster, intersections) => {
+            const direction = raycaster.ray.direction.clone().normalize();
+            const near = Math.max(0, raycaster.near), far = raycaster.far;
+            if (far < near)
+                return;
+            const origin = raycaster.ray.origin.clone().addScaledVector(direction, near);
+            const hit = state.acceleration.intersect(origin.toArray(), direction.toArray(), far - near);
+            if (!hit)
+                return;
+            const triangle = state.surface.triangles[hit.triangleIndex];
+            const point = origin.addScaledVector(direction, hit.distance);
+            const [a, b, c] = triangle.vertexIndices;
+            const inverse = mesh.matrixWorld.clone().invert();
+            const local = triangle.vertices.map(vertex => new THREE.Vector3(...vertex.position).applyMatrix4(inverse));
+            const faceNormal = new THREE.Triangle(local[0], local[1], local[2]).getNormal(new THREE.Vector3());
+            intersections.push({ distance: near + hit.distance, point, object: mesh, faceIndex: triangle.elementOffset / 3, face: { a, b, c, normal: faceNormal, materialIndex: triangle.materialIndex }, ...(triangle.instanceId !== undefined ? { instanceId: triangle.instanceId } : {}) });
+        };
+        return state;
+    };
+    return {
+        update(scene, graphs) {
+            if (disposed)
+                fail("Derived vertex owner is disposed.");
+            if (![...graphs.values()].some(binding => binding.vertex)) {
+                for (const state of states.values())
+                    restore(state);
+                states.clear();
+                return;
+            }
+            const captured = capture.capture(scene, new Set(graphs.keys()), graphs, { geometryOnly: true });
+            const byObject = new Map();
+            for (const triangle of captured.surface.triangles) {
+                if (!byObject.has(triangle.objectUuid))
+                    byObject.set(triangle.objectUuid, []);
+                byObject.get(triangle.objectUuid).push(triangle);
+            }
+            const staged = [];
+            scene.traverseVisible(object => {
+                if (!(object instanceof THREE.Mesh))
+                    return;
+                const triangles = byObject.get(object.uuid);
+                if (!triangles)
+                    return;
+                const inverse = object.matrixWorld.clone().invert();
+                const bounds = new THREE.Box3();
+                for (const triangle of triangles)
+                    for (const vertex of triangle.vertices)
+                        bounds.expandByPoint(new THREE.Vector3(...vertex.position).applyMatrix4(inverse));
+                const sphere = bounds.getBoundingSphere(new THREE.Sphere());
+                if (![...bounds.min.toArray(), ...bounds.max.toArray(), ...sphere.center.toArray(), sphere.radius].every(Number.isFinite))
+                    fail("Derived bounds are nonfinite for " + object.uuid);
+                staged.push({ mesh: object, triangles, bounds, sphere });
+            });
+            const live = new Set(staged.map(item => item.mesh));
+            for (const [mesh, state] of states)
+                if (!live.has(mesh)) {
+                    restore(state);
+                    states.delete(mesh);
+                }
+            for (const item of staged) {
+                let state = states.get(item.mesh);
+                if (!state) {
+                    state = install(item.mesh, captured.surface, item.triangles);
+                    states.set(item.mesh, state);
+                }
+                const next = { ...captured.surface, triangles: item.triangles };
+                state.acceleration.update(next);
+                state.surface = next;
+                Object.defineProperty(item.mesh, "boundingBox", { configurable: true, writable: true, enumerable: true, value: item.bounds });
+                Object.defineProperty(item.mesh, "boundingSphere", { configurable: true, writable: true, enumerable: true, value: item.sphere });
+            }
+            updates++;
+        },
+        inspect() {
+            return { disposed, updates, meshes: states.size, capture: capture.inspect(), accelerations: [...states.values()].map(state => ({ object: state.mesh.uuid, ...state.acceleration.inspect() })), bounds: [...states.values()].map(state => {
+                    const mesh = state.mesh;
+                    return { object: mesh.uuid, entity: entityName(mesh), frustumCulled: mesh.frustumCulled, center: mesh.boundingSphere.center.toArray(), worldCenter: mesh.boundingSphere.center.clone().applyMatrix4(mesh.matrixWorld).toArray(), radius: mesh.boundingSphere.radius, min: mesh.boundingBox.min.toArray(), max: mesh.boundingBox.max.toArray() };
+                }) };
+        },
+        intersect(origin, direction, maxDistance = Infinity) {
+            if (disposed)
+                fail("Derived vertex owner is disposed.");
+            let nearest = null;
+            for (const state of states.values()) {
+                const hit = state.acceleration.intersect(origin, direction, maxDistance);
+                if (hit && (!nearest || hit.distance < nearest.distance))
+                    nearest = { distance: hit.distance, normal: hit.normal, object: state.mesh.uuid, entity: entityName(state.mesh) };
+            }
+            return nearest;
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            for (const state of states.values())
+                restore(state);
+            states.clear();
+            capture.dispose();
+        },
+    };
+}

package/lib/renderer/vertex-contract.js

@@ -0,0 +1 @@
+export {};