murow 0.0.70 → 0.0.71

package/dist/webgpu/types/core/types.d.ts

@@ -0,0 +1,125 @@
+/**
+ * TypeGPU struct definitions for the 2D and 3D renderers.
+ * These define the GPU-side data layout — used by shaders and bind group layouts.
+ *
+ * All fields are f32 to guarantee contiguous layout matching our flat Float32Arrays.
+ * No vec2f/vec4f here — that would introduce alignment padding.
+ */
+import * as d from 'typegpu/data';
+export declare const DynamicSprite: d.WgslStruct<{
+    prevX: d.F32;
+    prevY: d.F32;
+    currX: d.F32;
+    currY: d.F32;
+    prevRotation: d.F32;
+    currRotation: d.F32;
+}>;
+export declare const StaticSprite: d.WgslStruct<{
+    scaleX: d.F32;
+    scaleY: d.F32;
+    uvMinX: d.F32;
+    uvMinY: d.F32;
+    uvMaxX: d.F32;
+    uvMaxY: d.F32;
+    layer: d.F32;
+    flipX: d.F32;
+    flipY: d.F32;
+    opacity: d.F32;
+    tintR: d.F32;
+    tintG: d.F32;
+    tintB: d.F32;
+    tintA: d.F32;
+}>;
+export declare const SpriteUniforms: d.WgslStruct<{
+    viewProjection: d.Mat3x3f;
+    alpha: d.F32;
+    resolution: d.Vec2f;
+}>;
+export declare const DynamicInstance3D: d.WgslStruct<{
+    prevPosX: d.F32;
+    prevPosY: d.F32;
+    prevPosZ: d.F32;
+    currPosX: d.F32;
+    currPosY: d.F32;
+    currPosZ: d.F32;
+    prevRotX: d.F32;
+    prevRotY: d.F32;
+    prevRotZ: d.F32;
+    prevRotW: d.F32;
+    currRotX: d.F32;
+    currRotY: d.F32;
+    currRotZ: d.F32;
+    currRotW: d.F32;
+}>;
+export declare const StaticInstance3D: d.WgslStruct<{
+    scaleX: d.F32;
+    scaleY: d.F32;
+    scaleZ: d.F32;
+    materialId: d.F32;
+    opacity: d.F32;
+    tintR: d.F32;
+    tintG: d.F32;
+    tintB: d.F32;
+    tintA: d.F32;
+    custom0: d.F32;
+    custom1: d.F32;
+}>;
+export declare const DynamicMesh: d.WgslStruct<{
+    prevPosX: d.F32;
+    prevPosY: d.F32;
+    prevPosZ: d.F32;
+    currPosX: d.F32;
+    currPosY: d.F32;
+    currPosZ: d.F32;
+    prevRotX: d.F32;
+    prevRotY: d.F32;
+    prevRotZ: d.F32;
+    currRotX: d.F32;
+    currRotY: d.F32;
+    currRotZ: d.F32;
+}>;
+export declare const DYNAMIC_MESH_FLOATS = 12;
+export declare const StaticMesh: d.WgslStruct<{
+    scaleX: d.F32;
+    scaleY: d.F32;
+    scaleZ: d.F32;
+    colorR: d.F32;
+    colorG: d.F32;
+    colorB: d.F32;
+}>;
+export declare const STATIC_MESH_FLOATS = 6;
+export declare const SkinnedStaticMesh: d.WgslStruct<{
+    scaleX: d.F32;
+    scaleY: d.F32;
+    scaleZ: d.F32;
+    colorR: d.F32;
+    colorG: d.F32;
+    colorB: d.F32;
+    boneOffset: d.U32;
+}>;
+export declare const SKINNED_STATIC_MESH_FLOATS = 7;
+export declare const MeshUniforms: d.WgslStruct<{
+    viewProjection: d.Mat4x4f;
+    alpha: d.F32;
+    lightDirX: d.F32;
+    lightDirY: d.F32;
+    lightDirZ: d.F32;
+}>;
+/** Per-instance animation state, uploaded from CPU each frame. */
+export declare const InstanceAnimStateGPU: d.WgslStruct<{
+    clipId: d.I32;
+    time: d.F32;
+    skinIndex: d.U32;
+    boneOffset: d.U32;
+    prevClipId: d.I32;
+    prevTime: d.F32;
+    blendWeight: d.F32;
+    _pad: d.F32;
+}>;
+/** Uniforms for the animation compute shader. */
+export declare const AnimComputeUniforms: d.WgslStruct<{
+    instanceCount: d.U32;
+    clipTableOffset: d.U32;
+    channelTableOffset: d.U32;
+    jointLookupOffset: d.U32;
+}>;

