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

package/src/wgpuSkinPalette.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest';
+
+import { getWgpuScene3DRuntime } from './wgpuScene3DRuntime';
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+import {
+  destroyWgpuSkinPalette,
+  ensureWgpuSkinDrawBindGroup,
+  ensureWgpuSkinDrawLayout,
+  registerWgpuGpuSkinning,
+  uploadWgpuSkinPalette,
+} from './wgpuSkinPalette';
+
+describe('destroyWgpuSkinPalette', () => {
+  it('clears every palette and draw-group cache slot', () => {
+    const { state } = makeWgpuScene3DState();
+    uploadWgpuSkinPalette(state, new Float32Array(16));
+    const runtime = getWgpuScene3DRuntime(state);
+    runtime.skinDrawBindGroup = {} as GPUBindGroup;
+
+    destroyWgpuSkinPalette(state);
+
+    expect(runtime.skinPaletteTexture).toBeNull();
+    expect(runtime.skinPaletteView).toBeNull();
+    expect(runtime.skinPaletteCapacity).toBe(0);
+    expect(runtime.skinDrawBindGroup).toBeNull();
+  });
+});
+
+describe('ensureWgpuSkinDrawBindGroup', () => {
+  it('caches the group and rebuilds it only when palette growth replaces its view', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const first = ensureWgpuSkinDrawBindGroup(state, new Float32Array(16));
+    const groupCount = fake.calls.filter((call) => call.name === 'createBindGroup').length;
+    expect(ensureWgpuSkinDrawBindGroup(state, new Float32Array(16))).toBe(first);
+    expect(fake.calls.filter((call) => call.name === 'createBindGroup')).toHaveLength(groupCount);
+
+    ensureWgpuSkinDrawBindGroup(state, new Float32Array(32));
+    expect(fake.calls.filter((call) => call.name === 'createBindGroup')).toHaveLength(groupCount + 1);
+    expect(fake.calls.filter((call) => call.name === 'createTexture')).toHaveLength(2);
+  });
+});
+
+describe('ensureWgpuSkinDrawLayout', () => {
+  it('caches the state-owned skin draw layout', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const layout = ensureWgpuSkinDrawLayout(state);
+    expect(ensureWgpuSkinDrawLayout(state)).toBe(layout);
+    expect(fake.calls.filter((call) => call.name === 'createBindGroupLayout')).toHaveLength(1);
+  });
+});
+
+describe('registerWgpuGpuSkinning', () => {
+  it('installs the opt-in adapter on only the requested render state', () => {
+    const { state } = makeWgpuScene3DState();
+    expect(getWgpuScene3DRuntime(state).skinningAdapter).toBeNull();
+    registerWgpuGpuSkinning(state);
+    expect(getWgpuScene3DRuntime(state).skinningAdapter).not.toBeNull();
+  });
+});
+
+describe('uploadWgpuSkinPalette', () => {
+  it('packs four rgba32float texels per joint into one row', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const joints = new Float32Array(32);
+    const view = uploadWgpuSkinPalette(state, joints);
+    const texture = fake.calls.find((call) => call.name === 'createTexture');
+    const write = fake.calls.find((call) => call.name === 'writeTexture');
+
+    expect(view).toBe(getWgpuScene3DRuntime(state).skinPaletteView);
+    expect(texture?.args[0]).toMatchObject({
+      format: 'rgba32float',
+      size: [8, 1, 1],
+    });
+    expect(write?.args[2]).toEqual({ bytesPerRow: 128 });
+    expect(write?.args[3]).toEqual([8, 1, 1]);
+  });
+
+  it('reuses capacity and grows without a joint-count fallback gate', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    uploadWgpuSkinPalette(state, new Float32Array(16 * 80));
+    uploadWgpuSkinPalette(state, new Float32Array(16 * 40));
+    expect(fake.calls.filter((call) => call.name === 'createTexture')).toHaveLength(1);
+
+    uploadWgpuSkinPalette(state, new Float32Array(16 * 160));
+    expect(fake.calls.filter((call) => call.name === 'createTexture')).toHaveLength(2);
+    expect(getWgpuScene3DRuntime(state).skinPaletteCapacity).toBe(160);
+  });
+});

package/src/wgpuToonPrelude.test.ts

