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

package/dist/wgpuDebugPrelude.js

@@ -0,0 +1,133 @@
+import { getWgpuRenderStateRuntime } from '@flighthq/render-wgpu';
+import { createWgpuMeshPipeline, ensureWgpuPlaceholderTextureView, ensureWgpuScene3DPipeline, stashWgpuUvTransform, WGPU_MESH_PRELUDE_WGSL, } from './wgpuMeshPipeline';
+import { getWgpuScene3DRuntime } from './wgpuScene3DRuntime';
+// Ensures (and caches per material reference) the debug Material bind group — a uniform buffer + the
+// shared sampler + the placeholder texture — and rewrites its uniform with this surface's params. The
+// params vec4 packs near/far (depth mode) and normalScale (normal mode) into one buffer shared by both
+// modes; the active mode reads only the lanes it needs. Mirrors scene-gl's bindGlDebugRange /
+// bindGlDebugNormalMap collapsed into one upload. Returns the bind group for the caller to set at
+// group(2). normalScale is uploaded for the normal mode; depth mode passes it through unused.
+export function bindWgpuDebugSurface(state, pipeline, materialKey, near, far, normalScale) {
+    const scene = getWgpuScene3DRuntime(state);
+    let binding = scene.materialBindGroups.get(materialKey);
+    if (binding === undefined) {
+        const stateRuntime = getWgpuRenderStateRuntime(state);
+        const buffer = state.device.createBuffer({
+            size: DEBUG_UNIFORM_BYTES,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
+        const bindGroup = state.device.createBindGroup({
+            layout: pipeline.materialBindGroupLayout,
+            entries: [
+                { binding: 0, resource: { buffer } },
+                { binding: 1, resource: stateRuntime.linearSampler },
+                { binding: 2, resource: ensureWgpuPlaceholderTextureView(state) },
+            ],
+        });
+        binding = { bindGroup, buffer };
+        scene.materialBindGroups.set(materialKey, binding);
+    }
+    _scratch[0] = near;
+    _scratch[1] = far;
+    _scratch[2] = normalScale;
+    _scratch[3] = 0;
+    state.device.queue.writeBuffer(binding.buffer, 0, _scratch.buffer, 0, DEBUG_UNIFORM_BYTES);
+    // The debug views (depth, normal) sample no uv map, so stash identity to keep the shared Draw uniform
+    // authoritative — a prior tiled material's transform must not persist into this bind.
+    stashWgpuUvTransform(state, null);
+    return binding.bindGroup;
+}
+// A short, stable, order-independent string identity for a debug define key, used as the pipeline-cache
+// key (combined with the color format). Two keys with the same flags produce the same string and so
+// share a compiled pipeline. `d-` is depth; `n-` is normal; `nm` is normal + normal map.
+export function buildWgpuDebugDefineKey(key) {
+    return `${key.mode === 'depth' ? 'd' : 'n'}${key.hasNormalMap ? 'm' : '-'}`;
+}
+// Compiles the debug module for a define key and builds the render pipeline for the given color format,
+// with the group(2) material bind-group layout (uniform + sampler + one texture, matching the unlit
+// material layout so the shared placeholder satisfies the texture slot). Pure GPU work — no caching —
+// used by ensureWgpuDebugPipeline.
+export function compileWgpuDebugPipeline(state, key, format, blended = false) {
+    const device = state.device;
+    const module = device.createShaderModule({ code: getWgpuDebugModuleSourceForKey(key) });
+    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, texture: { sampleType: 'float' } },
+        ],
+    });
+    // Debug materials are single-sided in OpenFL parity terms; the scene back-face cull is fine for both
+    // depth and normal visualization (a culled back face contributes neither depth nor normal).
+    return createWgpuMeshPipeline(state, { blended, doubleSided: false, format, materialBindGroupLayout, module });
+}
+// Resolves the debug pipeline for a define key + color format, compiling and caching it on first use
+// through the shared scene pipeline cache under the `debug:` family namespace. Distinct modes (and the
+// normal-map variant) cache as distinct entries.
+export function ensureWgpuDebugPipeline(state, key, format) {
+    return ensureWgpuScene3DPipeline(state, `debug:${format}|${buildWgpuDebugDefineKey(key)}`, (blended) => compileWgpuDebugPipeline(state, key, format, blended));
+}
+// The full WGSL module source for a define key: the const-flag block (MODE discriminator + normal-map
+// flag) + the shared mesh prelude (Frame/Draw/vs_main/srgbToLinear) + the debug material block +
+// fs_main.
+export function getWgpuDebugModuleSourceForKey(key) {
+    return (`const MODE : i32 = ${key.mode === 'depth' ? 'DEPTH_MODE' : 'NORMAL_MODE'};\n` +
+        `const HAS_NORMAL_MAP : bool = ${key.hasNormalMap ? 'true' : 'false'};\n` +
+        DEBUG_MODE_CONSTS_WGSL +
+        WGPU_MESH_PRELUDE_WGSL +
+        DEBUG_WGSL_BODY);
+}
+// Debug material uniform: params vec4f (16) = 16 bytes / 4 floats. params.x = near, params.y = far
+// (depth mode); params.z = normalScale (normal mode, reserved for the future normal-map path).
+const DEBUG_UNIFORM_BYTES = 16;
+// The two mode discriminator values, declared as consts so the MODE const set by the module header
+// reads as a named branch in the fragment body (WGSL has no preprocessor #define).
+const DEBUG_MODE_CONSTS_WGSL = /* wgsl */ `
+const DEPTH_MODE : i32 = 0;
+const NORMAL_MODE : i32 = 1;
+`;
+const DEBUG_WGSL_BODY = /* wgsl */ `
+struct DebugMaterial {
+  params : vec4f,  // x = near, y = far (depth); z = normalScale (normal)
+};
+
+@group(2) @binding(0) var<uniform> material : DebugMaterial;
+@group(2) @binding(1) var materialSampler : sampler;
+@group(2) @binding(2) var normalTexture : texture_2d<f32>;
+
+@fragment fn fs_main(in : VertexOutput, @builtin(front_facing) frontFacing : bool) -> @location(0) vec4f {
+  if (MODE == DEPTH_MODE) {
+    // Linear view-space distance is the perspective w: in.clipPosition is the @builtin(position), whose
+    // .w in the fragment scene2d is 1 / w_clip, so 1 / in.clipPosition.w == w_clip == eye distance. This
+    // is camera-agnostic (no camera near/far needed); map it across the material's [near, far]
+    // visualization window to grayscale [0, 1].
+    let near = material.params.x;
+    let far = material.params.y;
+    let eyeDepth = 1.0 / in.clipPosition.w;
+    let d = clamp((eyeDepth - near) / max(far - near, 1e-6), 0.0, 1.0);
+    return vec4f(vec3f(d), in.objectAlpha);
+  }
+
+  // NORMAL_MODE: visualize the WORLD-space surface normal — the geometric normal carried through
+  // draw.normalMatrix in vs_main. The normal-map branch is gated by HAS_NORMAL_MAP but stays inert on
+  // wgpu until map upload lands (see the prelude note); normalScale is read so the binding is live.
+  var geometricNormal = normalize(in.worldNormal);
+  if (!frontFacing) {
+    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, materialSampler, in.uv).xyz * 2.0 - 1.0;
+    tangentNormal = vec3f(tangentNormal.xy * material.params.z, tangentNormal.z);
+    let tbn = mat3x3f(tangent, bitangent, geometricNormal);
+    normal = normalize(tbn * tangentNormal);
+  }
+
+  return vec4f(normal * 0.5 + 0.5, in.objectAlpha);
+}
+`;
+const _scratch = new Float32Array(DEBUG_UNIFORM_BYTES / 4);
+//# sourceMappingURL=wgpuDebugPrelude.js.map