package/dist/webgpu/types/core/types.test.d.ts

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

package/dist/webgpu/types/geometry/built-in.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Built-in geometry primitives.
+ * Each returns a typed array of vertex data and optional indices.
+ */
+export type BuiltInGeometry = 'quad' | 'triangle' | 'line' | 'point' | 'circle' | 'cube' | 'sphere' | 'cylinder' | 'cone';
+export interface GeometryData {
+    /** Interleaved vertex data: [posX, posY, (posZ,) u, v, ...] */
+    vertices: Float32Array;
+    /** Optional index buffer */
+    indices?: Uint16Array | Uint32Array;
+    /** Number of vertices */
+    vertexCount: number;
+    /** Floats per vertex (stride) */
+    floatsPerVertex: number;
+    /** Whether this is a 3D geometry */
+    is3D: boolean;
+}
+/**
+ * 2D quad: 6 vertices (two triangles), each with position (x,y) + uv (u,v).
+ * Position range: [-1, 1], UV range: [0, 1].
+ */
+export declare function createQuad(): GeometryData;
+/**
+ * 2D triangle: 3 vertices, each with position (x,y) + uv (u,v).
+ */
+export declare function createTriangle(): GeometryData;
+/**
+ * 2D line: 2 vertices, position only.
+ */
+export declare function createLine(): GeometryData;
+/**
+ * 2D point: single vertex at origin.
+ */
+export declare function createPoint(): GeometryData;
+/**
+ * 2D circle: tessellated triangle fan, configurable segments.
+ */
+export declare function createCircle(segments?: number): GeometryData;
+/**
+ * 3D cube: 36 vertices with position (x,y,z) + normal (nx,ny,nz) + uv (u,v).
+ */
+export declare function createCube(): GeometryData;
+/**
+ * 3D sphere: tessellated with position + normal + uv.
+ */
+export declare function createSphere(latSegments?: number, lonSegments?: number): GeometryData;
+/**
+ * 3D cylinder: tessellated with position + normal + uv.
+ */
+export declare function createCylinder(segments?: number): GeometryData;
+/**
+ * 3D cone: tessellated with position + normal + uv.
+ */
+export declare function createCone(segments?: number): GeometryData;
+/**
+ * Resolve a built-in geometry name to actual data.
+ */
+export declare function resolveBuiltInGeometry(name: BuiltInGeometry): GeometryData;

package/dist/webgpu/types/geometry/built-in.test.d.ts

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

package/dist/webgpu/types/geometry/geometry-builder.d.ts

