@flighthq/scene3d-wgpu 0.2.1-next.840.857425c

package/dist/transmissionVolumePbrWgpuMeshMaterialRenderer.js

@@ -0,0 +1,74 @@
+import { unpackColorToLinear } from '@flighthq/color';
+import { getWgpuRenderStateRuntime } from '@flighthq/render-wgpu';
+import { TransmissionVolumePbrMaterialKind } from '@flighthq/types';
+import { buildWgpuPbrStandardDefineKey, ensureWgpuPbrMaterialBindGroup, getWgpuPbrMaterialScratch, writeWgpuPbrMaterialUniform, writeWgpuPbrStandardBlock, } from './standardPbrWgpuMeshMaterialRenderer';
+import { registerWgpuMeshMaterialRenderer } from './wgpuMeshMaterialRegistry';
+import { beginWgpuMeshDraw, drawWgpuMeshSubset, writeWgpuFrameUniform } from './wgpuMeshPipeline';
+import { ensureWgpuPbrPipeline } from './wgpuPbrPipelineCache';
+// The built-in TransmissionVolume (KHR_materials_transmission + KHR_materials_volume) forward-lit
+// mesh-material renderer for refractive, see-through surfaces (glass, liquid) — the WGSL mirror of
+// transmissionVolumePbrGlMeshMaterialRenderer.
+//
+// APPROXIMATION (not physically refractive yet): a true transmission path needs the Phase-5
+// opaque-scene-color capture pass to sample what lies behind the surface and refract it through the
+// surface IOR, with Beer-Lambert absorption over the volume `thickness`. Until that pass exists, this
+// renderer models transmission cheaply behind `const TRANSMISSION`: it attenuates the fragment's
+// coverage (alpha) by the `transmission` factor so the surface reads as translucent, and tints the lit
+// radiance by `attenuationColor`. The surface is therefore drawn as a tinted, partially transparent lit
+// shell rather than a refracting lens. `thickness`, `attenuationDistance`, and `ior` are accepted on the
+// material but only `transmission`/`attenuationColor` drive the current shader.
+//
+// bind builds the standard define key from `material.standard` + the surface trailer, sets the
+// TRANSMISSION flag, selects/compiles that pipeline variant for the current color format, writes the
+// shared Frame uniform, then writes the base block + the transmission factor / linear-decoded
+// attenuationColor into the one MaterialBlock uniform and binds it at group(2). The transmission/
+// thickness maps are reserved but NOT sampled on wgpu yet (maps deferred). See
+// registerTransmissionVolumePbrWgpuMaterial.
+export const transmissionVolumePbrWgpuMeshMaterialRenderer = {
+    bind(state, material, lights, camera) {
+        const stateRuntime = getWgpuRenderStateRuntime(state);
+        const pass = stateRuntime.renderPass;
+        if (pass === null)
+            return;
+        const transmission = material;
+        const standard = transmission !== null ? transmission.standard : null;
+        const key = buildWgpuPbrStandardDefineKey(standard, transmission);
+        key.transmissionEnabled = true;
+        const format = stateRuntime.currentColorFormat ?? state.format;
+        const pipeline = ensureWgpuPbrPipeline(state, key, format);
+        writeWgpuFrameUniform(state, camera, lights);
+        const binding = ensureWgpuPbrMaterialBindGroup(state, pipeline, transmission ?? FALLBACK_MATERIAL, standard);
+        const out = getWgpuPbrMaterialScratch();
+        writeWgpuPbrStandardBlock(out, standard, transmission !== null ? transmission.alphaCutoff : 0.5);
+        out.fill(0, 16);
+        // transmission group (floats 44..47): transmission factor, attenuationColor.rgb (linear).
+        if (transmission !== null) {
+            unpackColorToLinear(_colorScratch, transmission.attenuationColor);
+            out[44] = transmission.transmission;
+            out[45] = _colorScratch[0];
+            out[46] = _colorScratch[1];
+            out[47] = _colorScratch[2];
+        }
+        else {
+            out[44] = 0;
+            out[45] = 1;
+            out[46] = 1;
+            out[47] = 1;
+        }
+        writeWgpuPbrMaterialUniform(state, binding);
+        beginWgpuMeshDraw(state, pipeline);
+        pass.setBindGroup(2, binding.bindGroup);
+    },
+    draw(state, proxy, geometry) {
+        drawWgpuMeshSubset(state, proxy, geometry);
+    },
+};
+// Installs the built-in TransmissionVolume renderer for TransmissionVolumePbrMaterialKind on this
+// state. Opt-in (no top-level side effect): drawScene3D only draws TransmissionVolume subsets once this
+// is called.
+export function registerTransmissionVolumePbrWgpuMaterial(state) {
+    registerWgpuMeshMaterialRenderer(state, TransmissionVolumePbrMaterialKind, transmissionVolumePbrWgpuMeshMaterialRenderer);
+}
+const FALLBACK_MATERIAL = {};
+const _colorScratch = [0, 0, 0, 0];
+//# sourceMappingURL=transmissionVolumePbrWgpuMeshMaterialRenderer.js.map

package/dist/transmissionVolumePbrWgpuMeshMaterialRenderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transmissionVolumePbrWgpuMeshMaterialRenderer.js","sourceRoot":"","sources":["../src/transmissionVolumePbrWgpuMeshMaterialRenderer.ts"],"names":[],"mappings":"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"}

package/dist/unlitWgpuMeshMaterialRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { WgpuMeshMaterialRenderer, WgpuRenderState } from '@flighthq/types';
+export declare const unlitWgpuMeshMaterialRenderer: WgpuMeshMaterialRenderer;
+export declare function registerUnlitWgpuMaterial(state: WgpuRenderState): void;
+//# sourceMappingURL=unlitWgpuMeshMaterialRenderer.d.ts.map

package/dist/unlitWgpuMeshMaterialRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unlitWgpuMeshMaterialRenderer.d.ts","sourceRoot":"","sources":["../src/unlitWgpuMeshMaterialRenderer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAQV,wBAAwB,EACxB,eAAe,EAEhB,MAAM,iBAAiB,CAAC;AAWzB,eAAO,MAAM,6BAA6B,EAAE,wBAkC3C,CAAC;AAIF,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAEtE"}

package/dist/unlitWgpuMeshMaterialRenderer.js

@@ -0,0 +1,57 @@
+import { unpackColorToLinear } from '@flighthq/color';
+import { getWgpuRenderStateRuntime } from '@flighthq/render-wgpu';
+import { isVideoTextureFrameReady } from '@flighthq/texture';
+import { UnlitMaterialKind } from '@flighthq/types';
+import { registerWgpuMeshMaterialRenderer } from './wgpuMeshMaterialRegistry';
+import { beginWgpuMeshDraw, drawWgpuMeshSubset, isWgpuTextureReady, writeWgpuFrameUniform } from './wgpuMeshPipeline';
+import { bindWgpuUnlitSurface, bindWgpuUnlitVideoSurface, ensureWgpuUnlitPipeline } from './wgpuUnlitPrelude';
+// The built-in Unlit forward renderer (WgpuMeshMaterialRenderer for UnlitMaterialKind) — the WGSL
+// mirror of unlitGlMeshMaterialRenderer. Lighting-independent flat color: bind selects the unlit
+// pipeline variant for the alpha mode + color format, writes the shared Frame uniform (lights ignored),
+// and binds the linear base color; draw issues the indexed draw. See registerUnlitWgpuMaterial.
+export const unlitWgpuMeshMaterialRenderer = {
+    bind(state, material, _lights, camera) {
+        const stateRuntime = getWgpuRenderStateRuntime(state);
+        const pass = stateRuntime.renderPass;
+        if (pass === null)
+            return;
+        const unlit = material;
+        const format = stateRuntime.currentColorFormat ?? state.format;
+        const pipeline = ensureWgpuUnlitPipeline(state, defineKeyForMaterial(unlit), format);
+        writeWgpuFrameUniform(state, camera, _lights);
+        let group;
+        if (unlit === null) {
+            group = bindWgpuUnlitSurface(state, pipeline, FALLBACK_MATERIAL, WHITE, 1, 0.5, null);
+        }
+        else {
+            unpackColorToLinear(_scratch, unlit.baseColor);
+            group =
+                unlit.baseColorVideoMap !== null && isVideoTextureFrameReady(unlit.baseColorVideoMap)
+                    ? bindWgpuUnlitVideoSurface(state, pipeline, unlit, _scratch, 1, unlit.alphaCutoff, unlit.baseColorVideoMap)
+                    : bindWgpuUnlitSurface(state, pipeline, unlit, _scratch, 1, unlit.alphaCutoff, unlit.baseColorMap);
+        }
+        beginWgpuMeshDraw(state, pipeline);
+        pass.setBindGroup(2, group);
+    },
+    draw(state, proxy, geometry) {
+        drawWgpuMeshSubset(state, proxy, geometry);
+    },
+};
+// Registers the built-in Unlit renderer for UnlitMaterialKind on this state. Opt-in (no top-level side
+// effect); call once per WgpuRenderState before drawWgpuScene3D so meshes with UnlitMaterials draw.
+export function registerUnlitWgpuMaterial(state) {
+    registerWgpuMeshMaterialRenderer(state, UnlitMaterialKind, unlitWgpuMeshMaterialRenderer);
+}
+function defineKeyForMaterial(material) {
+    return {
+        alphaMaskEnabled: material !== null && material.alphaMode === 'mask',
+        doubleSided: material !== null && material.doubleSided,
+        hasColorMap: material !== null &&
+            ((material.baseColorVideoMap !== null && isVideoTextureFrameReady(material.baseColorVideoMap)) ||
+                isWgpuTextureReady(material.baseColorMap)),
+    };
+}
+const _scratch = [0, 0, 0, 0];
+const WHITE = [1, 1, 1, 1];
+const FALLBACK_MATERIAL = {};
+//# sourceMappingURL=unlitWgpuMeshMaterialRenderer.js.map

package/dist/unlitWgpuMeshMaterialRenderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unlitWgpuMeshMaterialRenderer.js","sourceRoot":"","sources":["../src/unlitWgpuMeshMaterialRenderer.ts"],"names":[],"mappings":"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"}

package/dist/vertexColorWgpuMeshMaterialRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { WgpuMeshMaterialRenderer, WgpuRenderState } from '@flighthq/types';
+export declare const vertexColorWgpuMeshMaterialRenderer: WgpuMeshMaterialRenderer;
+export declare function registerVertexColorWgpuMaterial(state: WgpuRenderState): void;
+//# sourceMappingURL=vertexColorWgpuMeshMaterialRenderer.d.ts.map

package/dist/vertexColorWgpuMeshMaterialRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vertexColorWgpuMeshMaterialRenderer.d.ts","sourceRoot":"","sources":["../src/vertexColorWgpuMeshMaterialRenderer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAQV,wBAAwB,EACxB,eAAe,EAEhB,MAAM,iBAAiB,CAAC;AAYzB,eAAO,MAAM,mCAAmC,EAAE,wBAiCjD,CAAC;AAKF,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAE5E"}

package/dist/vertexColorWgpuMeshMaterialRenderer.js

