murow 0.0.70 → 0.0.72

package/dist/webgpu/types/3d/shader.d.ts

@@ -0,0 +1,136 @@
+import * as d from 'typegpu/data';
+export declare function createMeshLayout(maxInstances: number): import("typegpu").TgpuBindGroupLayout<{
+    uniforms: {
+        uniform: d.WgslStruct<{
+            viewProjection: d.Mat4x4f;
+            alpha: d.F32;
+            lightDirX: d.F32;
+            lightDirY: d.F32;
+            lightDirZ: d.F32;
+        }>;
+    };
+    dynamicInstances: {
+        storage: d.WgslArray<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;
+        }>>;
+    };
+    staticInstances: {
+        storage: d.WgslArray<d.WgslStruct<{
+            scaleX: d.F32;
+            scaleY: d.F32;
+            scaleZ: d.F32;
+            colorR: d.F32;
+            colorG: d.F32;
+            colorB: d.F32;
+        }>>;
+    };
+    slotIndices: {
+        storage: d.WgslArray<d.U32>;
+    };
+}>;
+export type MeshDataLayout = ReturnType<typeof createMeshLayout>;
+export declare function createMeshVertex(meshLayout: MeshDataLayout): import("typegpu").TgpuVertexFn<{
+    position: d.Vec3f;
+    normal: d.Vec3f;
+}, {
+    vNormal: d.Vec3f;
+    vColor: d.Vec3f;
+}>;
+export declare function createMeshFragment(meshLayout: MeshDataLayout): import("typegpu").TgpuFragmentFn<{
+    vNormal: d.Vec3f;
+    vColor: d.Vec3f;
+}, d.Vec4f>;
+export declare function createTextureBindGroupLayout(): import("typegpu").TgpuBindGroupLayout<{
+    modelTexture: import("typegpu").TgpuLayoutTexture<d.WgslTexture2d<d.F32>>;
+    modelSampler: {
+        sampler: "filtering";
+    };
+}>;
+export type TextureBindGroupLayout = ReturnType<typeof createTextureBindGroupLayout>;
+export declare function createTexturedMeshVertex(meshLayout: MeshDataLayout): import("typegpu").TgpuVertexFn<{
+    position: d.Vec3f;
+    normal: d.Vec3f;
+    uv: d.Vec2f;
+}, {
+    vNormal: d.Vec3f;
+    vColor: d.Vec3f;
+    vUV: d.Vec2f;
+}>;
+export declare function createTexturedMeshFragment(meshLayout: MeshDataLayout, texLayout: TextureBindGroupLayout): import("typegpu").TgpuFragmentFn<{
+    vNormal: d.Vec3f;
+    vColor: d.Vec3f;
+    vUV: d.Vec2f;
+}, d.Vec4f>;
+export declare function createSkinnedMeshLayout(maxInstances: number, maxBones: number): import("typegpu").TgpuBindGroupLayout<{
+    uniforms: {
+        uniform: d.WgslStruct<{
+            viewProjection: d.Mat4x4f;
+            alpha: d.F32;
+            lightDirX: d.F32;
+            lightDirY: d.F32;
+            lightDirZ: d.F32;
+        }>;
+    };
+    dynamicInstances: {
+        storage: d.WgslArray<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;
+        }>>;
+    };
+    staticInstances: {
+        storage: d.WgslArray<d.WgslStruct<{
+            scaleX: d.F32;
+            scaleY: d.F32;
+            scaleZ: d.F32;
+            colorR: d.F32;
+            colorG: d.F32;
+            colorB: d.F32;
+            boneOffset: d.U32;
+        }>>;
+    };
+    slotIndices: {
+        storage: d.WgslArray<d.U32>;
+    };
+    boneMatrices: {
+        storage: d.WgslArray<d.Mat4x4f>;
+    };
+}>;
+export type SkinnedMeshDataLayout = ReturnType<typeof createSkinnedMeshLayout>;
+export declare function createSkinnedMeshVertex(layout: SkinnedMeshDataLayout): import("typegpu").TgpuVertexFn<{
+    position: d.Vec3f;
+    normal: d.Vec3f;
+    uv: d.Vec2f;
+    joints: d.Vec4u;
+    weights: d.Vec4f;
+}, {
+    vNormal: d.Vec3f;
+    vColor: d.Vec3f;
+    vUV: d.Vec2f;
+}>;
+/**
+ * Fragment shader for skinned meshes — reuses the textured fragment shader.
+ * For untextured skinned meshes, reuse createMeshFragment.
+ */
+export { createMeshFragment as createSkinnedMeshFragment };
+export { createTexturedMeshFragment as createSkinnedTexturedMeshFragment };