@@ -0,0 +1,281 @@
+import type { TgpuRoot, TgpuBuffer, TgpuRenderPipeline, TgpuBindGroup, TgpuBindGroupLayout, TgpuVertexFn, TgpuFragmentFn } from 'typegpu';
+import type { AnyWgslData } from 'typegpu/data';
+import { d } from '../shaders/typegpu';
+import type { BuiltInGeometry, GeometryData } from './built-in';
+import type { ComputeKernel } from '../compute/compute-builder';
+/** Map a TypeGPU data type to its JS value representation. */
+type DataToValue<T> = T extends typeof d.f32 ? number : T extends typeof d.vec2f ? [number, number] | number[] : T extends typeof d.vec3f ? [number, number, number] | number[] : T extends typeof d.vec4f ? [number, number, number, number] | number[] : number | number[];
+/** Partial record mapping field names to their JS values. */
+type FieldValues<T extends Record<string, AnyWgslData>> = {
+    [K in keyof T]?: DataToValue<T[K]>;
+};
+/** All instance field names (dynamic + static). */
+type AllFields<D extends Record<string, AnyWgslData>, S extends Record<string, AnyWgslData>> = keyof D | keyof S;
+export interface CustomGeometryLayout {
+    layout?: Record<string, {
+        type: string;
+        size: number;
+    }>;
+    vertices?: Array<Record<string, number | number[]>>;
+    indices?: number[];
+}
+export interface GeometryOptions {
+    maxInstances: number;
+    geometry: BuiltInGeometry | CustomGeometryLayout;
+}
+/** Typed instance layout config with inferred field types. */
+export interface InstanceLayoutConfig<D extends Record<string, AnyWgslData> = Record<string, AnyWgslData>, S extends Record<string, AnyWgslData> = Record<string, AnyWgslData>> {
+    dynamic: D;
+    static: S;
+}
+export interface GeometryDataLayout<D extends Record<string, AnyWgslData> = Record<string, AnyWgslData>, S extends Record<string, AnyWgslData> = Record<string, AnyWgslData>, U extends Record<string, AnyWgslData> = Record<string, AnyWgslData>> {
+    dataLayout: TgpuBindGroupLayout;
+    instanceLayout: InstanceLayoutConfig<D, S>;
+    uniformDefs: U;
+}
+export declare function getFieldFloats(desc: AnyWgslData): number;
+export declare function createGeometryDataLayout<D extends Record<string, AnyWgslData>, S extends Record<string, AnyWgslData>, U extends Record<string, AnyWgslData>>(instanceLayout: InstanceLayoutConfig<D, S>, uniformDefs: U, maxInstances: number): GeometryDataLayout<D, S, U>;
+export declare class CustomGeometry<TDynamic extends Record<string, AnyWgslData> = Record<string, AnyWgslData>, TStatic extends Record<string, AnyWgslData> = Record<string, AnyWgslData>, TUniforms extends Record<string, AnyWgslData> = Record<string, AnyWgslData>> {
+    readonly name: string;
+    readonly maxInstances: number;
+    readonly geometryData: GeometryData;
+    private root;
+    private freeList;
+    private layoutConfig;
+    private dynamicFieldNames;
+    private staticFieldNames;
+    private dynamicFloatsPerInstance;
+    private staticFloatsPerInstance;
+    private dynamicData;
+    private staticData;
+    private uniformValues;
+    private _dynamicDirty;
+    private _staticDirty;
+    private _uniformDirty;
+    private _isComputeSourced;
+    private _drawCount;
+    private activeSlots;
+    private activeCount;
+    private slotToActive;
+    private _ctx;
+    private dynamicBuffer;
+    private staticBuffer;
+    private uniformBuffer;
+    private pipeline;
+    private dataBindGroup;
+    private canvas;
+    private clearColor;
+    /** @internal — use GeometryBuilder to create instances. */
+    constructor(name: string, root: TgpuRoot, maxInstances: number, geometryData: GeometryData, layoutConfig: InstanceLayoutConfig<TDynamic, TStatic>, uniformValues: Record<string, unknown>, dynamicBuffer: TgpuBuffer<AnyWgslData>, staticBuffer: TgpuBuffer<AnyWgslData>, uniformBuffer: TgpuBuffer<AnyWgslData>, pipeline: TgpuRenderPipeline, dataBindGroup: TgpuBindGroup, canvas: HTMLCanvasElement, clearColor: [number, number, number, number], isComputeSourced?: boolean);
+    /**
+     * Set the number of instances to draw. Only needed for compute-sourced geometries
+     * where the instance count may change dynamically.
+     */
+    setDrawCount(count: number): void;
+    addInstance(data: FieldValues<TDynamic> & FieldValues<TStatic>): number;
+    removeInstance(slot: number): void;
+    setInstanceData(slot: number, data: FieldValues<TDynamic> & FieldValues<TStatic>): void;
+    getInstance(slot: number): InstanceAccessor<TDynamic, TStatic>;
+    updateUniforms(values: Partial<FieldValues<TUniforms>>): void;
+    getActiveCount(): number;
+    updateAll(callback: (ctx: InstanceContext<TDynamic, TStatic>, slot: number) => void): void;
+    render(): void;
+    destroy(): void;
+}
+export declare class InstanceContext<TDynamic extends Record<string, AnyWgslData> = Record<string, AnyWgslData>, TStatic extends Record<string, AnyWgslData> = Record<string, AnyWgslData>> {
+    private dynamicData;
+    private staticData;
+    private dynamicStride;
+    private staticStride;
+    private dynamicFieldNames;
+    private staticFieldNames;
+    private layout;
+    private dynBase;
+    private statBase;
+    /** @internal */
+    _bind(dynamicData: Float32Array, staticData: Float32Array, dynamicStride: number, staticStride: number, dynamicFieldNames: string[], staticFieldNames: string[], layout: InstanceLayoutConfig<TDynamic, TStatic>): void;
+    /** @internal */
+    _setSlot(slot: number): void;
+    get(field: AllFields<TDynamic, TStatic> & string): number | number[];
+    set(field: AllFields<TDynamic, TStatic> & string, value: number | number[]): void;
+    private fieldOffset;
+}
+export declare class InstanceAccessor<TDynamic extends Record<string, AnyWgslData> = Record<string, AnyWgslData>, TStatic extends Record<string, AnyWgslData> = Record<string, AnyWgslData>> {
+    private dynamicData;
+    private staticData;
+    private dynBase;
+    private statBase;
+    private dynamicFieldNames;
+    private staticFieldNames;
+    private layout;
+    private _onDynDirty;
+    private _onStatDirty;
+    constructor(dynamicData: Float32Array, staticData: Float32Array, slot: number, dynamicStride: number, staticStride: number, dynamicFieldNames: string[], staticFieldNames: string[], layout: InstanceLayoutConfig<TDynamic, TStatic>, onDynDirty: () => void, onStatDirty: () => void);
+    get(field: AllFields<TDynamic, TStatic> & string): number | number[];
+    set(field: AllFields<TDynamic, TStatic> & string, value: number | number[]): void;
+    private fieldOffset;
+}
+type ShaderResult = {
+    vertex: TgpuVertexFn<Record<string, AnyWgslData>, Record<string, AnyWgslData>>;
+    fragment: TgpuFragmentFn<Record<string, AnyWgslData>, AnyWgslData>;
+};
+/** Vertex input builtins available in shader functions. */
+export interface VertexInput {
+    /** The vertex index within the current draw call (0-5 for a quad). */
+    vertexIndex: number;
+    /** The instance index within the current draw call. */
+    instanceIndex: number;
+}
+/**
+ * Declarative shader config — no `tgpu.vertexFn`, no `'use gpu'`.
+ * The builder handles all TypeGPU wiring internally.
+ */
+export interface DeclarativeShaders<TDynamic extends Record<string, AnyWgslData> = Record<string, AnyWgslData>, TStatic extends Record<string, AnyWgslData> = Record<string, AnyWgslData>, TUniforms extends Record<string, AnyWgslData> = Record<string, AnyWgslData>> {
+    vertex: {
+        /** Varyings output from vertex to fragment (position is always included). */
+        out: Record<string, AnyWgslData>;
+        /** Vertex shader body. Receives typed context and vertex input. */
+        fn: (ctx: ShaderContext<TDynamic, TStatic, TUniforms>, input: VertexInput) => Record<string, unknown>;
+    };
+    fragment: {
+        /** Fragment shader body. Receives varyings from vertex shader. */
+        fn: (input: Record<string, unknown>) => unknown;
+    };
+}
+type ResolveWgsl<T> = T extends (...args: any) => infer R ? R : T;
+type ResolveRecord<T extends Record<string, AnyWgslData>> = {
+    readonly [K in keyof T]: ResolveWgsl<T[K]>;
+};
+/**
+ * Context passed to the shader factory callback.
+ * Provides `dynamic`, `statics`, and `uniforms` accessors with typed field names.
+ *
+ * **These accessors are lazy** — they only resolve when accessed inside a `'use gpu'` body.
+ * Capture them in the closure and use inside shader functions:
+ *
+ * ```ts
+ * .shaders(({ dynamic, statics, uniforms }) => ({
+ *     vertex: tgpu.vertexFn({...})(function(input) {
+ *         'use gpu';
+ *         const pos = dynamic[input.instanceIndex].position;
+ *         const time = uniforms.time;
+ *     }),
+ * }))
+ * ```
+ */
+export interface ShaderContext<TDynamic extends Record<string, AnyWgslData> = Record<string, AnyWgslData>, TStatic extends Record<string, AnyWgslData> = Record<string, AnyWgslData>, TUniforms extends Record<string, AnyWgslData> = Record<string, AnyWgslData>> {
+    /** Per-instance dynamic data (updated every frame). Access: `dynamic[instanceIndex].fieldName` */
+    readonly dynamic: Readonly<Record<number, Readonly<ResolveRecord<TDynamic>>>>;
+    /** Per-instance static data (set once). Access: `statics[instanceIndex].fieldName` */
+    readonly statics: Readonly<Record<number, Readonly<ResolveRecord<TStatic>>>>;
+    /** Shared uniforms. Access: `uniforms.fieldName` */
+    readonly uniforms: Readonly<ResolveRecord<TUniforms>>;
+    /** Raw TypeGPU bind group layout — escape hatch for advanced usage. */
+    readonly layout: TgpuBindGroupLayout;
+}
+type ShaderFactory<TDynamic extends Record<string, AnyWgslData> = Record<string, AnyWgslData>, TStatic extends Record<string, AnyWgslData> = Record<string, AnyWgslData>, TUniforms extends Record<string, AnyWgslData> = Record<string, AnyWgslData>> = (ctx: ShaderContext<TDynamic, TStatic, TUniforms>) => ShaderResult;
+export declare class GeometryBuilder<TDynamic extends Record<string, AnyWgslData> = Record<string, never>, TStatic extends Record<string, AnyWgslData> = Record<string, never>, TUniforms extends Record<string, AnyWgslData> = Record<string, never>> {
+    private _name;
+    private _options;
+    private _root;
+    private _format;
+    private _layoutConfig;
+    private _uniformDefs;
+    private _vertexFn;
+    private _fragmentFn;
+    private _shaderFactory;
+    private _vertexVaryings;
+    private _vertexFactory;
+    private _fragmentFactory;
+    private _declarativeShaders;
+    private _computeSource;
+    private _dataLayout;
+    private _canvas;
+    private _clearColor;
+    constructor(name: string, options: GeometryOptions, root: TgpuRoot, format: GPUTextureFormat, canvas: HTMLCanvasElement, clearColor: [number, number, number, number]);
+    instanceLayout<D extends Record<string, AnyWgslData>, S extends Record<string, AnyWgslData>>(layout: InstanceLayoutConfig<D, S> | GeometryDataLayout<D, S, TUniforms>): GeometryBuilder<D, S, TUniforms>;
+    uniforms<U extends Record<string, AnyWgslData>>(defs: U): GeometryBuilder<TDynamic, TStatic, U>;
+    /**
+     * Bind a compute kernel's buffer as this geometry's dynamic instance data.
+     * Zero-copy: the render shader reads directly from the compute buffer.
+     *
+     * ```ts
+     * const compute = renderer.createCompute('physics', { workgroupSize: 256 })
+     *     .buffers({ particles: { storage: d.arrayOf(ParticleStruct, MAX), readwrite: true } })
+     *     .shader(...)
+     *     .build();
+     *
+     * const render = renderer.createGeometry('vis', { maxInstances: MAX, geometry: 'quad' })
+     *     .fromCompute(compute, 'particles')
+     *     .uniforms({ resolution: d.vec2f })
+     *     .shaders({ ... })
+     *     .build();
+     * ```
+     */
+    fromCompute(kernel: ComputeKernel<Record<string, unknown>>, bufferName: string): this;
+    /**
+     * Provide shaders as a callback that receives the bind group layout.
+     *
+     * ```ts
+     * .shaders((layout) => ({
+     *     vertex: tgpu.vertexFn({...})(function(input) {
+     *         const pos = layout.$.dynamicInstances[input.instanceIndex].position;
+     *     }),
+     *     fragment: tgpu.fragmentFn({...})(function(input) { ... }),
+     * }))
+     * ```
+     *
+     * Or provide pre-built shaders directly:
+     * ```ts
+     * .shaders(vertexFn, fragmentFn)
+     * ```
+     */
+    /**
+     * Provide shaders via a factory callback that receives a typed context.
+     *
+     * ```ts
+     * .shaders(({ dynamic, statics, uniforms }) => ({
+     *     vertex: tgpu.vertexFn({...})(function(input) { ... }),
+     *     fragment: tgpu.fragmentFn({...})(function(input) { ... }),
+     * }))
+     * ```
+     *
+     * Or provide pre-built shaders directly:
+     * ```ts
+     * .shaders(vertexFn, fragmentFn)
+     * ```
+     */
+    shaders(vertexOrFactoryOrConfig: TgpuVertexFn<Record<string, AnyWgslData>, Record<string, AnyWgslData>> | ShaderFactory<TDynamic, TStatic, TUniforms> | DeclarativeShaders<TDynamic, TStatic, TUniforms>, fragment?: TgpuFragmentFn<Record<string, AnyWgslData>, AnyWgslData>): this;
+    /**
+     * Set the vertex shader with typed context.
+     * The builder handles `tgpu.vertexFn` wrapping and builtin inputs.
+     *
+     * ```ts
+     * .vertex(
+     *     { brightness: d.f32, localUV: d.vec2f },  // varyings
+     *     (ctx) => function(input) {
+     *         'use gpu';
+     *         const pos = ctx.dynamic[input.instanceIndex].position;
+     *         return { pos: d.vec4f(...), brightness, localUV };
+     *     }
+     * )
+     * ```
+     */
+    vertexShader<V extends Record<string, AnyWgslData>>(varyings: V, factory: (ctx: ShaderContext<TDynamic, TStatic, TUniforms>) => (input: {
+        vertexIndex: number;
+        instanceIndex: number;
+    }) => Record<string, AnyWgslData>): this;
+    /**
+     * Set the fragment shader.
+     *
+     * ```ts
+     * .fragmentShader(function(input) {
+     *     'use gpu';
+     *     return d.vec4f(1, 1, 1, 1);
+     * })
+     * ```
+     */
+    fragmentShader(fn: (input: Record<string, unknown>) => unknown): this;
+    build(): CustomGeometry<TDynamic, TStatic, TUniforms>;
+}
+export {};