@@ -0,0 +1,55 @@
+import { unpackColorToLinear } from '@flighthq/color';
+import { getWgpuRenderStateRuntime } from '@flighthq/render-wgpu';
+import { VertexColorMaterialKind } from '@flighthq/types';
+import { registerWgpuMeshMaterialRenderer } from './wgpuMeshMaterialRegistry';
+import { beginWgpuMeshDraw, drawWgpuMeshSubset, writeWgpuFrameUniform } from './wgpuMeshPipeline';
+import { bindWgpuUnlitSurface, ensureWgpuUnlitPipeline } from './wgpuUnlitPrelude';
+// The built-in VertexColor forward renderer (WgpuMeshMaterialRenderer for VertexColorMaterialKind) —
+// the WGSL mirror of vertexColorGlMeshMaterialRenderer. Lighting-independent: renders the material's
+// linear tint through the shared unlit pipeline. The canonical 48-byte vertex layout has no color0
+// slot on wgpu, so (unlike the GL path) the mesh color0 attribute is not yet multiplied in — the tint
+// alone drives the surface until color0 vertex support lands. See registerVertexColorWgpuMaterial.
+export const vertexColorWgpuMeshMaterialRenderer = {
+    bind(state, material, _lights, camera) {
+        const stateRuntime = getWgpuRenderStateRuntime(state);
+        const pass = stateRuntime.renderPass;
+        if (pass === null)
+            return;
+        const vertexColor = material;
+        const format = stateRuntime.currentColorFormat ?? state.format;
+        const pipeline = ensureWgpuUnlitPipeline(state, defineKeyForMaterial(vertexColor), format);
+        writeWgpuFrameUniform(state, camera, _lights);
+        let group;
+        if (vertexColor === null) {
+            group = bindWgpuUnlitSurface(state, pipeline, FALLBACK_MATERIAL, WHITE, 1, 0.5, null);
+        }
+        else {
+            unpackColorToLinear(_scratch, vertexColor.tint);
+            // VertexColor carries no map texture; color0 (the per-vertex tint) is the absent vertex attribute,
+            // not a material map. Pass null so the placeholder satisfies the color slot.
+            group = bindWgpuUnlitSurface(state, pipeline, vertexColor, _scratch, 1, vertexColor.alphaCutoff, null);
+        }
+        beginWgpuMeshDraw(state, pipeline);
+        pass.setBindGroup(2, group);
+    },
+    draw(state, proxy, geometry) {
+        drawWgpuMeshSubset(state, proxy, geometry);
+    },
+};
+// Registers the built-in VertexColor renderer for VertexColorMaterialKind on this state. Opt-in (no
+// top-level side effect); call once per WgpuRenderState before drawWgpuScene3D so meshes with
+// VertexColorMaterials draw.
+export function registerVertexColorWgpuMaterial(state) {
+    registerWgpuMeshMaterialRenderer(state, VertexColorMaterialKind, vertexColorWgpuMeshMaterialRenderer);
+}
+function defineKeyForMaterial(material) {
+    return {
+        alphaMaskEnabled: material !== null && material.alphaMode === 'mask',
+        doubleSided: material !== null && material.doubleSided,
+        hasColorMap: false,
+    };
+}
+const _scratch = [0, 0, 0, 0];
+const WHITE = [1, 1, 1, 1];
+const FALLBACK_MATERIAL = {};
+//# sourceMappingURL=vertexColorWgpuMeshMaterialRenderer.js.map

package/dist/vertexColorWgpuMeshMaterialRenderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vertexColorWgpuMeshMaterialRenderer.js","sourceRoot":"","sources":["../src/vertexColorWgpuMeshMaterialRenderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAalE,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAE1D,OAAO,EAAE,gCAAgC,EAAE,MAAM,4BAA4B,CAAC;AAC9E,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAClG,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAEnF,qGAAqG;AACrG,qGAAqG;AACrG,mGAAmG;AACnG,sGAAsG;AACtG,mGAAmG;AACnG,MAAM,CAAC,MAAM,mCAAmC,GAA6B;IAC3E,IAAI,CACF,KAAsB,EACtB,QAAmC,EACnC,OAAoC,EACpC,MAA0B;QAE1B,MAAM,YAAY,GAAG,yBAAyB,CAAC,KAAK,CAAC,CAAC;QACtD,MAAM,IAAI,GAAG,YAAY,CAAC,UAAU,CAAC;QACrC,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO;QAE1B,MAAM,WAAW,GAAG,QAAgD,CAAC;QACrE,MAAM,MAAM,GAAG,YAAY,CAAC,kBAAkB,IAAI,KAAK,CAAC,MAAM,CAAC;QAC/D,MAAM,QAAQ,GAAG,uBAAuB,CAAC,KAAK,EAAE,oBAAoB,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,CAAC;QAC3F,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;QAE9C,IAAI,KAAmB,CAAC;QACxB,IAAI,WAAW,KAAK,IAAI,EAAE,CAAC;YACzB,KAAK,GAAG,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;QACxF,CAAC;aAAM,CAAC;YACN,mBAAmB,CAAC,QAAQ,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;YAChD,mGAAmG;YACnG,6EAA6E;YAC7E,KAAK,GAAG,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC,EAAE,WAAW,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;QACzG,CAAC;QAED,iBAAiB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACnC,IAAI,CAAC,YAAY,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED,IAAI,CAAC,KAAsB,EAAE,KAAmC,EAAE,QAAgC;QAChG,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;IAC7C,CAAC;CACF,CAAC;AAEF,oGAAoG;AACpG,8FAA8F;AAC9F,6BAA6B;AAC7B,MAAM,UAAU,+BAA+B,CAAC,KAAsB;IACpE,gCAAgC,CAAC,KAAK,EAAE,uBAAuB,EAAE,mCAAmC,CAAC,CAAC;AACxG,CAAC;AAED,SAAS,oBAAoB,CAAC,QAA8C;IAC1E,OAAO;QACL,gBAAgB,EAAE,QAAQ,KAAK,IAAI,IAAI,QAAQ,CAAC,SAAS,KAAK,MAAM;QACpE,WAAW,EAAE,QAAQ,KAAK,IAAI,IAAI,QAAQ,CAAC,WAAW;QACtD,WAAW,EAAE,KAAK;KACnB,CAAC;AACJ,CAAC;AAED,MAAM,QAAQ,GAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAC3C,MAAM,KAAK,GAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AACxC,MAAM,iBAAiB,GAAG,EAAmC,CAAC"}