@@ -0,0 +1,93 @@
+import type { LinearColor, WgpuToonDefineKey } from '@flighthq/types';
+
+import { getWgpuScene3DRuntime } from './wgpuScene3DRuntime';
+import { makeWgpuScene3DState, makeWgpuSkinningAdapter } from './wgpuScene3DTestHelper';
+import {
+  bindWgpuToonSurface,
+  buildWgpuToonDefineKey,
+  compileWgpuToonPipeline,
+  ensureWgpuToonPipeline,
+  getWgpuToonModuleSourceForKey,
+} from './wgpuToonPrelude';
+
+const FLAT: WgpuToonDefineKey = { alphaMaskEnabled: false, doubleSided: false, hasBaseColorMap: false, hasRamp: false };
+const COLOR: LinearColor = [0.5, 0.25, 0.1, 1];
+
+describe('bindWgpuToonSurface', () => {
+  it('creates a material bind group once per key and writes its uniform', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const pipeline = compileWgpuToonPipeline(state, FLAT, 'bgra8unorm');
+    const key = {};
+    bindWgpuToonSurface(state, pipeline, key, COLOR, 3, 0.5);
+    const groups = fake.calls.filter((c) => c.name === 'createBindGroup').length;
+    bindWgpuToonSurface(state, pipeline, key, COLOR, 3, 0.5);
+    expect(fake.calls.filter((c) => c.name === 'createBindGroup').length).toBe(groups);
+    expect(fake.calls.some((c) => c.name === 'writeBuffer')).toBe(true);
+  });
+});
+
+describe('buildWgpuToonDefineKey', () => {
+  it('produces distinct stable strings per flag set', () => {
+    expect(buildWgpuToonDefineKey(FLAT)).toBe('----');
+    expect(
+      buildWgpuToonDefineKey({ alphaMaskEnabled: true, doubleSided: true, hasBaseColorMap: true, hasRamp: true }),
+    ).toBe('mdbr');
+  });
+});
+
+describe('compileWgpuToonPipeline', () => {
+  it('compiles a module and builds the pipeline with a 4-entry material layout', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const pipeline = compileWgpuToonPipeline(state, FLAT, 'rgba16float');
+    expect(pipeline.pipeline).toBeDefined();
+    expect(fake.calls.some((c) => c.name === 'createShaderModule')).toBe(true);
+    const matLayout = fake.calls
+      .filter((c) => c.name === 'createBindGroupLayout')
+      .map((c) => c.args[0] as { entries: unknown[] })
+      .find((d) => d.entries.length === 4);
+    expect(matLayout).toBeDefined();
+  });
+
+  it('compiles a cull-none pipeline for a double-sided key', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    compileWgpuToonPipeline(state, { ...FLAT, doubleSided: true }, 'bgra8unorm');
+    const pipelineCall = fake.calls.find((c) => c.name === 'createRenderPipeline');
+    const descriptor = pipelineCall!.args[0] as { primitive: { cullMode: string } };
+    expect(descriptor.primitive.cullMode).toBe('none');
+  });
+});
+
+describe('ensureWgpuToonPipeline', () => {
+  it('caches one pipeline per define key + format under the toon namespace', () => {
+    const { state } = makeWgpuScene3DState();
+    const a = ensureWgpuToonPipeline(state, FLAT, 'bgra8unorm');
+    const b = ensureWgpuToonPipeline(state, FLAT, 'bgra8unorm');
+    expect(a).toBe(b);
+    expect([...getWgpuScene3DRuntime(state).pipelineCache.keys()].some((k) => k.startsWith('toon:'))).toBe(true);
+  });
+});
+
+describe('getWgpuToonModuleSourceForKey', () => {
+  it('emits the feature consts and reads the shared light block', () => {
+    expect(getWgpuToonModuleSourceForKey(FLAT)).toContain('const HAS_RAMP : bool = false');
+    expect(getWgpuToonModuleSourceForKey({ ...FLAT, alphaMaskEnabled: true })).toContain(
+      'const ALPHA_MASK : bool = true',
+    );
+    const source = getWgpuToonModuleSourceForKey(FLAT);
+    expect(source).toContain('struct Frame');
+    expect(source).toContain('frame.directionalRadiance');
+    expect(source).toContain('fn fs_main');
+    expect(source).not.toContain('jointTexture');
+    expect(getWgpuToonModuleSourceForKey(FLAT, true, makeWgpuSkinningAdapter())).toContain('@location(4) joints0');
+  });
+
+  it('declares the group(3) shadow bindings and shadow-maps the banded directional term', () => {
+    for (const key of [FLAT, { ...FLAT, hasRamp: true }]) {
+      const source = getWgpuToonModuleSourceForKey(key);
+      expect(source).toContain('@group(3) @binding(1) var shadowMap : texture_depth_2d;');
+      expect(source).toContain('@group(3) @binding(2) var shadowSampler : sampler_comparison;');
+      expect(source).toContain('direct * sampleDirectionalShadow(in.worldPosition)');
+      expect(source.match(/direct \* sampleDirectionalShadow\(in\.worldPosition\)/g)).toHaveLength(1);
+    }
+  });
+});