package/dist/webgpu/types/geometry/geometry-builder.test.d.ts

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

package/dist/webgpu/types/geometry/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./built-in";
+export * from "./geometry-builder";

package/dist/webgpu/types/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @murow/webgpu — WebGPU rendering backend for murow.
+ *
+ * Re-exports TypeGPU's data module as `d` for user-facing shader authoring.
+ */
+export { d, std } from './shaders/typegpu';
+export { WebGPU2DRenderer } from './2d/renderer';
+export { SpriteAccessor } from './2d/sprite-accessor';
+export { WebGPU3DRenderer } from './3d/renderer';
+export type { ModelData, ModelHandle, GltfModel, InstanceHandle, MeshInstanceHandle, MeshInstanceOptions } from './3d/renderer';
+export { MorphAnimation } from './3d/morph-animation';
+export type { MorphClip, MorphState, MorphClipConfig } from './3d/morph-animation';
+export { SkeletalAnimation } from './3d/skeletal-animation';
+export type { SkeletalClip, SkeletalAnimState, PlayOptions } from './3d/skeletal-animation';
+export type { SkinData, AnimationClipData, AnimationChannel } from './3d/gltf-skin-parser';
+export { Camera2D } from './camera/camera-2d';
+export { Camera3D } from './camera/camera-3d';
+export { GeometryBuilder, CustomGeometry, InstanceAccessor, InstanceContext, getFieldFloats, createGeometryDataLayout } from './geometry/geometry-builder';
+export type { GeometryOptions, InstanceLayoutConfig, CustomGeometryLayout, GeometryDataLayout, ShaderContext } from './geometry/geometry-builder';
+export { resolveBuiltInGeometry } from './geometry/built-in';
+export type { BuiltInGeometry, GeometryData } from './geometry/built-in';
+export { Spritesheet, computeGridUVs, computeTexturePackerUVs, loadImage, createTextureFromBitmap } from './spritesheet/spritesheet';
+export type { SpritesheetConfig, TexturePackerData } from './spritesheet/spritesheet';
+export { ParticleEmitter } from './particle/emitter';
+export type { ParticleEmitterConfig, Range } from './particle/emitter';
+export { AnimationController } from './2d/animation';
+export type { AnimationClip, AnimationState, AnimationClipConfig } from './2d/animation';
+export { ComputeBuilder, ComputeKernel } from './compute/compute-builder';
+export type { ComputeOptions, ComputeBufferDef, ComputeInput } from './compute/compute-builder';
+export { rotate2d, worldToClip2d, worldToClip3d, remap, scaleRotate2d, inverseLerp } from './shaders/utils';
+export * from './core/constants';
+export { DynamicSprite, StaticSprite, SpriteUniforms, DynamicInstance3D, StaticInstance3D, DynamicMesh, StaticMesh, SkinnedStaticMesh, MeshUniforms } from './core/types';