package/dist/webgpu/types/3d/skeletal-animation-compute/index.d.ts

@@ -0,0 +1,2 @@
+export { buildAnimationKernel, uploadPackedToKernel, type AnimationKernelBudgets } from './kernel';
+export { packAnimationData, type PackedBuffers } from './packer';

package/dist/webgpu/types/3d/skeletal-animation-compute/kernel.d.ts

@@ -0,0 +1,25 @@
+import { type ComputeKernel } from '../../compute/compute-builder';
+import type { TgpuRoot } from 'typegpu';
+import { type PackedBuffers } from './packer';
+import type { PackedAnimationData } from 'murow/renderer';
+/**
+ * Capacity headroom for each storage buffer. Over-allocating is harmless —
+ * the kernel only ever reads as far as the uploaded data describes — and
+ * lets resyncs upload via `writeBuffer` instead of rebuilding the kernel.
+ */
+export interface AnimationKernelBudgets {
+    skelI32Capacity: number;
+    animF32Capacity: number;
+    matricesCapacity: number;
+}
+export declare function buildAnimationKernel(root: TgpuRoot, packed: PackedAnimationData, maxInstances: number, maxTotalBones: number, budgets: AnimationKernelBudgets): {
+    kernel: ComputeKernel;
+    packedBuffers: PackedBuffers;
+    budgets: AnimationKernelBudgets;
+};
+/**
+ * Re-upload packed animation data into an already-built kernel. Uses
+ * `device.queue.writeBuffer` directly against the typed arrays — TypeGPU's
+ * per-element write path is dramatically slower for big buffers.
+ */
+export declare function uploadPackedToKernel(root: TgpuRoot, kernel: ComputeKernel, pb: PackedBuffers): void;

package/dist/webgpu/types/3d/skeletal-animation-compute/packer.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Packs animation data into flat typed arrays for GPU consumption.
+ * Separated from the kernel so packing logic can be tested independently.
+ */
+import type { PackedAnimationData } from 'murow/renderer';
+export interface PackedBuffers {
+    skelI32: Int32Array;
+    animF32: Float32Array;
+    matFloats: Float32Array;
+    clipTableOffset: number;
+    channelTableOffset: number;
+    jointLookupOffset: number;
+    totalMats: number;
+}
+/**
+ * Layout of skelI32 (flat i32 array):
+ *   [0..S*10)         skin entries (10 i32 each)
+ *   [skinEnd..)       parent indices
+ *   [parentEnd..)     topo order
+ *   [topoEnd..)       clip entries (4 i32 each)
+ *   [clipEnd..)       channel entries (4 i32 each)
+ *   [channelEnd..)    per-joint channel lookup (2 i32 per joint per clip)
+ *
+ * Layout of animF32 (flat f32 array):
+ *   [0..K)            keyframe data
+ *   [K..)             rest pose TRS (10 floats per joint)
+ *
+ * Layout of matFloats (flat f32, read as mat4x4f):
+ *   [0..IBM)          inverse bind matrices
+ *   [IBM..)           skeleton root matrices
+ */
+export declare function packAnimationData(packed: PackedAnimationData): PackedBuffers;

package/dist/webgpu/types/camera/camera-2d.d.ts

@@ -0,0 +1,53 @@
+import type { Camera2DState } from 'murow/renderer';
+export declare class Camera2D implements Camera2DState {
+    x: number;
+    y: number;
+    zoom: number;
+    rotation: number;
+    private _prevX;
+    private _prevY;
+    private _prevZoom;
+    private _prevRotation;
+    private _renderX;
+    private _renderY;
+    private _renderZoom;
+    private _renderRotation;
+    private _width;
+    private _height;
+    /** Column-major 3x3 matrix stored as 12 floats (std140 padded) */
+    private _matrix;
+    constructor(width: number, height: number);
+    get width(): number;
+    get height(): number;
+    setViewport(width: number, height: number): void;
+    setPosition(x: number, y: number): void;
+    move(x: number, y: number): void;
+    private _worldPoint;
+    /**
+     * Unproject a screen coordinate to a world-space position.
+     * Uses current (non-interpolated) camera state.
+     * Returns a pre-allocated tuple — copy if you need to store it.
+     */
+    screenToWorld(screenX: number, screenY: number): [number, number];
+    /**
+     * Smoothly move the camera toward a target position.
+     * Call each tick. The camera lerps toward (targetX, targetY) by the given factor.
+     * @param targetX  World X to follow
+     * @param targetY  World Y to follow
+     * @param smoothing  0-1. 1 = snap instantly, 0.1 = lazy follow. Default 1.
+     */
+    follow(targetX: number, targetY: number, smoothing?: number): void;
+    /**
+     * Store current state as previous. Call before each tick.
+     */
+    storePrevious(): void;
+    /**
+     * Interpolate between previous and current state. Call before rendering.
+     */
+    interpolate(alpha: number): void;
+    /**
+     * Build the view-projection matrix using interpolated state.
+     * Orthographic: maps world coords to clip space [-1,1].
+     */
+    getMatrix(): Float32Array;
+}