package/src/wgpuUnlitPrelude.test.ts

@@ -0,0 +1,102 @@
+import type { LinearColor, VideoTexture, WgpuUnlitDefineKey } from '@flighthq/types';
+
+import { getWgpuScene3DRuntime } from './wgpuScene3DRuntime';
+import { makeWgpuScene3DState, makeWgpuSkinningAdapter } from './wgpuScene3DTestHelper';
+import {
+  bindWgpuUnlitSurface,
+  bindWgpuUnlitVideoSurface,
+  buildWgpuUnlitDefineKey,
+  compileWgpuUnlitPipeline,
+  ensureWgpuUnlitPipeline,
+  getWgpuUnlitModuleSourceForKey,
+} from './wgpuUnlitPrelude';
+
+const FLAT: WgpuUnlitDefineKey = { alphaMaskEnabled: false, doubleSided: false, hasColorMap: false };
+const COLOR: LinearColor = [0.5, 0.25, 0.1, 1];
+
+describe('bindWgpuUnlitSurface', () => {
+  it('creates a material bind group once per key and writes its uniform', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const pipeline = compileWgpuUnlitPipeline(state, FLAT, 'bgra8unorm');
+    const key = {};
+    bindWgpuUnlitSurface(state, pipeline, key, COLOR, 2, 0.5, null);
+    const groups = fake.calls.filter((c) => c.name === 'createBindGroup').length;
+    bindWgpuUnlitSurface(state, pipeline, key, COLOR, 2, 0.5, null);
+    expect(fake.calls.filter((c) => c.name === 'createBindGroup').length).toBe(groups);
+    expect(fake.calls.some((c) => c.name === 'writeBuffer')).toBe(true);
+  });
+});
+
+describe('bindWgpuUnlitVideoSurface', () => {
+  it('uploads the ready video frame into the same unlit material layout', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const pipeline = compileWgpuUnlitPipeline(state, { ...FLAT, hasColorMap: true }, 'bgra8unorm');
+    const video = {
+      frameId: 1,
+      sampler: {
+        anisotropy: 1,
+        magFilter: 'linear',
+        minFilter: 'linear',
+        mipmaps: false,
+        wrapU: 'clamp-to-edge',
+        wrapV: 'clamp-to-edge',
+      },
+      source: {
+        element: { readyState: 4, videoHeight: 120, videoWidth: 160 } as HTMLVideoElement,
+      },
+      flipX: false,
+      flipY: false,
+      uvOffset: { x: 0, y: 0 },
+      uvRotation: 0,
+      uvScale: { x: 1, y: 1 },
+    } as unknown as VideoTexture;
+    bindWgpuUnlitVideoSurface(state, pipeline, {}, COLOR, 1, 0.5, video);
+    expect(fake.calls.some((c) => c.name === 'copyExternalImageToTexture')).toBe(true);
+    expect(fake.calls.some((c) => c.name === 'writeBuffer')).toBe(true);
+  });
+});
+
+describe('buildWgpuUnlitDefineKey', () => {
+  it('produces distinct stable strings per flag set', () => {
+    expect(buildWgpuUnlitDefineKey(FLAT)).toBe('---');
+    expect(buildWgpuUnlitDefineKey({ alphaMaskEnabled: true, doubleSided: true, hasColorMap: true })).toBe('mdc');
+  });
+});
+
+describe('compileWgpuUnlitPipeline', () => {
+  it('compiles a module and builds the pipeline with a 3-entry material layout', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const pipeline = compileWgpuUnlitPipeline(state, FLAT, 'rgba16float');
+    expect(pipeline.pipeline).toBeDefined();
+    expect(fake.calls.some((c) => c.name === 'createShaderModule')).toBe(true);
+    const matLayout = fake.calls
+      .filter((c) => c.name === 'createBindGroupLayout')
+      .map((c) => c.args[0] as { entries: unknown[] })
+      .find((d) => d.entries.length === 3);
+    expect(matLayout).toBeDefined();
+  });
+});
+
+describe('ensureWgpuUnlitPipeline', () => {
+  it('caches one pipeline per define key + format under the unlit namespace', () => {
+    const { state } = makeWgpuScene3DState();
+    const a = ensureWgpuUnlitPipeline(state, FLAT, 'bgra8unorm');
+    const b = ensureWgpuUnlitPipeline(state, FLAT, 'bgra8unorm');
+    expect(a).toBe(b);
+    expect([...getWgpuScene3DRuntime(state).pipelineCache.keys()].some((k) => k.startsWith('unlit:'))).toBe(true);
+  });
+});
+
+describe('getWgpuUnlitModuleSourceForKey', () => {
+  it('emits the feature consts and includes the shared prelude + fs_main', () => {
+    expect(getWgpuUnlitModuleSourceForKey(FLAT)).toContain('const HAS_COLOR_MAP : bool = false');
+    expect(getWgpuUnlitModuleSourceForKey({ ...FLAT, alphaMaskEnabled: true })).toContain(
+      'const ALPHA_MASK : bool = true',
+    );
+    const source = getWgpuUnlitModuleSourceForKey(FLAT);
+    expect(source).toContain('struct Frame');
+    expect(source).toContain('fn fs_main');
+    expect(source).not.toContain('jointTexture');
+    expect(getWgpuUnlitModuleSourceForKey(FLAT, true, makeWgpuSkinningAdapter())).toContain('@location(5) weights0');
+  });
+});

