Add Go CDN and playground server

Build Core and Handles into in-memory CDN modules, add the marketing site and tutorial docs, and provide a SQLite-backed WebGPU playground with TypeScript tooling and profiling. Amp-Thread-ID: https://ampcode.com/threads/T-01a02485-5574-707c-bff4-5668d83bee8a Co-authored-by: Heaust Azure <heaust.azure@gmail.com>
2026-08-21 16:42:02 +00:00
parent 53a53a8f3f
commit 7070799862
27 changed files with 3402 additions and 7 deletions
@@ -0,0 +1,161 @@
+declare module "@yawn/core" {
+  export type RowFormat = "f32" | "u32" | "i32";
+  export interface RowDescriptor {
+    name: string;
+    rows: number;
+    stride: number;
+    format: RowFormat;
+    offset: number;
+    bytes: number;
+  }
+  export class SharedRows {
+    readonly buffer: SharedArrayBuffer;
+    readonly descriptor: RowDescriptor;
+    readonly name: string;
+    readonly rows: number;
+    readonly stride: number;
+    readonly format: RowFormat;
+    readonly view: Float32Array | Uint32Array | Int32Array;
+    row(index: number): Float32Array | Uint32Array | Int32Array;
+    read(index: number): number[];
+    write(index: number, values: ArrayLike<number>): this;
+    share(): { buffer: SharedArrayBuffer; descriptor: RowDescriptor };
+  }
+  export interface ProfileFrame {
+    frame: number;
+    milliseconds: number;
+    readbackMilliseconds: number;
+    adapter: string;
+    canvas: { width: number; height: number };
+    passes: Array<{ name: string; milliseconds: number }>;
+  }
+  export class YawnCore {
+    constructor(canvas: HTMLCanvasElement, options?: { arenaBytes?: number; debug?: boolean });
+    readonly ready: Promise<void>;
+    createRows(options: { name: string; rows: number; stride: number; format: RowFormat }): Promise<SharedRows>;
+    createRowsBatch(rows: Array<{ name: string; rows: number; stride: number; format: RowFormat }>): Promise<SharedRows[]>;
+    deleteRows(name: string): Promise<void>;
+    allocateObject(name: string): Promise<number>;
+    deleteObject(name: string, id: number): Promise<void>;
+    compileGraph(serialized: string): Promise<string>;
+    switchLoadout(id: string): Promise<void>;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    setFps(fps: number): Promise<void>;
+    setProfiler(enabled: boolean): Promise<boolean>;
+    onProfile(listener: (frame: ProfileFrame) => void): () => void;
+    array(name: string): SharedRows;
+    dispose(): void;
+  }
+}
+
+declare module "@yawn/handles" {
+  import { SharedRows, YawnCore } from "@yawn/core";
+
+  export interface SceneOptions { arenaBytes?: number; debug?: boolean; fps?: number; hdr?: boolean }
+  export class Scene {
+    constructor(canvas: HTMLCanvasElement, options?: SceneOptions);
+    readonly core: YawnCore;
+    readonly ready: Promise<this>;
+    readonly hdr: boolean;
+    array(name: string): SharedRows;
+    ensureRows(name: string, rows: number, stride: number, format: "f32" | "u32" | "i32"): Promise<SharedRows>;
+    reserve(additional: { nodes?: number; materials?: number }): Promise<void>;
+    batchWrites<T>(operation: () => T): T;
+    batchGraphUpdates<T>(operation: () => T | Promise<T>): Promise<T>;
+    dispose(): void;
+  }
+
+  export interface Vector3View { x: number; y: number; z: number; set(values: ArrayLike<number>): void }
+  export interface RotorView extends Vector3View { w: number }
+  export interface NodeOptions { position?: ArrayLike<number>; rotor?: ArrayLike<number>; scale?: ArrayLike<number> }
+  export class Node {
+    constructor(scene: Scene, options?: NodeOptions);
+    readonly scene: Scene;
+    readonly ready: Promise<this>;
+    readonly id: number;
+    readonly position: Vector3View;
+    readonly rotor: RotorView;
+    readonly scale: Vector3View;
+    setPosition(value: ArrayLike<number>): this;
+    setRotor(value: ArrayLike<number>): this;
+    setScale(value: ArrayLike<number>): this;
+    translate(x: number, y: number, z: number): this;
+    rotateX(radians: number): this;
+    rotateY(radians: number): this;
+    rotateZ(radians: number): this;
+    dispose(): Promise<void>;
+  }
+
+  export interface PBRMaterialOptions {
+    baseColor?: ArrayLike<number>;
+    metallic?: number;
+    roughness?: number;
+    emissive?: ArrayLike<number>;
+  }
+  export class PBRMaterial {
+    constructor(scene: Scene, options?: PBRMaterialOptions);
+    readonly ready: Promise<this>;
+    readonly id: number;
+    metallic: number;
+    roughness: number;
+    readonly baseColor: { 0: number; 1: number; 2: number; 3: number };
+    dispose(): Promise<void>;
+  }
+
+  export type VertexKind = "positions" | "normals" | "tangents" | "uvs" | "colors" | "indices";
+  export interface MeshOptions extends NodeOptions {
+    geometryId?: number;
+    material?: PBRMaterial;
+    vertexData?: Partial<Record<VertexKind, ArrayLike<number>>>;
+    visible?: boolean;
+  }
+  export class Mesh extends Node {
+    constructor(scene: Scene, options?: MeshOptions);
+    geometryId: number;
+    vertexCount: number;
+    indexCount: number;
+    isVisible: boolean;
+    material: PBRMaterial;
+    clone(options?: Omit<MeshOptions, "geometryId" | "vertexData">): Mesh;
+    setVertexData(kind: VertexKind, data: ArrayLike<number>): Promise<this>;
+    setMaterialForFaces(material: PBRMaterial, faces: number | number[]): Promise<this>;
+  }
+
+  export interface CameraOptions extends NodeOptions { fov?: number; near?: number; far?: number; aspect?: number }
+  export class Camera extends Node {
+    fov: number;
+    near: number;
+    far: number;
+    aspect: number;
+  }
+  export class ArcRotateCamera extends Camera {
+    constructor(scene: Scene, options?: CameraOptions & { target?: Node; alpha?: number; beta?: number; radius?: number; controls?: { element: HTMLElement; pointer?: boolean; controller?: boolean } });
+    alpha: number;
+    beta: number;
+    radius: number;
+  }
+  export class FreeCamera extends Camera {
+    constructor(scene: Scene, options?: CameraOptions & { controls?: { element: HTMLElement; keyboard?: boolean; pointer?: boolean; controller?: boolean; speed?: number } });
+  }
+  export class FollowCamera extends Camera {
+    constructor(scene: Scene, options?: CameraOptions & { target?: Node; distance?: number; height?: number; smoothing?: number });
+  }
+
+  export interface LightOptions extends NodeOptions { color?: ArrayLike<number>; intensity?: number }
+  export class PointLight extends Node { constructor(scene: Scene, options?: LightOptions & { range?: number }); intensity: number; range: number }
+  export class AmbientLight extends Node { constructor(scene: Scene, options?: LightOptions); intensity: number }
+  export class DirectionalLight extends Node { constructor(scene: Scene, options?: LightOptions); intensity: number }
+  export class SpotLight extends Node { constructor(scene: Scene, options?: LightOptions & { range?: number; innerAngle?: number; outerAngle?: number }) }
+  export class RectAreaLight extends Node { constructor(scene: Scene, options?: LightOptions & { width?: number; height?: number }) }
+
+  export class ComputePass { constructor(options: Record<string, unknown>); readonly id: string }
+  export class FXAA { constructor(scene: Scene, options?: Record<string, unknown>); readonly ready: Promise<this>; dispose(): Promise<void> }
+  export class ColorGrading extends FXAA { constructor(scene: Scene, options?: { toneMap?: "aces" | "reinhard" | "linear"; amount?: number }) }
+  export class DynamicExposure extends FXAA { constructor(scene: Scene, options?: { exposure?: number }) }
+  export class SSAO extends FXAA { constructor(scene: Scene, options?: { amount?: number }) }
+  export function importGltf(scene: Scene, url: string | URL): Promise<Mesh[]>;
+}
+
+declare const canvas: HTMLCanvasElement;
+declare function log(...values: unknown[]): void;