package/dist/webgpu/types/particle/emitter.d.ts

@@ -0,0 +1,36 @@
+import type { SpritesheetHandle } from 'murow/renderer/types';
+import type { WebGPU2DRenderer } from '../2d/renderer';
+export interface Range {
+    min: number;
+    max: number;
+}
+export interface ParticleEmitterConfig {
+    max: number;
+    lifetime: Range;
+    speed: Range;
+    size: Range;
+    gravity?: [number, number];
+    color: [number, number, number, number];
+    direction: Range;
+    fadeOut?: boolean;
+    sheet?: SpritesheetHandle;
+    sprite?: number;
+    seed?: number;
+}
+export declare class ParticleEmitter {
+    private renderer;
+    private config;
+    private sprites;
+    private lifetimes;
+    private maxLifetimes;
+    private velocitiesX;
+    private velocitiesY;
+    private activeCount;
+    private head;
+    private rng;
+    constructor(renderer: WebGPU2DRenderer, config: ParticleEmitterConfig);
+    emit(x: number, y: number, count?: number): void;
+    update(deltaTime: number): void;
+    getActiveCount(): number;
+    clear(): void;
+}

package/dist/webgpu/types/shaders/index.d.ts

@@ -0,0 +1,2 @@
+export * from "../2d/shader";
+export { rotate2d, worldToClip2d, worldToClip3d, remap, scaleRotate2d, inverseLerp } from './utils';