package/dist/wgpuDebugPrelude.js.map

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

package/dist/wgpuEnvironmentCube.d.ts

@@ -0,0 +1,4 @@
+import type { Environment, ImageResource, WgpuRenderState } from '@flighthq/types';
+export declare function ensureWgpuEnvironmentSourceCube(state: WgpuRenderState, environment: Readonly<Environment>): GPUTextureView | null;
+export declare function updateWgpuEnvironmentCubeFace(state: WgpuRenderState, face: number, image: Readonly<ImageResource>): boolean;
+//# sourceMappingURL=wgpuEnvironmentCube.d.ts.map

package/dist/wgpuEnvironmentCube.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuEnvironmentCube.d.ts","sourceRoot":"","sources":["../src/wgpuEnvironmentCube.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAe,WAAW,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAgBhG,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,eAAe,EACtB,WAAW,EAAE,QAAQ,CAAC,WAAW,CAAC,GACjC,cAAc,GAAG,IAAI,CAyBvB;AAQD,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,eAAe,EACtB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,GAC7B,OAAO,CAKT"}

package/dist/wgpuEnvironmentCube.js

@@ -0,0 +1,66 @@
+import { uploadWgpuTextureImageResource } from '@flighthq/render-wgpu';
+import { getWgpuScene3DRuntime } from './wgpuScene3DRuntime';
+// Uploads an Environment's source radiance cubemap (six ImageResource faces) to a wgpu cube texture,
+// caching it on the scene runtime. Returns null when the environment has no complete cube — all six faces
+// bound with pixels, either a decoded `source` element or raw `data` — which callers treat as "no
+// environment this frame". Each face uploads through whichever representation it carries:
+// copyExternalImageToTexture for a `source`, or queue.writeTexture for a data-only face (a generated
+// Surface, e.g. the skybox's rotateSurface180 path, which never allocates a canvas). The WGSL mirror of
+// scene-gl's ensureGlEnvironmentSourceCube. The upload is keyed by identity: re-uploaded only when the
+// cached view is absent (a changed cube must drop the cache first via destroyWgpuScene3DIbl). The faces are
+// stored sRGB-encoded (rgba8unorm) and decoded to linear by the bake/skybox shaders that sample them,
+// matching scene-gl's sRGB-passthrough convention (the GL path uploads UNSIGNED_BYTE + decodes in-shader).
+// Returns the cube-dimension GPUTextureView the bake + skybox sample. The source cube is a non-GC GPU
+// resource freed by destroyWgpuScene3DIbl.
+export function ensureWgpuEnvironmentSourceCube(state, environment) {
+    const scene = getWgpuScene3DRuntime(state);
+    if (scene.environmentSourceCubeView !== null)
+        return scene.environmentSourceCubeView;
+    const cube = environment.environment;
+    if (cube === null || !hasWgpuCubeFacePixels(cube))
+        return null;
+    // Cube textures must be square; every face shares the +X face's dimensions (a well-formed cube).
+    const size = cube.faces[0].width;
+    const device = state.device;
+    const texture = device.createTexture({
+        size: [size, size, 6],
+        format: ENVIRONMENT_CUBE_FORMAT,
+        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
+    });
+    // Each face uploads into its array layer, in the canonical +X, -X, +Y, -Y, +Z, -Z order (the array-layer
+    // index IS the face index — the wgpu counterpart of GL's CUBE_MAP_POSITIVE_X + face).
+    for (let face = 0; face < 6; face++) {
+        uploadWgpuTextureImageResource(device, texture, [0, 0, face], cube.faces[face]);
+    }
+    const view = texture.createView({ dimension: 'cube' });
+    scene.environmentSourceCube = texture;
+    scene.environmentSourceCubeView = view;
+    return view;
+}
+// Restamps a single face of the already-built source cube in place, uploading whichever representation the
+// image carries (element or generated `data`). The incremental counterpart of the all-six
+// ensureWgpuEnvironmentSourceCube — for dynamic cube content (reflection probes, a live sky face, or a
+// generated data face mixed into loaded ones) without dropping and rebuilding the whole cube. `face` is the
+// CubeFace* index (+X, -X, +Y, -Y, +Z, -Z). Returns false when no cube has been built yet — the caller
+// must call ensureWgpuEnvironmentSourceCube first.
+export function updateWgpuEnvironmentCubeFace(state, face, image) {
+    const texture = getWgpuScene3DRuntime(state).environmentSourceCube;
+    if (texture === null)
+        return false;
+    uploadWgpuTextureImageResource(state.device, texture, [0, 0, face], image);
+    return true;
+}
+// A face is uploadable when it carries pixels in either representation: a decoded `source` element or
+// raw CPU `data` (a generated Surface). A cube is complete only when all six faces are uploadable.
+function hasWgpuCubeFacePixels(cube) {
+    for (let face = 0; face < 6; face++) {
+        const image = cube.faces[face];
+        if (image == null || (image.source == null && image.data == null))
+            return false;
+    }
+    return true;
+}
+// The source radiance cube is stored sRGB-encoded (not rgba8unorm-srgb): the bake/skybox shaders decode it
+// to linear themselves via srgbToLinear, exactly as scene-gl's shaders do, so the two backends agree.
+const ENVIRONMENT_CUBE_FORMAT = 'rgba8unorm';
+//# sourceMappingURL=wgpuEnvironmentCube.js.map

package/dist/wgpuEnvironmentCube.js.map

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

package/dist/wgpuEnvironmentIblBake.d.ts

@@ -0,0 +1,4 @@
+import type { Environment, WgpuRenderState } from '@flighthq/types';
+export declare function bakeWgpuEnvironmentIbl(state: WgpuRenderState, environment: Readonly<Environment>): void;
+export declare function destroyWgpuScene3DIbl(state: WgpuRenderState): void;
+//# sourceMappingURL=wgpuEnvironmentIblBake.d.ts.map

package/dist/wgpuEnvironmentIblBake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wgpuEnvironmentIblBake.d.ts","sourceRoot":"","sources":["../src/wgpuEnvironmentIblBake.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAkB,MAAM,iBAAiB,CAAC;AAkBpF,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,IAAI,CAgCvG;AAOD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAmClE"}