3draft 26.11.1013 → 26.11.2005

package/README.md

@@ -71,7 +71,7 @@ keeps the framing fixed while it moves.
 space and picks stay valid. `standOn(mesh, hit, { base, height, color })`
 returns a prism standing on the picked surface along its normal (height
 defaults to 3 x base). In the viewer, Space puts one down under the cross and
-Backspace takes the last one back. Over empty space Space shoots the prism out along the cursor ray to a random distance, animated. The viewer starts empty (no table) and lays out only what you place. D deletes the prism under the cross. H toggles edges and points. T flies the camera, animated, to the object under the cross and in front of the surface you point at (the whole scene is framed again when T is pressed over nothing, or with Reset view). Prisms get a random wood brown.
+Backspace takes the last one back. Over empty space Space shoots the prism out under the cursor to a random distance, animated, flying exactly along the camera axis (it lies along that axis like a bullet). The viewer starts empty (no table) and lays out only what you place. X deletes the prism under the cross. V is the Spider bar: the first V remembers the surface point under the cross, the second joins the two points with a thin prism (half the base of a shot prism, a darker brown); V over empty space forgets a pending first point. T flies the camera straight to the front of the object under the cross without turning it; T over nothing sets the speed to zero. W A S D R F fly: every press is a speed step along that axis (the speed grows faster than the level: 1, 2.7, 5.6, 9.9 ...) (w w w = speed 3 forward, s s s brings it back to a stop), R and F go up and down. While Shift is held the view turns towards the pointer, faster the farther the pointer is from the middle. H toggles edges and points. T flies the camera, animated, to the object under the cross and in front of the surface you point at (the whole scene is framed again when T is pressed over nothing, or with Reset view). Prisms get a random wood brown. On a phone or tablet the stage fills the screen with no text: drag orbits, and four round translucent buttons do T, Space, D and the SVG/WebGPU switch (the cross starts in the middle and stays where you last touched).
 
 ### WebGPU view
 
@@ -144,16 +144,58 @@ Everything is deterministic, so the same calls give the same SVG.
 - Edges are the polygon outlines, so hidden edges are not drawn.
 - Back-face culling assumes closed meshes with CCW faces seen from outside.
 