package/dist/wgpuClassicPrelude.d.ts

@@ -0,0 +1,8 @@
+import type { LinearColor, Texture, WgpuClassicDefineKey, WgpuClassicPipeline, WgpuRenderState, WgpuSkinningAdapter } from '@flighthq/types';
+export declare function bindWgpuClassicSurface(state: WgpuRenderState, pipeline: Readonly<WgpuClassicPipeline>, materialKey: object, diffuse: Readonly<LinearColor>, specular: Readonly<LinearColor>, shininess: number, alphaCutoff: number, diffuseMap: Readonly<Texture> | null, specularMap: Readonly<Texture> | null, normalMap: Readonly<Texture> | null, alphaMap: Readonly<Texture> | null): GPUBindGroup;
+export declare function buildWgpuClassicDefineKey(key: Readonly<WgpuClassicDefineKey>): string;
+export declare function compileWgpuClassicPipeline(state: WgpuRenderState, key: Readonly<WgpuClassicDefineKey>, format: GPUTextureFormat, blended?: boolean, skinned?: boolean): WgpuClassicPipeline;
+export declare function ensureWgpuClassicPipeline(state: WgpuRenderState, key: Readonly<WgpuClassicDefineKey>, format: GPUTextureFormat): WgpuClassicPipeline;
+export declare function getWgpuClassicModuleSourceForKey(key: Readonly<WgpuClassicDefineKey>, skinned?: boolean, skinning?: Readonly<WgpuSkinningAdapter> | null): string;
+export declare function getWgpuClassicSharedSamplerModuleSourceForKey(key: Readonly<WgpuClassicDefineKey>, skinned?: boolean, skinning?: Readonly<WgpuSkinningAdapter> | null): string;
+//# sourceMappingURL=wgpuClassicPrelude.d.ts.map

package/dist/wgpuClassicPrelude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuClassicPrelude.d.ts","sourceRoot":"","sources":["../src/wgpuClassicPrelude.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,OAAO,EACP,oBAAoB,EACpB,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACpB,MAAM,iBAAiB,CAAC;AAkBzB,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,eAAe,EACtB,QAAQ,EAAE,QAAQ,CAAC,mBAAmB,CAAC,EACvC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,EAC9B,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAAC,EAC/B,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,EACpC,WAAW,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,EACrC,SAAS,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,EACnC,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,GACjC,YAAY,CAsCd;AAMD,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,QAAQ,CAAC,oBAAoB,CAAC,GAAG,MAAM,CAKrF;AAMD,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,eAAe,EACtB,GAAG,EAAE,QAAQ,CAAC,oBAAoB,CAAC,EACnC,MAAM,EAAE,gBAAgB,EACxB,OAAO,UAAQ,EACf,OAAO,UAAQ,GACd,mBAAmB,CA8BrB;AAKD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,eAAe,EACtB,GAAG,EAAE,QAAQ,CAAC,oBAAoB,CAAC,EACnC,MAAM,EAAE,gBAAgB,GACvB,mBAAmB,CAIrB;AAID,wBAAgB,gCAAgC,CAC9C,GAAG,EAAE,QAAQ,CAAC,oBAAoB,CAAC,EACnC,OAAO,UAAQ,EACf,QAAQ,GAAE,QAAQ,CAAC,mBAAmB,CAAC,GAAG,IAAW,GACpD,MAAM,CAER;AAMD,wBAAgB,6CAA6C,CAC3D,GAAG,EAAE,QAAQ,CAAC,oBAAoB,CAAC,EACnC,OAAO,UAAQ,EACf,QAAQ,GAAE,QAAQ,CAAC,mBAAmB,CAAC,GAAG,IAAW,GACpD,MAAM,CAER"}

package/dist/wgpuClassicPrelude.js