package/dist/webgpu/types/shaders/runtime-transpile.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Attach TypeGPU shader metadata to a function at runtime.
+ *
+ * @param fn The shader function
+ * @param getExternals Lazy function returning external variable bindings.
+ *                     Called during pipeline resolution. The returned record
+ *                     is augmented with auto-detected namespace aliases (see
+ *                     `namespaceAliases`) so bundler-renamed identifiers
+ *                     (e.g. `d10` instead of `d`) still resolve.
+ * @param stripFirstParam If true, removes the first parameter (ctx) and treats
+ *                        its destructured names as externals instead
+ * @param namespaceAliases Map of canonical namespace name → namespace object.
+ *                         When a bundler renames `d` to `d10`, we detect it by
+ *                         matching the member-access pattern in the function
+ *                         source against the members of each candidate namespace,
+ *                         and alias the renamed name to the right object.
+ */
+export declare function attachShaderMetadata(fn: Function, getExternals: () => Record<string, unknown>, stripFirstParam?: boolean, namespaceAliases?: Record<string, object>): void;

package/dist/webgpu/types/shaders/sprite-2d.wgsl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Default 2D sprite shader — WGSL source as a template string.
+ *
+ * Supports:
+ * - Instanced rendering (one draw call per spritesheet batch)
+ * - GPU-side interpolation between previous and current frame
+ * - Per-sprite: position, rotation, scale, UV, tint, opacity, flip
+ * - Camera transform via uniform matrix
+ */
+export declare const SPRITE_2D_WGSL = "\n// --- Uniforms ---\nstruct Uniforms {\n    viewProjection: mat3x3<f32>,\n    alpha: f32,\n    resolution: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: Uniforms;\n\n// --- Instance data (storage buffers) ---\nstruct DynamicInstance {\n    prevX: f32,\n    prevY: f32,\n    currX: f32,\n    currY: f32,\n    prevRotation: f32,\n    currRotation: f32,\n}\n\nstruct StaticInstance {\n    scaleX: f32,\n    scaleY: f32,\n    uvMinX: f32,\n    uvMinY: f32,\n    uvMaxX: f32,\n    uvMaxY: f32,\n    layer: f32,\n    flipX: f32,\n    flipY: f32,\n    opacity: f32,\n    tintR: f32,\n    tintG: f32,\n    tintB: f32,\n    tintA: f32,\n}\n\n@group(0) @binding(1) var<storage, read> dynamicInstances: array<DynamicInstance>;\n@group(0) @binding(2) var<storage, read> staticInstances: array<StaticInstance>;\n\n// --- Texture ---\n@group(1) @binding(0) var spriteTex: texture_2d<f32>;\n@group(1) @binding(1) var spriteSampler: sampler;\n\n// --- Vertex output ---\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) uv: vec2<f32>,\n    @location(1) tint: vec4<f32>,\n    @location(2) opacity: f32,\n}\n\n@vertex\nfn vs_main(\n    @builtin(vertex_index) vertexIndex: u32,\n    @builtin(instance_index) instanceIndex: u32,\n) -> VertexOutput {\n    let dyn = dynamicInstances[instanceIndex];\n    let stat = staticInstances[instanceIndex];\n\n    // Interpolate position\n    let alpha = uniforms.alpha;\n    let x = mix(dyn.prevX, dyn.currX, alpha);\n    let y = mix(dyn.prevY, dyn.currY, alpha);\n\n    // Interpolate rotation\n    let rotation = mix(dyn.prevRotation, dyn.currRotation, alpha);\n\n    // Quad vertices: 6 verts for 2 triangles\n    let isRight = f32((vertexIndex & 1u) ^ ((vertexIndex >> 1u) & 1u));\n    let isTop = f32((vertexIndex + 1u) / 3u);\n    // Adjust for second triangle\n    let localX = select(-0.5, 0.5, isRight > 0.0) * stat.scaleX;\n    let localY = select(-0.5, 0.5, isTop > 0.0) * stat.scaleY;\n\n    // Apply flip\n    let fx = select(1.0, -1.0, stat.flipX > 0.0);\n    let fy = select(1.0, -1.0, stat.flipY > 0.0);\n    let flippedX = localX * fx;\n    let flippedY = localY * fy;\n\n    // Rotate\n    let cosR = cos(rotation);\n    let sinR = sin(rotation);\n    let rotX = flippedX * cosR - flippedY * sinR;\n    let rotY = flippedX * sinR + flippedY * cosR;\n\n    // World position\n    let worldPos = vec3<f32>(x + rotX, y + rotY, 1.0);\n\n    // Apply camera view-projection\n    let clipPos = uniforms.viewProjection * worldPos;\n\n    // UV mapping\n    let u = mix(stat.uvMinX, stat.uvMaxX, isRight);\n    let v = mix(stat.uvMinY, stat.uvMaxY, 1.0 - isTop);\n\n    var out: VertexOutput;\n    out.position = vec4<f32>(clipPos.xy, 0.0, 1.0);\n    out.uv = vec2<f32>(u, v);\n    out.tint = vec4<f32>(stat.tintR, stat.tintG, stat.tintB, stat.tintA);\n    out.opacity = stat.opacity;\n    return out;\n}\n\n@fragment\nfn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {\n    let texColor = textureSample(spriteTex, spriteSampler, in.uv);\n    let tinted = texColor * in.tint;\n    return vec4<f32>(tinted.rgb, tinted.a * in.opacity);\n}\n";