+## TypeScript and the `|>` pipeline operator
+
+The engine is written in TypeScript (`src/*.ts`) with the F# style pipeline operator, `value |> fn`
+(see [Pipeline operator great again](https://dev.to/pengeszikra/pipeline-operator-great-again-1cbn)).
+Neither `tsc` nor Node understands `|>` yet, so `npm run build` (`scripts/build.mjs`) first rewrites
+every `|>` into plain calls (`scripts/pipe.mjs`, `a |> f |> g(1)` becomes `g(1)(f(a))`) and then lets the
+TypeScript compiler type check and emit `dist/*.js` and `dist/*.d.ts`.
+
+```ts
+const t1 = mesh.positions[b] |> minus(mesh.positions[a]) |> norm;   // the right side is a function
+const dir = spec.dir |> norm |> times(dist) |> plus(center);          // curried helpers: plus, minus, times
+```
+
+- The right side must evaluate to a function; put an arrow function in parentheses: `x |> ((v) => v + 1)`.
+- `|>` binds like `>>>` while it is parsed, so wrap a pipeline in parentheses next to `+`, `-` and friends.
+- `dist/` is committed: the viewer, the examples, the MCP server and the npm package use the built JavaScript, so a
+  clone runs without a build. `npm run build:check` fails when `dist/` is out of date, `npm test` builds first.
+- The compiler is a dev dependency (`typescript`); `TYPESCRIPT=/path/to/typescript.js` points the build at another copy.
+
+## Develop
+
+```bash
+npm run build        # src/*.ts -> dist/ (|> desugared, type checked)
+npm test             # builds, then runs every test (dist, examples, mcp, scripts)
+npm run build:check  # fails when dist/ is out of date
+npm run kernel       # re-assemble kernel/pick.hexaw (needs the hexaw repo next to this one)
+npm run app          # the viewer, http://localhost:5173/app/
+```
+
+Edit `src/*.ts`, never `dist/`: it is generated and committed so that a clone runs without a build.
+
 ## Viewer app (repo only, not part of the npm package)
 
 ```sh
 npm run app     # http://localhost:5173/app/
 ```
 
-Drag to rotate the view, double click to reset. G switches between the SVG and the WebGPU view, L turns the light (WebGPU). A
-target cross follows the pointer and lies on the surface under it. It is a
+Drag to rotate the view, double click to reset. A target cross follows the pointer and lies on the surface under it.
+
+| key | does |
+| --- | --- |
+| `w a s d r f` | fly: forward, left, back, right, up, down; every press is a speed step (an accelerating curve), the opposite key slows down |
+| `Shift` | steer towards the pointer while flying |
+| `Space` | place a prism on the surface (or shoot one into empty space) |
+| `V` | Spider bar: two surface points joined by a thin brown prism; `V` over empty space forgets the first point |
+| `T` | travel to the target (a straight flight); `T` over nothing stops and zeroes the speed |
+| `X`, `Backspace` | delete the prism under the cross, undo |
+| `H`, `G`, `L` | edges, SVG / WebGPU view, light |
+
+On a phone the four round buttons do the same. The viewer picks with the HEXAW kernel (the footer shows `pick hexaw`). It is a
 single `app/index.html` plus a dependency-free static server
-(`app/serve.js`, localhost only, serves `app/`, `src/` and `examples/`).
+(`app/serve.js`, localhost only, serves `app/`, `dist/` and `examples/`).
 
 ## Versioning
 
@@ -168,7 +210,7 @@ day * 1000 + build:
 | `26.11.15.012` | `26.11.15012`   |
 
 `npm run bump` sets the next version for today's date in `package.json` and
-`src/index.js` (`node scripts/bump.js --dry` only prints it).
+`src/index.ts` (`node scripts/bump.js --dry` only prints it).
 
 ## Idea
 
@@ -192,3 +234,22 @@ day * 1000 + build:
 ## License
 
 MIT
+
+## Examples
+
+- `examples/table.js`: the table demo (`npm run example`).
+- `examples/bridge.js`: a stone arch bridge of 50 named objects (`npm run bridge`). It writes `examples/bridge.scene.json`, a scene file you can load with the MCP `import` tool (`path: "examples/bridge.scene.json"`).
+- `examples/cessna.js`: a small Cessna as ONE mesh with 9 face colours (single flat material, colour per face): lofted closed parts (fuselage, high wing, tail, struts, gear, spinner, propeller) merged into one mesh. `node examples/cessna.js` checks it and writes `examples/cessna.scene.json` (one object, loadable with the MCP `import` tool) and `examples/out/cessna.svg`.
+
+## HEXAW kernel
+
+The picking hot loop (ray against every triangle, Moller-Trumbore, the same arithmetic as `src/pick.ts`) is also written in
+[HEXAW](https://github.com/Pengeszikra/hexaw), the byte-visible WebAssembly assembly dialect:
+
+- `kernel/pick.hexaw` is the source (569 bytes of WebAssembly once assembled).
+- `npm run kernel` assembles it with `hexaw-core.js` (found through `HEXAW_CORE`, a checkout next to this repo, or the `hexaw` package) and writes `src/kernel-bytes.ts`, the module as base64 (then `npm run build` carries it into `dist/`). The engine needs neither HEXAW nor a file fetch at runtime. `node scripts/build-kernel.mjs --check` fails when the generated file is out of date.
+- `initKernel()` starts it; `kernel.pick(mesh, camera, x, y)` returns exactly what `pick()` returns. The mesh is copied into the kernel's linear memory once for as long as it is the same object.
+- The viewer uses the kernel as soon as it has started (the footer shows `pick hexaw`), and plain `pick()` before that.
+- Measured on 1200 prisms (7200 faces): 1.7 ms per pick in JavaScript, 0.14 ms with the kernel.
+
+The kernel exports its linear memory (`EXPM "memory"`, needs hexaw with JS-compatible memory), so the mesh is written straight into it with `Float64Array` / `Int32Array` views and the distance is read back from address 0; the former `setf`/`seti`/`getf`/`grow`/`size` helper functions are gone.

package/dist/camera.d.ts

@@ -0,0 +1,29 @@
+import type { Camera, Fit, Mesh, Vec3, ViewName, ViewSpec } from './types.js';
+export declare const VIEW_ORDER: readonly ViewName[];
+/**
+ * `fit` = { center, radius, dist? } overrides the target and framing (perspective views only use `dist`). Use it when the
+ * mesh moves (e.g. rotates) so the camera keeps looking at the same spot.
+ */
+export declare const makeCamera: (view: ViewName | ViewSpec, mesh: Mesh, size: number, fit?: Fit) => Camera;
+/**
+ * Turntable rotation as a camera: the view you get from rotate(mesh, { yaw, pitch })
+ * with a fixed camera, but the mesh stays where it is. Picks and marks are then
+ * in object space.
+ */
+export declare const orbit: ({ yaw, pitch, ortho, name }?: {
+    yaw?: number;
+    pitch?: number;
+    ortho?: boolean;
+    name?: string;
+}) => ViewSpec;
+/** Ray through panel pixel (x, y), the inverse of project(): { origin, dir } in world space, dir is a unit vector. */
+export declare const ray: (cam: Camera, x: number, y: number) => {
+    origin: Vec3;
+    dir: Vec3;
+};
+/** World point -> { x, y } in panel pixels (y down) and depth along the view direction. */
+export declare const project: (cam: Camera, p: Vec3) => {
+    x: number;
+    y: number;
+    depth: number;
+};

package/dist/camera.js

@@ -0,0 +1,68 @@
+// Four named views, all looking at the mesh bounding-box center.
+// front / side / top are orthographic (same scale), persp is a perspective view.
+// A view can also be a custom spec: { dir, up, ortho, name? } where `dir` is the
+// direction from the target towards the eye.
+import { add, cross, dot, norm, scale, plus, minus, times } from './vec.js';
+import { bounds } from './mesh.js';
+export const VIEW_ORDER = ['front', 'side', 'top', 'persp'];
+const FOV = (35 * Math.PI) / 180;
+const VIEWS = {
+    front: { dir: [0, 0, 1], up: [0, 1, 0], ortho: true }, // eye on +z
+    side: { dir: [1, 0, 0], up: [0, 1, 0], ortho: true }, // eye on +x
+    top: { dir: [0, 1, 0], up: [0, 0, -1], ortho: true }, // eye on +y, -z is screen-up
+    persp: { dir: norm([1, 0.8, 1.2]), up: [0, 1, 0], ortho: false },
+};
+/**
+ * `fit` = { center, radius, dist? } overrides the target and framing (perspective views only use `dist`). Use it when the
+ * mesh moves (e.g. rotates) so the camera keeps looking at the same spot.
+ */
+export const makeCamera = (view, mesh, size, fit) => {
+    const spec = typeof view === 'string' ? VIEWS[view] : view;
+    if (!spec)
+        throw new Error(`unknown view: ${view}`);
+    const name = typeof view === 'string' ? view : (view.name ?? 'custom');
+    const ortho = Boolean(spec.ortho);
+    const { center, radius } = fit ?? bounds(mesh);
+    const r0 = radius || 1;
+    const dist = ortho ? r0 * 4 : (fit?.dist ?? (r0 * 1.25) / Math.sin(FOV / 2)); // fit.dist: eye distance override (a first-person eye sits almost on the center)
+    const eye = plus(center)(times(dist)(norm(spec.dir)));
+    const f = norm(minus(eye)(center)); // forward
+    const r = norm(cross(f, spec.up)); // right
+    const u = cross(r, f); // up
+    const k = ortho ? ((size / 2) * 0.8) / r0 : size / 2 / Math.tan(FOV / 2);
+    return { name, eye, f, r, u, ortho, k, size };
+};
+/**
+ * Turntable rotation as a camera: the view you get from rotate(mesh, { yaw, pitch })
+ * with a fixed camera, but the mesh stays where it is. Picks and marks are then
+ * in object space.
+ */
+export const orbit = ({ yaw = 0, pitch = 0, ortho = false, name = 'orbit' } = {}) => {
+    const cy = Math.cos(yaw);
+    const sy = Math.sin(yaw);
+    const cp = Math.cos(pitch);
+    const sp = Math.sin(pitch);
+    return { name, ortho, dir: [-sy * cp, sp, cy * cp], up: [sy * sp, cp, -cy * sp] };
+};
+/** Ray through panel pixel (x, y), the inverse of project(): { origin, dir } in world space, dir is a unit vector. */
+export const ray = (cam, x, y) => {
+    const nx = (x - cam.size / 2) / cam.k;
+    const ny = -(y - cam.size / 2) / cam.k;
+    const lateral = plus(scale(cam.u, ny))(scale(cam.r, nx));
+    return cam.ortho
+        ? { origin: add(cam.eye, lateral), dir: cam.f }
+        : { origin: cam.eye, dir: norm(plus(lateral)(cam.f)) };
+};
+/** World point -> { x, y } in panel pixels (y down) and depth along the view direction. */
+export const project = (cam, p) => {
+    const d = minus(cam.eye)(p);
+    const cx = dot(d, cam.r);
+    const cy = dot(d, cam.u);
+    const depth = dot(d, cam.f);
+    const w = cam.ortho ? 1 : depth;
+    return {
+        x: cam.size / 2 + (cx / w) * cam.k,
+        y: cam.size / 2 - (cy / w) * cam.k,
+        depth,
+    };
+};

package/dist/check.d.ts

@@ -0,0 +1,24 @@
+import type { Mesh } from './types.js';
+export interface Validation {
+    vertices: number;
+    faces: number;
+    /** Every edge is shared by two faces, wound consistently. */
+    closed: boolean;
+    openEdges: number;
+    /** Signed volume; null unless closed. */
+    volume: number | null;
+    /** Closed, but the faces point inward. */
+    inside_out: boolean;
+    degenerateFaces: number[];
+    nonPlanarFaces: number[];
+    nonConvexFaces: number[];
+    ok: boolean;
+    /** Plain-text findings. */
+    notes: string[];
+}
+/**
+ * { vertices, faces, closed, openEdges, volume, inside_out, degenerateFaces,
+ *   nonPlanarFaces, nonConvexFaces, ok, notes }
+ * `volume` and `inside_out` only mean something for a closed mesh.
+ */
+export declare const validate: (mesh: Mesh) => Validation;

package/dist/check.js

@@ -0,0 +1,83 @@
+// Model checks an AI can read as text: is the mesh closed, are the faces CCW from
+// outside, planar and convex (picking and the painter assume that).
+import { sub, dot, cross, len, norm } from './vec.js';
+import { faceNormal, bounds } from './mesh.js';
+/**
+ * { vertices, faces, closed, openEdges, volume, inside_out, degenerateFaces,
+ *   nonPlanarFaces, nonConvexFaces, ok, notes }
+ * `volume` and `inside_out` only mean something for a closed mesh.
+ */
+export const validate = (mesh) => {
+    const { positions, faces } = mesh;
+    const size = bounds(mesh).radius || 1;
+    const degenerate = [];
+    const nonPlanar = [];
+    const nonConvex = [];
+    const directed = new Map();
+    let volume = 0;
+    faces.forEach((face, i) => {
+        const pts = face.v.map((k) => positions[k]);
+        const m = pts.length;
+        const n = faceNormal(pts);
+        const area2 = len(n);
+        if (area2 < 1e-12 * size * size) {
+            degenerate.push(i);
+            return;
+        }
+        const unit = norm(n);
+        if (Math.max(...pts.map((p) => Math.abs(dot(sub(p, pts[0]), unit)))) > 1e-6 * size)
+            nonPlanar.push(i);
+        for (let j = 0; j < m; j++) {
+            const a = pts[j];
+            const b = pts[(j + 1) % m];
+            const c = pts[(j + 2) % m];
+            if (dot(cross(sub(b, a), sub(c, b)), unit) < -1e-9 * size * size) {
+                nonConvex.push(i);
+                break;
+            }
+        }
+        for (let j = 0; j < m; j++) {
+            const key = `${face.v[j]},${face.v[(j + 1) % m]}`;
+            directed.set(key, (directed.get(key) ?? 0) + 1);
+        }
+        for (let j = 1; j < m - 1; j++)
+            volume += dot(pts[0], cross(pts[j], pts[j + 1])) / 6;
+    });
+    let open = 0;
+    let repeated = 0;
+    for (const [key, count] of directed) {
+        const [a, b] = key.split(',');
+        if (count > 1)
+            repeated += 1;
+        if (!directed.has(`${b},${a}`))
+            open += 1;
+    }
+    const closed = faces.length > 0 && open === 0 && repeated === 0;
+    const insideOut = closed && volume < 0;
+    const notes = [];
+    if (degenerate.length)
+        notes.push(`degenerate faces (no area): ${degenerate.join(', ')}`);
+    if (nonPlanar.length)
+        notes.push(`non-planar faces: ${nonPlanar.join(', ')}`);
+    if (nonConvex.length)
+        notes.push(`non-convex faces (picking and painting assume convex): ${nonConvex.join(', ')}`);
+    if (repeated)
+        notes.push(`${repeated} edge(s) are used twice in the same direction: faces are wound inconsistently`);
+    if (open)
+        notes.push(`${open} open edge(s): the mesh is not closed (fine for a surface, e.g. a missing bottom)`);
+    if (insideOut)
+        notes.push('the faces point inward: reverse the vertex order of every face');
+    return {
+        vertices: positions.length,
+        faces: faces.length,
+        closed,
+        openEdges: open,
+        volume: closed ? Math.round(volume * 1e9) / 1e9 : null,
+        inside_out: insideOut,
+        degenerateFaces: degenerate,
+        nonPlanarFaces: nonPlanar,
+        nonConvexFaces: nonConvex,
+        ok: !degenerate.length && !nonPlanar.length && !nonConvex.length && !repeated && !insideOut,
+        notes,
+    };
+};

package/dist/edit.d.ts

@@ -0,0 +1,23 @@
+import type { Mesh, Vec3 } from './types.js';
+/**
+ * Extrude a face: it is replaced (same index) by a copy moved `distance` along its
+ * normal and scaled by `scale` about its center, and one quad per edge joins the two.
+ *   distance > 0, scale 1      a prism out of the face
+ *   distance > 0, scale < 1    a taper (roof, spire, frustum)
+ *   distance 0,   scale < 1    an inset (a panel, a window frame)
+ *   distance < 0               a dent into the solid (a niche, a door recess)
+ * The new quads are appended after the existing faces; `color` recolors the cap and
+ * the quads, otherwise they keep the face color.
+ * Returns { mesh, cap, sides } with the index of the cap face and the new quad indices.
+ */
+export declare const extrudeFace: (mesh: Mesh, index: number, { distance, scale, color }?: {
+    distance?: number;
+    scale?: number;
+    color?: string;
+}) => {
+    mesh: Mesh;
+    cap: number;
+    sides: number[];
+};
+/** Move the vertices at `indices` by `delta` [dx, dy, dz]. Faces keep their vertices, so faces may stop being planar: check with validate(). */
+export declare const moveVertices: (mesh: Mesh, indices: number[], delta: Vec3) => Mesh;

package/dist/edit.js

@@ -0,0 +1,48 @@
+// Shaping an existing mesh: the topology edits a modeller does by hand.
+// Both functions return a NEW mesh; faces stay CCW from outside and closed meshes stay closed.
+import { add, sub, scale as mul, norm } from './vec.js';
+import { faceNormal, faceCenter } from './mesh.js';
+/**
+ * Extrude a face: it is replaced (same index) by a copy moved `distance` along its
+ * normal and scaled by `scale` about its center, and one quad per edge joins the two.
+ *   distance > 0, scale 1      a prism out of the face
+ *   distance > 0, scale < 1    a taper (roof, spire, frustum)
+ *   distance 0,   scale < 1    an inset (a panel, a window frame)
+ *   distance < 0               a dent into the solid (a niche, a door recess)
+ * The new quads are appended after the existing faces; `color` recolors the cap and
+ * the quads, otherwise they keep the face color.
+ * Returns { mesh, cap, sides } with the index of the cap face and the new quad indices.
+ */
+export const extrudeFace = (mesh, index, { distance = 0, scale = 1, color } = {}) => {
+    const face = mesh.faces[index];
+    if (!face)
+        throw new Error(`no face ${index}: this mesh has ${mesh.faces.length} faces`);
+    if (!(scale > 0))
+        throw new Error('scale must be positive');
+    if (distance === 0 && scale === 1)
+        throw new Error('nothing to do: give a distance or a scale other than 1');
+    const pts = face.v.map((k) => mesh.positions[k]);
+    const n = norm(faceNormal(pts));
+    const c = faceCenter(pts);
+    const moved = pts.map((p) => add(add(c, mul(sub(p, c), scale)), mul(n, distance)));
+    const base = mesh.positions.length;
+    const m = pts.length;
+    const tint = color ?? face.color;
+    const faces = mesh.faces.map((f, i) => (i === index ? { ...f, v: moved.map((_, j) => base + j), color: tint } : f));
+    const sides = [];
+    for (let i = 0; i < m; i++) {
+        sides.push(faces.length);
+        faces.push({ v: [face.v[i], face.v[(i + 1) % m], base + ((i + 1) % m), base + i], color: tint });
+    }
+    return { mesh: { positions: [...mesh.positions, ...moved], faces }, cap: index, sides };
+};
+/** Move the vertices at `indices` by `delta` [dx, dy, dz]. Faces keep their vertices, so faces may stop being planar: check with validate(). */
+export const moveVertices = (mesh, indices, delta) => {
+    const set = new Set();
+    for (const i of indices) {
+        if (!Number.isInteger(i) || i < 0 || i >= mesh.positions.length)
+            throw new Error(`vertex ${i} does not exist: this mesh has ${mesh.positions.length} vertices`);
+        set.add(i);
+    }
+    return { ...mesh, positions: mesh.positions.map((p, i) => (set.has(i) ? add(p, delta) : p)) };
+};

package/dist/gpu.d.ts

@@ -0,0 +1,74 @@
+import type { Axes, Camera, Fit, Mesh, Vec3, ViewName, ViewSpec } from './types.js';
+type Handle = any;
+export interface GpuLight {
+    /** Direction towards the light, world space. */
+    direction?: Vec3;
+    /** Hemisphere ambient colors (rgb 0..1): up and down. */
+    sky?: Vec3;
+    ground?: Vec3;
+}
+export interface GpuMaterial {
+    ambient?: number;
+    diffuse?: number;
+    specular?: number;
+    shininess?: number;
+}
+export interface GpuRenderOptions {
+    /** CSS pixels, the canvas becomes size x size (times dpr in device pixels). */
+    size?: number;
+    fit?: Fit;
+    /** Clear color, rgb 0..1. */
+    background?: Vec3;
+    light?: GpuLight;
+    material?: GpuMaterial;
+    dpr?: number;
+    /** Many copies of one prototype mesh (modelled around the origin), drawn after `mesh`. */
+    instances?: {
+        mesh: Mesh;
+        data: Float32Array;
+    };
+}
+/** One copy of a prototype: its position, orthonormal frame and color. */
+export interface Instance {
+    at: Vec3;
+    axes: Axes;
+    color?: string;
+}
+export interface Pixels {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+}
+export interface Gpu {
+    render(mesh: Mesh, view: ViewName | ViewSpec, options?: GpuRenderOptions): void;
+    /** Same frame, drawn offscreen and read back as RGBA (tests, thumbnails). */
+    pixels(mesh: Mesh, view: ViewName | ViewSpec, options?: GpuRenderOptions): Promise<Pixels>;
+    destroy(): void;
+    device: Handle;
+    adapter: Handle;
+}
+/**
+ * Column-major 4x4 matrix (for WebGPU, z in 0..1) that maps world points exactly
+ * like camera.project(): the same pixels, plus a depth between near and far.
+ */
+export declare const viewProjection: (cam: Camera, near?: number, far?: number) => Float32Array;
+/** Triangle list for the GPU: flat face normals and face colors. Float32Array, 9 floats per vertex. */
+export declare const buildVertices: (mesh: Mesh) => Float32Array;
+/**
+ * Per-instance data for drawInstances: one entry { at, axes: [ex, ey, ez], color } per copy of a
+ * prototype mesh (modelled around the origin). Float32Array, 15 floats per instance.
+ */
+export declare const buildInstances: (items: Instance[]) => Float32Array;
+export declare const defaultLight: Required<GpuLight>;
+export declare const defaultMaterial: Required<GpuMaterial>;
+/**
+ * Sets up WebGPU on a canvas. Rejects when WebGPU is not available.
+ * Returns { render(mesh, view, options), destroy() }.
+ * render options: size (CSS px, the canvas is made size x size), fit, instances { mesh, data } (many copies of one
+ * prototype mesh, data from buildInstances; drawn after the mesh), background [r,g,b] 0..1,
+ * light { direction, sky, ground }, material { ambient, diffuse, specular, shininess }, dpr.
+ */
+export declare const createGpu: (canvas: HTMLCanvasElement, { sampleCount }?: {
+    sampleCount?: number;
+}) => Promise<Gpu>;
+export {};