@@ -0,0 +1,319 @@
+import { createWgpuMeshPipeline, ensureWgpuPerMapMaterialBinding, ensureWgpuScene3DPipeline, ensureWgpuShadowSampleLayout, getWgpuMeshPreludeWgsl, getWgpuMaterialSampler, resolveWgpuMaterialTextureView, stashWgpuUvTransform, } from './wgpuMeshPipeline';
+import { getWgpuSkinningAdapter } from './wgpuScene3DRuntime';
+// Ensures (and caches per material reference) the classic Material bind group — a uniform buffer + the
+// shared sampler + the placeholder diffuse/specular/normal textures — and rewrites its uniform with
+// this surface's linear diffuse + specular colors, shininess, and alpha cutoff. Mirrors scene-gl's
+// bindGl{Lambert,Phong,BlinnPhong}MaterialUniforms. Returns the bind group for the caller to set at
+// group(2).
+export function bindWgpuClassicSurface(state, pipeline, materialKey, diffuse, specular, shininess, alphaCutoff, diffuseMap, specularMap, normalMap, alphaMap) {
+    // Re-resolve the primary sampler + map views every bind so a live material-map mutation (swap,
+    // unready→ready, image replacement, version bump, primary-sampler change) is picked up; the views land
+    // in a REUSED module scratch so the steady-state re-bind of an unchanged material allocates nothing.
+    // ensureWgpuPerMapMaterialBinding rebuilds the bind group only when a view/sampler actually differs.
+    _samplerScratch[0] = getWgpuMaterialSampler(state, diffuseMap);
+    _samplerScratch[1] = getWgpuMaterialSampler(state, specularMap);
+    _samplerScratch[2] = getWgpuMaterialSampler(state, normalMap);
+    _samplerScratch[3] = getWgpuMaterialSampler(state, alphaMap);
+    _viewScratch[0] = resolveWgpuMaterialTextureView(state, diffuseMap);
+    _viewScratch[1] = resolveWgpuMaterialTextureView(state, specularMap);
+    _viewScratch[2] = resolveWgpuMaterialTextureView(state, normalMap);
+    _viewScratch[3] = resolveWgpuMaterialTextureView(state, alphaMap);
+    const binding = ensureWgpuPerMapMaterialBinding(state, materialKey, pipeline.materialBindGroupLayout, CLASSIC_UNIFORM_BYTES, _samplerScratch, _viewScratch);
+    _scratch[0] = diffuse[0];
+    _scratch[1] = diffuse[1];
+    _scratch[2] = diffuse[2];
+    _scratch[3] = diffuse[3];
+    _scratch[4] = specular[0];
+    _scratch[5] = specular[1];
+    _scratch[6] = specular[2];
+    _scratch[7] = specular[3];
+    _scratch[8] = shininess;
+    _scratch[9] = alphaCutoff;
+    _scratch[10] = 0;
+    _scratch[11] = 0;
+    state.device.queue.writeBuffer(binding.buffer, 0, _scratch.buffer, 0, CLASSIC_UNIFORM_BYTES);
+    // The diffuse map's uv transform drives the shared vertex-scene2d uv the classic maps sample.
+    stashWgpuUvTransform(state, diffuseMap);
+    return binding.bindGroup;
+}
+// A short, stable, order-independent string identity for a classic define key, used as the pipeline-
+// cache key (combined with the color format). The lighting model is encoded first (l/p/b) so the three
+// models never collide, followed by the feature flags. Two keys with the same model + flags produce
+// the same string and so share a compiled pipeline.
+export function buildWgpuClassicDefineKey(key) {
+    const model = key.lightingModel === 'phong' ? 'p' : key.lightingModel === 'blinnphong' ? 'b' : 'l';
+    return `${model}${key.alphaMaskEnabled ? 'm' : '-'}${key.doubleSided ? 'd' : '-'}${key.hasDiffuseMap ? 'd' : '-'}${key.hasSpecularMap ? 's' : '-'}${key.hasNormalMap ? 'n' : '-'}${key.hasAlphaMap ? 'a' : '-'}`;
+}
+// Compiles the classic module for a define key and builds the render pipeline for the given color
+// format, with the group(2) material bind-group layout (uniform + one sampler per map +
+// diffuse/specular/normal/alpha textures). Pure GPU work — no caching — used by
+// ensureWgpuClassicPipeline.
+export function compileWgpuClassicPipeline(state, key, format, blended = false, skinned = false) {
+    const device = state.device;
+    const module = device.createShaderModule({
+        code: getWgpuClassicModuleSourceForKey(key, skinned, getWgpuSkinningAdapter(state)),
+    });
+    const materialBindGroupLayout = device.createBindGroupLayout({
+        entries: [
+            { binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform' } },
+            { binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' } },
+            { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' } },
+            { binding: 3, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' } },
+            { binding: 4, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' } },
+            { binding: 5, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: 'float' } },
+            { binding: 6, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: 'float' } },
+            { binding: 7, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: 'float' } },
+            { binding: 8, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: 'float' } },
+        ],
+    });
+    // The group(3) shadow-sample layout opts this pipeline into directional shadow reception: the pipeline
+    // layout gains [Frame, Draw, Material, Shadow] and beginWgpuMeshDraw binds the shared shadow group each
+    // draw (the real depth map when drawWgpuScene3DShadowMap ran this frame, else a gated-off 1x1 dummy).
+    return createWgpuMeshPipeline(state, {
+        blended,
+        doubleSided: key.doubleSided,
+        format,
+        materialBindGroupLayout,
+        module,
+        shadowBindGroupLayout: ensureWgpuShadowSampleLayout(state),
+        skinned,
+    });
+}
+// Resolves the classic pipeline for a define key + color format, compiling and caching it on first use
+// through the shared scene pipeline cache under the `classic:` family namespace, so each model +
+// feature/format variant is compiled at most once per state and reused every frame.
+export function ensureWgpuClassicPipeline(state, key, format) {
+    return ensureWgpuScene3DPipeline(state, `classic:${format}|${buildWgpuClassicDefineKey(key)}`, (blended, skinned) => compileWgpuClassicPipeline(state, key, format, blended, skinned));
+}
+// The full WGSL module source for a define key: the const-flag block (lighting model first) + the
+// shared mesh prelude (Frame/Draw/vs_main/srgbToLinear) + the classic material block + fs_main.
+export function getWgpuClassicModuleSourceForKey(key, skinned = false, skinning = null) {
+    return assembleWgpuClassicModuleSource(key, skinned, skinning, CLASSIC_WGSL_BODY);
+}
+// ShadedMaterial composes modifier declarations and contributions into the classic WGSL, but retains
+// its intentionally extensible legacy group(2) layout: one sampler at binding 1, base textures at 2..5,
+// and modifier textures at 6+. Keep that source contract separate from the per-map classic pipeline so
+// changing classic's sampler layout cannot collide with shaded modifier bindings.
+export function getWgpuClassicSharedSamplerModuleSourceForKey(key, skinned = false, skinning = null) {
+    return assembleWgpuClassicModuleSource(key, skinned, skinning, CLASSIC_SHARED_SAMPLER_WGSL_BODY);
+}
+function assembleWgpuClassicModuleSource(key, skinned, skinning, body) {
+    return (`const LIGHTING_PHONG : bool = ${key.lightingModel === 'phong' ? 'true' : 'false'};\n` +
+        `const LIGHTING_BLINNPHONG : bool = ${key.lightingModel === 'blinnphong' ? 'true' : 'false'};\n` +
+        `const ALPHA_MASK : bool = ${key.alphaMaskEnabled ? 'true' : 'false'};\n` +
+        `const DOUBLE_SIDED : bool = ${key.doubleSided ? 'true' : 'false'};\n` +
+        `const HAS_DIFFUSE_MAP : bool = ${key.hasDiffuseMap ? 'true' : 'false'};\n` +
+        `const HAS_SPECULAR_MAP : bool = ${key.hasSpecularMap ? 'true' : 'false'};\n` +
+        `const HAS_NORMAL_MAP : bool = ${key.hasNormalMap ? 'true' : 'false'};\n` +
+        `const HAS_ALPHA_MAP : bool = ${key.hasAlphaMap ? 'true' : 'false'};\n` +
+        getWgpuMeshPreludeWgsl(skinned, skinning) +
+        body);
+}
+// Classic material uniform: diffuse vec4f (16) + specular vec4f (16) + params vec4f (16) = 48 bytes /
+// 12 floats. params.x = shininess, params.y = alphaCutoff.
+const CLASSIC_UNIFORM_BYTES = 48;
+const CLASSIC_WGSL_BODY = /* wgsl */ `
+struct ClassicMaterial {
+  diffuse : vec4f,   // linear rgba
+  specular : vec4f,  // linear rgb; a unused
+  params : vec4f,    // x = shininess, y = alphaCutoff
+};
+
+@group(2) @binding(0) var<uniform> material : ClassicMaterial;
+@group(2) @binding(1) var diffuseSampler : sampler;
+@group(2) @binding(2) var specularSampler : sampler;
+@group(2) @binding(3) var normalSampler : sampler;
+@group(2) @binding(4) var alphaSampler : sampler;
+@group(2) @binding(5) var diffuseTexture : texture_2d<f32>;
+@group(2) @binding(6) var specularTexture : texture_2d<f32>;
+@group(2) @binding(7) var normalTexture : texture_2d<f32>;
+@group(2) @binding(8) var alphaTexture : texture_2d<f32>;
+
+// The directional shadow inputs (group 3), the shared shadow-sample layout ensureWgpuShadowSampleLayout
+// builds and beginWgpuMeshDraw binds. matrix is the light view-projection (world -> shadow clip);
+// params.x is the enabled flag (0 or 1). The WGSL mirror of scene-gl's u_shadowMap / u_shadowMatrix /
+// u_shadowEnabled and wgpuPbrPrelude's Shadow.
+struct Shadow {
+  matrix : mat4x4f,
+  params : vec4f,   // x = enabled (0 or 1)
+};
+
+@group(3) @binding(0) var<uniform> shadow : Shadow;
+@group(3) @binding(1) var shadowMap : texture_depth_2d;
+@group(3) @binding(2) var shadowSampler : sampler_comparison;
+
+// Directional shadow factor at a world position: 1.0 fully lit, 0.0 fully shadowed, with 3x3 PCF —
+// identical to wgpuPbrPrelude's copy. UV flips Y (WebGPU top-left origin), depthRef remaps GL-convention
+// clip Z (-1..1) into WebGPU's 0..1 range; the comparison sampler ('less-equal') yields "current <=
+// closest" per tap. Fragments outside the shadow frustum, or when no map is bound, read as lit.
+fn sampleDirectionalShadow(worldPos : vec3f) -> f32 {
+  if (shadow.params.x < 0.5) {
+    return 1.0;
+  }
+  let clip = shadow.matrix * vec4f(worldPos, 1.0);
+  let ndc = clip.xyz / clip.w;
+  let uv = vec2f(ndc.x * 0.5 + 0.5, 1.0 - (ndc.y * 0.5 + 0.5));
+  let depthRef = ndc.z * 0.5 + 0.5 - 0.0025;
+  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0 || depthRef > 1.0) {
+    return 1.0;
+  }
+  let texel = 1.0 / vec2f(textureDimensions(shadowMap, 0));
+  var sum = 0.0;
+  for (var x = -1; x <= 1; x = x + 1) {
+    for (var y = -1; y <= 1; y = y + 1) {
+      let offset = vec2f(f32(x), f32(y)) * texel;
+      sum = sum + textureSampleCompareLevel(shadowMap, shadowSampler, uv + offset, depthRef);
+    }
+  }
+  return sum / 9.0;
+}
+
+// Smooth finite-range window over inverse-square falloff. A non-positive inverse range means
+// unlimited range, matching packScene3DLightBlock and the GL classic/PBR preludes.
+fn rangeWindow(dist2 : f32, invSqrRange : f32) -> f32 {
+  if (invSqrRange <= 0.0) {
+    return 1.0;
+  }
+  let factor = clamp(1.0 - dist2 * invSqrRange, 0.0, 1.0);
+  return factor * factor;
+}
+
+// One classic-light contribution shared by directional, point, and spot lights. Keeping the BRDF in
+// one function prevents the positional families from drifting from the directional model.
+fn shadeClassicLight(normal : vec3f, lightDir : vec3f, lightColor : vec3f, diffuseRgb : vec3f,
+                     specularColor : vec3f, worldPosition : vec3f) -> vec3f {
+  let nDotL = max(dot(normal, lightDir), 0.0);
+  var result = diffuseRgb * nDotL * lightColor;
+  if ((LIGHTING_PHONG || LIGHTING_BLINNPHONG) && nDotL > 0.0) {
+    let viewDir = normalize(frame.cameraPosition.xyz - worldPosition);
+    var specAngle = 0.0;
+    if (LIGHTING_PHONG) {
+      specAngle = max(dot(reflect(-lightDir, normal), viewDir), 0.0);
+    } else {
+      specAngle = max(dot(normal, normalize(lightDir + viewDir)), 0.0);
+    }
+    let specular = pow(specAngle, max(material.params.x, 1.0));
+    result = result + specular * specularColor * lightColor;
+  }
+  return result;
+}
+
+@fragment fn fs_main(in : VertexOutput, @builtin(front_facing) isFront : bool) -> @location(0) vec4f {
+  var diffuse = material.diffuse;
+  if (HAS_DIFFUSE_MAP) {
+    let sampled = textureSample(diffuseTexture, diffuseSampler, in.uv);
+    diffuse = vec4f(diffuse.rgb * srgbToLinear(sampled.rgb), diffuse.a * sampled.a);
+  }
+
+  // Dedicated coverage (opacity) map: its green channel is linear data, multiplied into alpha before
+  // the alpha-mask cutoff so 'mask' cutout and 'blend' transparency both see the combined coverage.
+  if (HAS_ALPHA_MAP) {
+    diffuse.a = diffuse.a * textureSample(alphaTexture, alphaSampler, in.uv).g;
+  }
+
+  if (ALPHA_MASK && diffuse.a < material.params.y) {
+    discard;
+  }
+
+  var geometricNormal = normalize(in.worldNormal);
+  // Double-sided materials flip the normal for back faces so both sides shade correctly.
+  if (DOUBLE_SIDED && !isFront) {
+    geometricNormal = -geometricNormal;
+  }
+
+  var normal = geometricNormal;
+  if (HAS_NORMAL_MAP) {
+    let tangent = normalize(in.worldTangent.xyz);
+    let bitangent = cross(geometricNormal, tangent) * in.worldTangent.w;
+    var tangentNormal = textureSample(normalTexture, normalSampler, in.uv).xyz * 2.0 - vec3f(1.0);
+    let tbn = mat3x3f(tangent, bitangent, geometricNormal);
+    normal = normalize(tbn * tangentNormal);
+  }
+
+  // Specular color is resolved here in UNIFORM control flow. WGSL forbids textureSample inside the
+  // per-pixel lighting branch below (it depends on nDotL, a non-uniform value), so the map sample is
+  // hoisted out. It starts at the material specular; when a specular map is present its sampled value
+  // multiplies in just below (an absent map binds a placeholder view and this stays the flat specular).
+  var specularColor = material.specular.rgb;
+  if (HAS_SPECULAR_MAP) {
+    let sampledSpecular = textureSample(specularTexture, specularSampler, in.uv);
+    specularColor = specularColor * srgbToLinear(sampledSpecular.rgb);
+  }
+
+  var radiance = vec3f(0.0);
+
+  // Directional light: -direction is the surface-to-light vector (light travels along direction).
+  // The whole directional contribution (diffuse + specular) is PCF shadow-mapped, mirroring the PBR path;
+  // sampleDirectionalShadow returns 1.0 when no shadow map is bound, so an unshadowed scene is unchanged.
+  if (frame.lightDirection.w > 0.5) {
+    let lightDir = normalize(-frame.lightDirection.xyz);
+    let direct = shadeClassicLight(normal, lightDir, frame.directionalRadiance.rgb, diffuse.rgb,
+                                   specularColor, in.worldPosition);
+    radiance = radiance + direct * sampleDirectionalShadow(in.worldPosition);
+  }
+
+  // Point lights: surface-to-light direction with smooth inverse-square range falloff.
+  let pointCount = u32(frame.punctualCounts.x);
+  for (var point = 0u; point < 4u; point = point + 1u) {
+    if (point >= pointCount) { break; }
+    let toLight = frame.pointLights[point * 2u].xyz - in.worldPosition;
+    let dist2 = dot(toLight, toLight);
+    let lightDir = toLight * inverseSqrt(max(dist2, 1e-8));
+    let atten = rangeWindow(dist2, frame.pointLights[point * 2u + 1u].w) / max(dist2, 1e-4);
+    radiance = radiance + shadeClassicLight(normal, lightDir,
+      frame.pointLights[point * 2u + 1u].xyz * atten, diffuse.rgb, specularColor, in.worldPosition);
+  }
+
+  // Spot lights: point attenuation multiplied by the smooth inner/outer cone window.
+  let spotCount = u32(frame.punctualCounts.y);
+  for (var spot = 0u; spot < 4u; spot = spot + 1u) {
+    if (spot >= spotCount) { break; }
+    let toLight = frame.spotLights[spot * 4u].xyz - in.worldPosition;
+    let dist2 = dot(toLight, toLight);
+    let lightDir = toLight * inverseSqrt(max(dist2, 1e-8));
+    let atten = rangeWindow(dist2, frame.spotLights[spot * 4u + 1u].w) / max(dist2, 1e-4);
+    let cone = smoothstep(frame.spotLights[spot * 4u + 3u].y, frame.spotLights[spot * 4u + 3u].x,
+                          dot(normalize(frame.spotLights[spot * 4u + 2u].xyz), -lightDir));
+    radiance = radiance + shadeClassicLight(normal, lightDir,
+      frame.spotLights[spot * 4u + 1u].xyz * atten * cone, diffuse.rgb, specularColor, in.worldPosition);
+  }
+
+  // Ambient term: flat irradiance over the diffuse albedo.
+  if (frame.ambientRadiance.w > 0.5) {
+    radiance = radiance + diffuse.rgb * frame.ambientRadiance.rgb;
+  }
+
+  // Hemisphere fill: sky/ground gradient blended by the normal's up-axis alignment.
+  let hemisphereCount = u32(frame.punctualCounts.z);
+  for (var hemisphere = 0u; hemisphere < 4u; hemisphere = hemisphere + 1u) {
+    if (hemisphere >= hemisphereCount) { break; }
+    let factor = 0.5 + 0.5 * dot(normal, frame.hemisphereLights[hemisphere * 3u + 2u].xyz);
+    radiance = radiance + mix(frame.hemisphereLights[hemisphere * 3u + 1u].xyz,
+      frame.hemisphereLights[hemisphere * 3u].xyz, factor) * diffuse.rgb;
+  }
+
+  return vec4f(radiance, diffuse.a * in.objectAlpha);
+}
+`;
+const CLASSIC_SHARED_SAMPLER_WGSL_BODY = CLASSIC_WGSL_BODY.replace(`@group(2) @binding(1) var diffuseSampler : sampler;
+@group(2) @binding(2) var specularSampler : sampler;
+@group(2) @binding(3) var normalSampler : sampler;
+@group(2) @binding(4) var alphaSampler : sampler;
+@group(2) @binding(5) var diffuseTexture : texture_2d<f32>;
+@group(2) @binding(6) var specularTexture : texture_2d<f32>;
+@group(2) @binding(7) var normalTexture : texture_2d<f32>;
+@group(2) @binding(8) var alphaTexture : texture_2d<f32>;`, `@group(2) @binding(1) var materialSampler : sampler;
+@group(2) @binding(2) var diffuseTexture : texture_2d<f32>;
+@group(2) @binding(3) var specularTexture : texture_2d<f32>;
+@group(2) @binding(4) var normalTexture : texture_2d<f32>;
+@group(2) @binding(5) var alphaTexture : texture_2d<f32>;`)
+    .replaceAll('diffuseSampler', 'materialSampler')
+    .replaceAll('specularSampler', 'materialSampler')
+    .replaceAll('normalSampler', 'materialSampler')
+    .replaceAll('alphaSampler', 'materialSampler');
+const _scratch = new Float32Array(CLASSIC_UNIFORM_BYTES / 4);
+const _samplerScratch = new Array(4);
+// Reused per-bind resolved-view scratch (diffuse, specular, normal, alpha) so a steady-state re-bind
+// allocates nothing; ensureWgpuPerMapMaterialBinding copies it into the binding only on create/rebuild.
+const _viewScratch = new Array(4);
+//# sourceMappingURL=wgpuClassicPrelude.js.map

package/dist/wgpuClassicPrelude.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuClassicPrelude.js","sourceRoot":"","sources":["../src/wgpuClassicPrelude.ts"],"names":[],"mappings":"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"}

package/dist/wgpuCustomMaterialAbi.d.ts

@@ -0,0 +1,3 @@
+export declare const WGPU_CUSTOM_SHADER_USER_VEC4_CAPACITY = 32;
+export declare const WGPU_CUSTOM_SHADER_TEXTURE_CAPACITY = 8;
+//# sourceMappingURL=wgpuCustomMaterialAbi.d.ts.map

package/dist/wgpuCustomMaterialAbi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuCustomMaterialAbi.d.ts","sourceRoot":"","sources":["../src/wgpuCustomMaterialAbi.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,qCAAqC,KAAK,CAAC;AACxD,eAAO,MAAM,mCAAmC,IAAI,CAAC"}

package/dist/wgpuCustomMaterialAbi.js

@@ -0,0 +1,5 @@
+// Fixed WebGPU custom-material ABI capacities. Every logical scalar/vector uniform consumes one
+// vec4-aligned slot; every texture consumes sampler(binding 2N) + texture(binding 2N+1) in group(3).
+export const WGPU_CUSTOM_SHADER_USER_VEC4_CAPACITY = 32;
+export const WGPU_CUSTOM_SHADER_TEXTURE_CAPACITY = 8;
+//# sourceMappingURL=wgpuCustomMaterialAbi.js.map

package/dist/wgpuCustomMaterialAbi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuCustomMaterialAbi.js","sourceRoot":"","sources":["../src/wgpuCustomMaterialAbi.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAChG,qGAAqG;AACrG,MAAM,CAAC,MAAM,qCAAqC,GAAG,EAAE,CAAC;AACxD,MAAM,CAAC,MAAM,mCAAmC,GAAG,CAAC,CAAC"}

package/dist/wgpuDebugPrelude.d.ts

@@ -0,0 +1,7 @@
+import type { WgpuDebugDefineKey, WgpuDebugPipeline, WgpuRenderState } from '@flighthq/types';
+export declare function bindWgpuDebugSurface(state: WgpuRenderState, pipeline: Readonly<WgpuDebugPipeline>, materialKey: object, near: number, far: number, normalScale: number): GPUBindGroup;
+export declare function buildWgpuDebugDefineKey(key: Readonly<WgpuDebugDefineKey>): string;
+export declare function compileWgpuDebugPipeline(state: WgpuRenderState, key: Readonly<WgpuDebugDefineKey>, format: GPUTextureFormat, blended?: boolean): WgpuDebugPipeline;
+export declare function ensureWgpuDebugPipeline(state: WgpuRenderState, key: Readonly<WgpuDebugDefineKey>, format: GPUTextureFormat): WgpuDebugPipeline;
+export declare function getWgpuDebugModuleSourceForKey(key: Readonly<WgpuDebugDefineKey>): string;
+//# sourceMappingURL=wgpuDebugPrelude.d.ts.map

package/dist/wgpuDebugPrelude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuDebugPrelude.d.ts","sourceRoot":"","sources":["../src/wgpuDebugPrelude.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,eAAe,EAAuB,MAAM,iBAAiB,CAAC;AAgBnH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,eAAe,EACtB,QAAQ,EAAE,QAAQ,CAAC,iBAAiB,CAAC,EACrC,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,GAClB,YAAY,CA8Bd;AAKD,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,QAAQ,CAAC,kBAAkB,CAAC,GAAG,MAAM,CAEjF;AAMD,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,eAAe,EACtB,GAAG,EAAE,QAAQ,CAAC,kBAAkB,CAAC,EACjC,MAAM,EAAE,gBAAgB,EACxB,OAAO,UAAQ,GACd,iBAAiB,CAanB;AAKD,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,eAAe,EACtB,GAAG,EAAE,QAAQ,CAAC,kBAAkB,CAAC,EACjC,MAAM,EAAE,gBAAgB,GACvB,iBAAiB,CAInB;AAKD,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,QAAQ,CAAC,kBAAkB,CAAC,GAAG,MAAM,CAQxF"}