package/src/wgpuWireframePrelude.test.ts

@@ -0,0 +1,54 @@
+import type { LinearColor } from '@flighthq/types';
+
+import { getWgpuScene3DRuntime } from './wgpuScene3DRuntime';
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+import {
+  bindWgpuWireframeColor,
+  compileWgpuWireframePipeline,
+  ensureWgpuWireframePipeline,
+  getWgpuWireframeModuleSource,
+} from './wgpuWireframePrelude';
+
+const COLOR: LinearColor = [1, 0, 0, 1];
+
+describe('bindWgpuWireframeColor', () => {
+  it('creates a color bind group once per key and writes its uniform', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const pipeline = compileWgpuWireframePipeline(state, 'bgra8unorm');
+    const key = {};
+    bindWgpuWireframeColor(state, pipeline, key, COLOR);
+    const groups = fake.calls.filter((c) => c.name === 'createBindGroup').length;
+    bindWgpuWireframeColor(state, pipeline, key, COLOR);
+    expect(fake.calls.filter((c) => c.name === 'createBindGroup').length).toBe(groups);
+    expect(fake.calls.some((c) => c.name === 'writeBuffer')).toBe(true);
+  });
+});
+
+describe('compileWgpuWireframePipeline', () => {
+  it('builds a line-list pipeline with a single-uniform material layout', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const pipeline = compileWgpuWireframePipeline(state, 'rgba16float');
+    expect(pipeline.pipeline).toBeDefined();
+    const pipelineCall = fake.calls.find((c) => c.name === 'createRenderPipeline');
+    expect((pipelineCall!.args[0] as { primitive: { topology: string } }).primitive.topology).toBe('line-list');
+  });
+});
+
+describe('ensureWgpuWireframePipeline', () => {
+  it('caches one pipeline per format under the wireframe namespace', () => {
+    const { state } = makeWgpuScene3DState();
+    const a = ensureWgpuWireframePipeline(state, 'bgra8unorm');
+    const b = ensureWgpuWireframePipeline(state, 'bgra8unorm');
+    expect(a).toBe(b);
+    expect([...getWgpuScene3DRuntime(state).pipelineCache.keys()].some((k) => k.startsWith('wireframe:'))).toBe(true);
+  });
+});
+
+describe('getWgpuWireframeModuleSource', () => {
+  it('includes the shared prelude and a fs_main returning the color', () => {
+    const source = getWgpuWireframeModuleSource();
+    expect(source).toContain('struct Frame');
+    expect(source).toContain('fn fs_main');
+    expect(source).toContain('material.color');
+  });
+});

package/src/wgpuWireframeUpload.test.ts

