murow 0.0.60 → 0.0.71

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 } from './kernel';
+export { packAnimationData, type PackedBuffers } from './packer';

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

@@ -0,0 +1,8 @@
+import { type ComputeKernel } from '../../compute/compute-builder';
+import type { TgpuRoot } from 'typegpu';
+import { type PackedBuffers } from './packer';
+import type { PackedAnimationData } from '../gltf-skin-parser';
+export declare function buildAnimationKernel(root: TgpuRoot, packed: PackedAnimationData, maxInstances: number, maxTotalBones: number): {
+    kernel: ComputeKernel;
+    packedBuffers: PackedBuffers;
+};

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 '../gltf-skin-parser';
+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/3d/skeletal-animation.d.ts

@@ -0,0 +1,90 @@
+/**
+ * SkeletalAnimation — CPU-side bone matrix evaluation for skinned meshes.
+ *
+ * Evaluates animation clips by sampling keyframes, computing joint local transforms,
+ * walking the hierarchy, and writing final bone matrices into a pre-allocated buffer.
+ * Zero per-frame allocations.
+ *
+ * Usage:
+ * ```ts
+ * const anim = new SkeletalAnimation(skinData, clips);
+ * const state = anim.createState('walk');
+ *
+ * // Each tick:
+ * anim.update(state, deltaTime, outputMatrices);
+ *
+ * // outputMatrices is a Float32Array view into the bone matrix buffer
+ * ```
+ */
+import type { SkinData, AnimationClipData, AnimationChannel } from './gltf-skin-parser';
+export interface SkeletalClip {
+    readonly id: number;
+    readonly name: string;
+    readonly duration: number;
+    readonly channels: AnimationChannel[];
+    readonly loop: boolean;
+}
+export interface PlayOptions {
+    speed?: number;
+    /** Crossfade duration in seconds. 0 = instant switch (default). */
+    crossfade?: number;
+    /** Whether the animation should loop. Default: true. */
+    loop?: boolean;
+    /** Called when the animation clip ends (reaches duration). Fires each loop for looping clips. */
+    onEnd?: () => void;
+}
+export interface SkeletalAnimState {
+    clipId: number;
+    time: number;
+    speed: number;
+    playing: boolean;
+    loop: boolean;
+    prevClipId: number;
+    prevTime: number;
+    prevSpeed: number;
+    blendWeight: number;
+    blendDuration: number;
+    onEnd: () => void;
+}
+export declare class SkeletalAnimation {
+    private clips;
+    private clipsByName;
+    readonly skinData: SkinData;
+    private readonly localMatrices;
+    private readonly worldMatrices;
+    private readonly blendScratch;
+    private readonly originalRestPoseTRS;
+    private readonly currentTRS;
+    private readonly topoOrder;
+    private readonly skelRootMat;
+    constructor(skinData: SkinData, clips: AnimationClipData[], gltfNodes: any[]);
+    loadClip(clip: AnimationClipData, loop?: boolean): number;
+    getClipId(name: string): number;
+    getClipNames(): string[];
+    getClip(id: number): SkeletalClip | null;
+    get clipCount(): number;
+    createState(clipIdOrName: number | string, speed?: number, playing?: boolean): SkeletalAnimState;
+    play(state: SkeletalAnimState, clipIdOrName: number | string, opts?: PlayOptions): void;
+    stop(state: SkeletalAnimState): void;
+    resume(state: SkeletalAnimState): void;
+    /**
+     * Advance time and compute bone matrices.
+     * Writes jointCount mat4s into `output` starting at float index `outputOffset`.
+     * Handles crossfade blending automatically.
+     */
+    update(state: SkeletalAnimState, deltaTime: number, output: Float32Array, outputOffset?: number): void;
+    /** Advance clip time with looping/clamping. */
+    private advanceTime;
+    /** Evaluate a clip at a specific time and write bone matrices. */
+    private evaluateClip;
+    /**
+     * Compute bone matrices for the rest/bind pose (no animation).
+     */
+    computeRestPose(output: Float32Array, outputOffset?: number): void;
+    /** Sample an animation channel at time t. Returns 3 or 4 floats. */
+    private sampleChannel;
+    private readonly _scratchVec3;
+    private readonly _scratchQuat;
+    /** Normalized lerp for quaternions (nlerp). */
+    private nlerpQuat;
+}

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

@@ -0,0 +1,53 @@
+import type { Camera2DState } from 'murow/renderer/types';
+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/types';
+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/math.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared 3D math utilities for the WebGPU renderer.
+ * All functions operate on Float32Arrays with explicit offsets — zero allocations in hot paths.
+ */
+/**
+ * Write a 4x4 identity matrix into `dst` at `offset`.
+ */
+export declare function mat4Identity(dst: Float32Array, offset: number): void;
+/**
+ * Create a new 4x4 identity matrix.
+ */
+export declare function mat4IdentityNew(): Float32Array;
+/**
+ * Write a column-major 4x4 matrix from TRS (translation, quaternion rotation, scale)
+ * into `dst` at `offset`.
+ */
+export declare function trsToMat4(tx: number, ty: number, tz: number, qx: number, qy: number, qz: number, qw: number, sx: number, sy: number, sz: number, dst: Float32Array, offset: number): void;
+/**
+ * Build a column-major 4x4 matrix from a glTF node's TRS or matrix property.
+ * Allocates and returns a new Float32Array(16).
+ */
+export declare function nodeToMat4(node: {
+    translation?: number[];
+    rotation?: number[];
+    scale?: number[];
+    matrix?: number[];
+}): Float32Array;
+/**
+ * 4x4 matrix multiply: dst[dO..+16] = a[aO..+16] * b[bO..+16]. Column-major.
+ * Safe when a, b, dst overlap (uses internal temp buffer).
+ */
+export declare function mat4Mul(a: Float32Array, aO: number, b: Float32Array, bO: number, dst: Float32Array, dO: number): void;
+/**
+ * 4x4 matrix multiply that allocates and returns a new Float32Array(16).
+ * Use for load-time operations, not per-frame hot paths.
+ */
+export declare function mat4MulNew(a: Float32Array, b: Float32Array): Float32Array;