package/dist/webgpu/types/camera/camera-2d.test.d.ts

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

package/dist/webgpu/types/camera/camera-3d.d.ts

@@ -0,0 +1,81 @@
+import { Ray3D } from "murow/core/ray";
+import type { Camera3DState } from 'murow/renderer';
+export declare class Camera3D implements Camera3DState {
+    position: [number, number, number];
+    target: [number, number, number];
+    up: [number, number, number];
+    fov: number;
+    near: number;
+    far: number;
+    aspect: number;
+    movement: 'local' | 'grounded' | 'global';
+    private _prevPosition;
+    private _prevTarget;
+    private _renderPosition;
+    private _renderTarget;
+    private _viewMatrix;
+    private _projMatrix;
+    private _vpMatrix;
+    private _ray;
+    private _width;
+    private _height;
+    /**
+     * Store current position/target as previous. Call before each tick.
+     */
+    storePrevious(): void;
+    /**
+     * Smoothly move the camera toward a target point.
+     * Call each tick. The camera and its look-at target lerp toward the given position.
+     * @param targetX  World X to follow
+     * @param targetY  World Y to follow
+     * @param targetZ  World Z to follow
+     * @param smoothing  0-1. 1 = snap instantly, 0.1 = lazy follow. Default 1.
+     */
+    follow(targetX: number, targetY: number, targetZ: number, smoothing?: number): void;
+    /**
+     * Interpolate between previous and current state. Call before rendering.
+     */
+    interpolate(alpha: number): void;
+    /**
+     * Build the view matrix (lookAt) using interpolated state.
+     */
+    getViewMatrix(): Float32Array;
+    /**
+     * Build the perspective projection matrix.
+     */
+    getProjectionMatrix(): Float32Array;
+    /**
+     * Build the combined view-projection matrix.
+     */
+    getViewProjectionMatrix(): Float32Array;
+    setAspect(width: number, height: number): void;
+    setPosition(x: number, y: number, z: number): void;
+    /**
+     * Unproject a screen coordinate into a world-space ray.
+     * Requires `setAspect(width, height)` to have been called first.
+     * Returns a pre-allocated Ray3D — copy origin/direction if you need to store it.
+     */
+    screenToRay(screenX: number, screenY: number): Ray3D;
+    setTarget(x: number, y: number, z: number): void;
+    /**
+     * Move the camera. Behaviour is determined by the `movement` property:
+     * - `'local'`    — along camera axes, pitch included (free-fly / spectator)
+     * - `'grounded'` — yaw-projected XZ + world Y (FPS)
+     * - `'global'`   — world axes directly (isometric / platformer)
+     */
+    move(right: number, up: number, forward: number): void;
+    private _moveLocal;
+    private _moveGrounded;
+    private _moveGlobal;
+    /**
+     * Orbit around the target point. Zero allocations.
+     * @param yawDelta   Horizontal rotation in radians (positive = rotate right)
+     * @param pitchDelta Vertical rotation in radians (positive = rotate up)
+     */
+    orbit(yawDelta: number, pitchDelta: number): void;
+    /**
+     * Zoom by adjusting distance to target. Zero allocations.
+     * @param delta Positive = zoom in, negative = zoom out
+     */
+    zoom(delta: number): void;
+}

package/dist/webgpu/types/camera/camera-3d.test.d.ts

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

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

@@ -0,0 +1,2 @@
+export * from "./camera-2d";
+export * from "./camera-3d";

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