@@ -0,0 +1,36 @@
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+import { ensureWgpuWireframeUpload } from './wgpuWireframeUpload';
+
+describe('ensureWgpuWireframeUpload', () => {
+  it('builds a line-index buffer sized two indices per triangle edge', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const geometry = createBoxMeshGeometry();
+    const upload = ensureWgpuWireframeUpload(state, geometry);
+    expect(upload).not.toBeNull();
+    expect(upload!.lineIndexBuffer).toBeDefined();
+    expect(upload!.indexFormat === 'uint16' || upload!.indexFormat === 'uint32').toBe(true);
+
+    // An INDEX buffer is created sized for the derived line list (6 indices per triangle).
+    const triangleCount = geometry.indices!.length / 3;
+    const bytesPerIndex = upload!.indexFormat === 'uint32' ? 4 : 2;
+    const lineBufferCreate = fake.calls.find(
+      (c) =>
+        c.name === 'createBuffer' &&
+        ((c.args[0] as { usage: number; size: number }).usage & GPUBufferUsage.INDEX) !== 0 &&
+        (c.args[0] as { size: number }).size === triangleCount * 6 * bytesPerIndex,
+    );
+    expect(lineBufferCreate).toBeDefined();
+  });
+
+  it('returns the cached upload without rebuilding when the version is unchanged', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const geometry = createBoxMeshGeometry();
+    const first = ensureWgpuWireframeUpload(state, geometry);
+    const buffers = fake.calls.filter((c) => c.name === 'createBuffer').length;
+    const second = ensureWgpuWireframeUpload(state, geometry);
+    expect(second).toBe(first);
+    expect(fake.calls.filter((c) => c.name === 'createBuffer').length).toBe(buffers);
+  });
+});

package/src/wireframeWgpuMeshMaterialRenderer.test.ts

@@ -0,0 +1,69 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createWireframeMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { WireframeMaterialKind } from '@flighthq/types';
+
+import { getWgpuMeshMaterialRenderer } from './wgpuMeshMaterialRegistry';
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+import { registerWireframeWgpuMaterial, wireframeWgpuMeshMaterialRenderer } from './wireframeWgpuMeshMaterialRenderer';
+
+function makeCamera(): Camera3D {
+  return createCamera3D({ far: 100, near: 0.1, projection: { aspect: 1, fovY: Math.PI / 3, kind: 'perspective' } });
+}
+
+const NO_LIGHTS: Scene3DLightBlock = {
+  ambientCount: 0,
+  data: new Float32Array(12),
+  directionalCount: 0,
+  hemisphereCount: 0,
+  pointCount: 0,
+  spotCount: 0,
+  version: 1,
+};
+
+function makeProxy(): Scene3DRenderProxy {
+  const geometry = createBoxMeshGeometry();
+  return {
+    material: createWireframeMaterial(),
+    normalMatrix: createMatrix3(),
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4(),
+  };
+}
+
+describe('registerWireframeWgpuMaterial', () => {
+  it('installs the renderer for WireframeMaterialKind', () => {
+    const { state } = makeWgpuScene3DState();
+    registerWireframeWgpuMaterial(state);
+    expect(getWgpuMeshMaterialRenderer(state, WireframeMaterialKind)).toBe(wireframeWgpuMeshMaterialRenderer);
+  });
+});
+
+describe('wireframeWgpuMeshMaterialRenderer', () => {
+  it('bind selects a line-list pipeline and uploads the color', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    wireframeWgpuMeshMaterialRenderer.bind(state, createWireframeMaterial(), NO_LIGHTS, makeCamera());
+    expect(fake.calls.some((c) => c.name === 'setPipeline')).toBe(true);
+    expect(fake.calls.some((c) => c.name === 'writeBuffer')).toBe(true);
+    const pipelineCall = fake.calls.find((c) => c.name === 'createRenderPipeline');
+    expect((pipelineCall!.args[0] as { primitive: { topology: string } }).primitive.topology).toBe('line-list');
+  });
+
+  it('draw issues a line-list indexed draw over the doubled subset range', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const proxy = makeProxy();
+    wireframeWgpuMeshMaterialRenderer.bind(state, proxy.material, NO_LIGHTS, makeCamera());
+    wireframeWgpuMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+    const drawCall = fake.calls.find((c) => c.name === 'drawIndexed');
+    expect(drawCall).toBeDefined();
+    expect(drawCall!.args[0]).toBe(proxy.subset.indexCount * 2);
+  });
+
+  it('draw is a no-op when bind has not selected a pipeline', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    wireframeWgpuMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(fake.calls.some((c) => c.name === 'drawIndexed')).toBe(false);
+  });
+});