package/dist/webgpu/types/shaders/typegpu.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Bundler-safe wrappers around TypeGPU's `data` and `std` namespace exports.
+ */
+import * as _d from 'typegpu/data';
+import * as _std from 'typegpu/std';
+export declare const d: typeof _d;
+export declare const std: typeof _std;
+export type d = typeof _d;
+export type std = typeof _std;

package/dist/webgpu/types/shaders/utils.d.ts

@@ -0,0 +1,28 @@
+import * as d from 'typegpu/data';
+/**
+ * Rotate a 2D point around the origin by `angle` radians.
+ */
+export declare const rotate2d: import("typegpu").TgpuFn<(point: d.Vec2f, angle: d.F32) => d.Vec2f>;
+/**
+ * Transform a 2D world position to clip space using a 3x3 camera matrix
+ * (stored as mat3x3f). Returns vec4f for vertex output.
+ */
+export declare const worldToClip2d: import("typegpu").TgpuFn<(worldPos: d.Vec2f, cameraMatrix: d.Mat3x3f) => d.Vec4f>;
+/**
+ * Transform a 3D world position to clip space using a 4x4 view-projection matrix.
+ */
+export declare const worldToClip3d: import("typegpu").TgpuFn<(worldPos: d.Vec3f, vpMatrix: d.Mat4x4f) => d.Vec4f>;
+/**
+ * Remap a value from one range to another.
+ * `remap(0.5, 0, 1, 10, 20)` returns `15`.
+ */
+export declare const remap: import("typegpu").TgpuFn<(value: d.F32, inMin: d.F32, inMax: d.F32, outMin: d.F32, outMax: d.F32) => d.F32>;
+/**
+ * Compute a 2D scale+rotation matrix from scale and angle.
+ * Useful for sprite transforms in the vertex shader.
+ */
+export declare const scaleRotate2d: import("typegpu").TgpuFn<(scale: d.Vec2f, angle: d.F32) => d.Mat2x2f>;
+/**
+ * Inverse lerp — given a value in [min, max], returns its t in [0, 1].
+ */
+export declare const inverseLerp: import("typegpu").TgpuFn<(min: d.F32, max: d.F32, value: d.F32) => d.F32>;

package/dist/webgpu/types/shaders/utils.test.d.ts

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

package/dist/webgpu/types/spritesheet/index.d.ts

@@ -0,0 +1 @@
+export * from "./spritesheet";