@@ -0,0 +1,123 @@
+import type { TgpuRoot, TgpuBuffer, TgpuBindGroup, TgpuComputePipeline } from 'typegpu';
+import type { AnyWgslData, AnyData } from 'typegpu/data';
+/** Buffer definition for a compute shader. */
+export interface ComputeBufferDef<TStorage extends AnyWgslData = AnyWgslData, TUniform extends AnyData = AnyData> {
+    /** Storage buffer (read-only or read-write). Provide an arrayOf(...) schema. */
+    storage?: TStorage;
+    /** Uniform buffer. Provide a struct schema. */
+    uniform?: TUniform;
+    /** If true, storage buffer is read-write (`storage, read_write`). Default: false (read-only). */
+    readwrite?: boolean;
+    /** External TgpuBuffer to use instead of creating a new one. For buffer sharing between kernels. */
+    external?: TgpuBuffer<AnyWgslData>;
+}
+/** Extract the data type from a buffer definition. */
+type BufferDataType<T extends ComputeBufferDef> = T extends {
+    storage: infer S;
+} ? S : T extends {
+    uniform: infer U;
+} ? U : unknown;
+export interface ComputeOptions {
+    /** Number of invocations per workgroup. Default: 64. */
+    workgroupSize: number | [number, number] | [number, number, number];
+}
+/** Compute shader input builtins. */
+export interface ComputeInput {
+    /** Global invocation ID (x, y, z). */
+    globalId: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Local invocation ID within workgroup. */
+    localId: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Local invocation index (flattened). */
+    localIndex: number;
+    /** Workgroup ID. */
+    workgroupId: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Number of workgroups dispatched. */
+    numWorkgroups: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+/**
+ * Buffer accessors passed to the compute shader as the first parameter.
+ * Buffer names and data types are inferred from `.buffers()`.
+ */
+export type ComputeBufferAccessors<TBuffers extends Record<string, ComputeBufferDef>> = {
+    readonly [K in keyof TBuffers]: BufferDataType<TBuffers[K]>;
+};
+/**
+ * Compute shader function signature.
+ * First param: buffer accessors (typed from `.buffers()`).
+ * Second param: compute builtins (globalId, localId, etc.).
+ */
+type ComputeShaderFn<TBuffers extends Record<string, ComputeBufferDef>> = (buffers: ComputeBufferAccessors<TBuffers>, input: ComputeInput) => void;
+export declare class ComputeKernel<TBuffers extends Record<string, ComputeBufferDef> = Record<string, ComputeBufferDef>> {
+    readonly name: string;
+    private root;
+    private pipeline;
+    private bindGroup;
+    private buffers;
+    private workgroupSize;
+    constructor(name: string, root: TgpuRoot, pipeline: TgpuComputePipeline, bindGroup: TgpuBindGroup, buffers: Map<string, TgpuBuffer<AnyWgslData>>, workgroupSize: [number, number, number]);
+    /**
+     * Write data to a uniform or storage buffer by name.
+     */
+    write<K extends keyof TBuffers & string>(bufferName: K, data: unknown): void;
+    /**
+     * Dispatch the compute shader (creates its own command encoder).
+     * @param countOrGroups Total invocation count (divided by workgroupSize automatically),
+     *                      or explicit [x, y, z] workgroup counts.
+     */
+    dispatch(countOrGroups: number | [number, number?, number?]): void;
+    /**
+     * Encode a compute dispatch into an existing command encoder.
+     * Use this to chain multiple compute passes without separate submissions.
+     * The compute pass is started and ended within this call.
+     */
+    encode(encoder: GPUCommandEncoder, countOrGroups: number | [number, number?, number?]): void;
+    private _resolveGroups;
+    /**
+     * Read data back from a storage buffer.
+     * Warning: this forces a GPU → CPU sync stall. Avoid in hot paths.
+     */
+    read(bufferName: keyof TBuffers & string): Promise<unknown>;
+    /**
+     * Get the raw TypeGPU buffer for a named buffer.
+     * Use this to share buffers between compute and render pipelines (zero-copy).
+     */
+    getBuffer(bufferName: keyof TBuffers & string): TgpuBuffer<AnyWgslData>;
+    destroy(): void;
+}
+export declare class ComputeBuilder<TBuffers extends Record<string, ComputeBufferDef> = Record<string, never>> {
+    private _name;
+    private _root;
+    private _workgroupSize;
+    private _bufferDefs;
+    private _shaderFn;
+    constructor(name: string, options: ComputeOptions, root: TgpuRoot);
+    /**
+     * Define the compute shader's buffers.
+     * Each entry maps a name to a storage or uniform buffer definition.
+     */
+    buffers<B extends Record<string, ComputeBufferDef>>(defs: B): ComputeBuilder<B>;
+    /**
+     * Define the compute shader body.
+     * Receives a context with buffer accessors and compute builtins.
+     * No `'use gpu'` needed — the builder handles transpilation.
+     */
+    shader(fn: ComputeShaderFn<TBuffers>): this;
+    build(): ComputeKernel<TBuffers>;
+}
+export {};

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

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

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

@@ -0,0 +1,59 @@
+/**
+ * Memory layout constants for the 2D renderer.
+ *
+ * Dynamic data: updated every tick (positions, rotation).
+ * Static data: rarely changes (UVs, tint, opacity, scale).
+ *
+ * Laid out as flat Float32Arrays for zero-GC GPU uploads.
+ */
+export declare const DYNAMIC_OFFSET_PREV_X = 0;
+export declare const DYNAMIC_OFFSET_PREV_Y = 1;
+export declare const DYNAMIC_OFFSET_CURR_X = 2;
+export declare const DYNAMIC_OFFSET_CURR_Y = 3;
+export declare const DYNAMIC_OFFSET_PREV_ROTATION = 4;
+export declare const DYNAMIC_OFFSET_CURR_ROTATION = 5;
+export declare const DYNAMIC_FLOATS_PER_SPRITE = 6;
+export declare const STATIC_OFFSET_SCALE_X = 0;
+export declare const STATIC_OFFSET_SCALE_Y = 1;
+export declare const STATIC_OFFSET_UV_MIN_X = 2;
+export declare const STATIC_OFFSET_UV_MIN_Y = 3;
+export declare const STATIC_OFFSET_UV_MAX_X = 4;
+export declare const STATIC_OFFSET_UV_MAX_Y = 5;
+export declare const STATIC_OFFSET_LAYER = 6;
+export declare const STATIC_OFFSET_FLIP_X = 7;
+export declare const STATIC_OFFSET_FLIP_Y = 8;
+export declare const STATIC_OFFSET_OPACITY = 9;
+export declare const STATIC_OFFSET_TINT_R = 10;
+export declare const STATIC_OFFSET_TINT_G = 11;
+export declare const STATIC_OFFSET_TINT_B = 12;
+export declare const STATIC_OFFSET_TINT_A = 13;
+export declare const STATIC_FLOATS_PER_SPRITE = 14;
+export declare const DYNAMIC_3D_OFFSET_PREV_POS_X = 0;
+export declare const DYNAMIC_3D_OFFSET_PREV_POS_Y = 1;
+export declare const DYNAMIC_3D_OFFSET_PREV_POS_Z = 2;
+export declare const DYNAMIC_3D_OFFSET_CURR_POS_X = 3;
+export declare const DYNAMIC_3D_OFFSET_CURR_POS_Y = 4;
+export declare const DYNAMIC_3D_OFFSET_CURR_POS_Z = 5;
+export declare const DYNAMIC_3D_OFFSET_PREV_ROT_X = 6;
+export declare const DYNAMIC_3D_OFFSET_PREV_ROT_Y = 7;
+export declare const DYNAMIC_3D_OFFSET_PREV_ROT_Z = 8;
+export declare const DYNAMIC_3D_OFFSET_PREV_ROT_W = 9;
+export declare const DYNAMIC_3D_OFFSET_CURR_ROT_X = 10;
+export declare const DYNAMIC_3D_OFFSET_CURR_ROT_Y = 11;
+export declare const DYNAMIC_3D_OFFSET_CURR_ROT_Z = 12;
+export declare const DYNAMIC_3D_OFFSET_CURR_ROT_W = 13;
+export declare const DYNAMIC_3D_FLOATS_PER_INSTANCE = 14;
+export declare const STATIC_3D_OFFSET_SCALE_X = 0;
+export declare const STATIC_3D_OFFSET_SCALE_Y = 1;
+export declare const STATIC_3D_OFFSET_SCALE_Z = 2;
+export declare const STATIC_3D_OFFSET_MATERIAL_ID = 3;
+export declare const STATIC_3D_OFFSET_OPACITY = 4;
+export declare const STATIC_3D_OFFSET_TINT_R = 5;
+export declare const STATIC_3D_OFFSET_TINT_G = 6;
+export declare const STATIC_3D_OFFSET_TINT_B = 7;
+export declare const STATIC_3D_OFFSET_TINT_A = 8;
+export declare const STATIC_3D_OFFSET_CUSTOM_0 = 9;
+export declare const STATIC_3D_OFFSET_CUSTOM_1 = 10;
+export declare const STATIC_3D_FLOATS_PER_INSTANCE = 11;
+export declare const INVALID_INDEX = 4294967295;
+export declare const INVALID_ENTITY = 4294967295;

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

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

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

@@ -0,0 +1,2 @@
+export * from "./constants";
+export * from "./types";

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 {};