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

package/src/standardPbrWgpuMeshMaterialRenderer.test.ts

@@ -0,0 +1,172 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createStandardPbrMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Matrix3, Matrix4, Scene3DLightBlock, Scene3DRenderProxy, Texture } from '@flighthq/types';
+
+import {
+  buildWgpuPbrStandardDefineKey,
+  ensureWgpuPbrMaterialBindGroup,
+  getWgpuPbrMaterialScratch,
+  standardPbrWgpuMeshMaterialRenderer,
+  WGPU_PBR_MATERIAL_UNIFORM_FLOATS,
+  writeWgpuPbrMaterialUniform,
+  writeWgpuPbrStandardBlock,
+} from './standardPbrWgpuMeshMaterialRenderer';
+import { ensureWgpuPbrPipeline } from './wgpuPbrPipelineCache';
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+
+function makeCamera(): Camera3D {
+  return createCamera3D({ far: 100, near: 0.1, projection: { aspect: 1, fovY: Math.PI / 3, kind: 'perspective' } });
+}
+
+function makeLights(): Scene3DLightBlock {
+  const data = new Float32Array(12);
+  data[0] = 0;
+  data[1] = -1;
+  data[2] = 0;
+  data[4] = 1;
+  data[5] = 1;
+  data[6] = 1;
+  data[8] = 0.1;
+  data[9] = 0.1;
+  data[10] = 0.1;
+  return { ambientCount: 1, data, directionalCount: 1, hemisphereCount: 0, pointCount: 0, spotCount: 0, version: 1 };
+}
+
+function makeProxy(): Scene3DRenderProxy {
+  const geometry = createBoxMeshGeometry();
+  return {
+    material: createStandardPbrMaterial(),
+    normalMatrix: createMatrix3() as Matrix3,
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4() as Matrix4,
+  };
+}
+
+describe('buildWgpuPbrStandardDefineKey', () => {
+  it('reads the alpha mode + double-sidedness and leaves every extension flag off', () => {
+    const material = createStandardPbrMaterial();
+    material.alphaMode = 'mask';
+    material.doubleSided = true;
+    const key = buildWgpuPbrStandardDefineKey(material, material);
+    expect(key.alphaMaskEnabled).toBe(true);
+    expect(key.doubleSided).toBe(true);
+    expect(key.clearcoatEnabled).toBe(false);
+    expect(key.transmissionEnabled).toBe(false);
+  });
+
+  it('returns all-false flags for a null surface', () => {
+    const key = buildWgpuPbrStandardDefineKey(null, null);
+    expect(key.alphaMaskEnabled).toBe(false);
+    expect(key.hasBaseColorMap).toBe(false);
+  });
+
+  it('derives the five standard map flags from the material maps that carry an image source', () => {
+    const material = createStandardPbrMaterial();
+    // A texture is "present" only when it carries a GPU-uploadable image source; a structural stub of
+    // exactly that shape is enough to exercise the flag derivation without a real GPU texture upload.
+    const sourced = { image: { source: {} } } as unknown as Texture;
+    material.baseColorMap = sourced;
+    material.metallicRoughnessMap = sourced;
+    const key = buildWgpuPbrStandardDefineKey(material, material);
+    expect(key.hasBaseColorMap).toBe(true);
+    expect(key.hasMetallicRoughnessMap).toBe(true);
+    expect(key.hasNormalMap).toBe(false);
+    expect(key.hasOcclusionMap).toBe(false);
+    expect(key.hasEmissiveMap).toBe(false);
+  });
+});
+
+describe('ensureWgpuPbrMaterialBindGroup', () => {
+  it('creates a material bind group once per key and reuses it', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const pipeline = ensureWgpuPbrPipeline(state, buildWgpuPbrStandardDefineKey(null, null), 'bgra8unorm');
+    const cacheKey = {};
+    const a = ensureWgpuPbrMaterialBindGroup(state, pipeline, cacheKey, null);
+    const groups = fake.calls.filter((c) => c.name === 'createBindGroup').length;
+    const b = ensureWgpuPbrMaterialBindGroup(state, pipeline, cacheKey, null);
+    expect(b).toBe(a);
+    expect(fake.calls.filter((c) => c.name === 'createBindGroup').length).toBe(groups);
+  });
+});
+
+describe('getWgpuPbrMaterialScratch', () => {
+  it('returns the shared 48-float MaterialBlock scratch', () => {
+    expect(getWgpuPbrMaterialScratch().length).toBe(WGPU_PBR_MATERIAL_UNIFORM_FLOATS);
+  });
+});
+
+describe('standardPbrWgpuMeshMaterialRenderer', () => {
+  it('bind selects a pipeline and binds frame + material groups + uploads uniforms', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    standardPbrWgpuMeshMaterialRenderer.bind(state, createStandardPbrMaterial(), makeLights(), makeCamera());
+
+    expect(fake.calls.some((c) => c.name === 'createRenderPipeline')).toBe(true);
+    expect(fake.calls.some((c) => c.name === 'setPipeline')).toBe(true);
+    expect(fake.calls.filter((c) => c.name === 'setBindGroup').length).toBeGreaterThanOrEqual(2);
+    expect(fake.calls.some((c) => c.name === 'writeBuffer')).toBe(true);
+  });
+
+  it('bind compiles a cull-none pipeline for a double-sided material', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const material = createStandardPbrMaterial();
+    material.doubleSided = true;
+    standardPbrWgpuMeshMaterialRenderer.bind(state, material, makeLights(), makeCamera());
+    const pipelineCall = fake.calls.find((c) => c.name === 'createRenderPipeline');
+    const descriptor = pipelineCall!.args[0] as { primitive: { cullMode: string } };
+    expect(descriptor.primitive.cullMode).toBe('none');
+  });
+
+  it('draw uploads geometry and issues an indexed draw over the subset range', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const proxy = makeProxy();
+    const geometry = createBoxMeshGeometry();
+    standardPbrWgpuMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    standardPbrWgpuMeshMaterialRenderer.draw(state, proxy, geometry);
+
+    const drawCall = fake.calls.find((c) => c.name === 'drawIndexed');
+    expect(drawCall).toBeDefined();
+    expect(drawCall!.args[0]).toBe(proxy.subset.indexCount);
+    expect(drawCall!.args[2]).toBe(proxy.subset.indexOffset);
+    expect(fake.calls.some((c) => c.name === 'setIndexBuffer')).toBe(true);
+    expect(fake.calls.some((c) => c.name === 'setVertexBuffer')).toBe(true);
+  });
+
+  it('draw is a no-op when bind has not selected a pipeline', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    standardPbrWgpuMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(fake.calls.some((c) => c.name === 'drawIndexed')).toBe(false);
+  });
+});
+
+describe('WGPU_PBR_MATERIAL_UNIFORM_FLOATS', () => {
+  it('is the 48-float (192-byte) MaterialBlock size', () => {
+    expect(WGPU_PBR_MATERIAL_UNIFORM_FLOATS).toBe(48);
+  });
+});
+
+describe('writeWgpuPbrMaterialUniform', () => {
+  it('writes the scratch into the binding buffer', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const pipeline = ensureWgpuPbrPipeline(state, buildWgpuPbrStandardDefineKey(null, null), 'bgra8unorm');
+    const binding = ensureWgpuPbrMaterialBindGroup(state, pipeline, {}, null);
+    const writes = fake.calls.filter((c) => c.name === 'writeBuffer').length;
+    writeWgpuPbrMaterialUniform(state, binding);
+    expect(fake.calls.filter((c) => c.name === 'writeBuffer').length).toBe(writes + 1);
+  });
+});
+
+describe('writeWgpuPbrStandardBlock', () => {
+  it('packs the base color + alpha cutoff, and uses neutral defaults for a null block', () => {
+    const out = new Float32Array(WGPU_PBR_MATERIAL_UNIFORM_FLOATS);
+    writeWgpuPbrStandardBlock(out, createStandardPbrMaterial({ baseColor: 0xff0000ff }), 0.25);
+    expect(out[0]).toBeGreaterThan(0.9); // red channel ~1 in linear
+    expect(out[12]).toBe(0.25); // alphaCutoff
+
+    const neutral = new Float32Array(WGPU_PBR_MATERIAL_UNIFORM_FLOATS);
+    writeWgpuPbrStandardBlock(neutral, null, 0.5);
+    expect(neutral[0]).toBe(1);
+    expect(neutral[9]).toBe(1); // roughness default
+  });
+});

package/src/subsurfacePbrWgpuMeshMaterialRenderer.test.ts

@@ -0,0 +1,90 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createSubsurfacePbrMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Matrix3, Matrix4, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { SubsurfacePbrMaterialKind } from '@flighthq/types';
+
+import {
+  registerSubsurfacePbrWgpuMaterial,
+  subsurfacePbrWgpuMeshMaterialRenderer,
+} from './subsurfacePbrWgpuMeshMaterialRenderer';
+import { getWgpuMeshMaterialRenderer } from './wgpuMeshMaterialRegistry';
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+
+function makeCamera(): Camera3D {
+  return createCamera3D({ far: 100, near: 0.1, projection: { aspect: 1, fovY: Math.PI / 3, kind: 'perspective' } });
+}
+
+function makeLights(): Scene3DLightBlock {
+  const data = new Float32Array(12);
+  data[1] = -1;
+  data[4] = 1;
+  data[5] = 1;
+  data[6] = 1;
+  data[8] = 0.1;
+  data[9] = 0.1;
+  data[10] = 0.1;
+  return { ambientCount: 1, data, directionalCount: 1, hemisphereCount: 0, pointCount: 0, spotCount: 0, version: 1 };
+}
+
+function makeProxy(): Scene3DRenderProxy {
+  const geometry = createBoxMeshGeometry();
+  return {
+    material: createSubsurfacePbrMaterial({ subsurface: 0.8 }),
+    normalMatrix: createMatrix3() as Matrix3,
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4() as Matrix4,
+  };
+}
+
+describe('registerSubsurfacePbrWgpuMaterial', () => {
+  it('installs the renderer for SubsurfacePbrMaterialKind', () => {
+    const { state } = makeWgpuScene3DState();
+    registerSubsurfacePbrWgpuMaterial(state);
+    expect(getWgpuMeshMaterialRenderer(state, SubsurfacePbrMaterialKind)).toBe(subsurfacePbrWgpuMeshMaterialRenderer);
+  });
+});
+
+describe('subsurfacePbrWgpuMeshMaterialRenderer', () => {
+  it('bind selects a pipeline and binds frame + material groups + uploads uniforms', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    subsurfacePbrWgpuMeshMaterialRenderer.bind(
+      state,
+      createSubsurfacePbrMaterial({ subsurface: 0.8 }),
+      makeLights(),
+      makeCamera(),
+    );
+
+    expect(fake.calls.some((c) => c.name === 'createRenderPipeline')).toBe(true);
+    expect(fake.calls.some((c) => c.name === 'setPipeline')).toBe(true);
+    expect(fake.calls.filter((c) => c.name === 'setBindGroup').length).toBeGreaterThanOrEqual(2);
+    expect(fake.calls.some((c) => c.name === 'writeBuffer')).toBe(true);
+  });
+
+  it('bind compiles the SUBSURFACE extension variant', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    subsurfacePbrWgpuMeshMaterialRenderer.bind(state, createSubsurfacePbrMaterial(), makeLights(), makeCamera());
+    const moduleCall = fake.calls.find((c) => c.name === 'createShaderModule');
+    const code = (moduleCall!.args[0] as { code: string }).code;
+    expect(code).toContain('const SUBSURFACE : bool = true;');
+  });
+
+  it('draw uploads geometry and issues an indexed draw over the subset range', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const proxy = makeProxy();
+    subsurfacePbrWgpuMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    subsurfacePbrWgpuMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+
+    const drawCall = fake.calls.find((c) => c.name === 'drawIndexed');
+    expect(drawCall).toBeDefined();
+    expect(drawCall!.args[0]).toBe(proxy.subset.indexCount);
+    expect(drawCall!.args[2]).toBe(proxy.subset.indexOffset);
+  });
+
+  it('draw is a no-op when bind has not selected a pipeline', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    subsurfacePbrWgpuMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(fake.calls.some((c) => c.name === 'drawIndexed')).toBe(false);
+  });
+});

package/src/toonWgpuMeshMaterialRenderer.test.ts

@@ -0,0 +1,89 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createToonMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Matrix3, Matrix4, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { ToonMaterialKind } from '@flighthq/types';
+
+import { registerToonWgpuMaterial, toonWgpuMeshMaterialRenderer } from './toonWgpuMeshMaterialRenderer';
+import { getWgpuMeshMaterialRenderer } from './wgpuMeshMaterialRegistry';
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+
+function makeCamera(): Camera3D {
+  return createCamera3D({ far: 100, near: 0.1, projection: { aspect: 1, fovY: Math.PI / 3, kind: 'perspective' } });
+}
+
+function makeLights(): Scene3DLightBlock {
+  const data = new Float32Array(12);
+  data[0] = 0;
+  data[1] = -1;
+  data[2] = 0;
+  data[4] = 1;
+  data[5] = 1;
+  data[6] = 1;
+  data[8] = 0.1;
+  data[9] = 0.1;
+  data[10] = 0.1;
+  return { ambientCount: 1, data, directionalCount: 1, hemisphereCount: 0, pointCount: 0, spotCount: 0, version: 1 };
+}
+
+function makeProxy(): Scene3DRenderProxy {
+  const geometry = createBoxMeshGeometry();
+  return {
+    material: createToonMaterial(),
+    normalMatrix: createMatrix3() as Matrix3,
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4() as Matrix4,
+  };
+}
+
+describe('registerToonWgpuMaterial', () => {
+  it('installs the toon renderer for ToonMaterialKind', () => {
+    const { state } = makeWgpuScene3DState();
+    registerToonWgpuMaterial(state);
+    expect(getWgpuMeshMaterialRenderer(state, ToonMaterialKind)).toBe(toonWgpuMeshMaterialRenderer);
+  });
+});
+
+describe('toonWgpuMeshMaterialRenderer', () => {
+  it('bind selects a pipeline and binds frame + material groups + uploads uniforms', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    toonWgpuMeshMaterialRenderer.bind(state, createToonMaterial(), makeLights(), makeCamera());
+
+    expect(fake.calls.some((c) => c.name === 'createRenderPipeline')).toBe(true);
+    expect(fake.calls.some((c) => c.name === 'setPipeline')).toBe(true);
+    expect(fake.calls.filter((c) => c.name === 'setBindGroup').length).toBeGreaterThanOrEqual(2);
+    expect(fake.calls.some((c) => c.name === 'writeBuffer')).toBe(true);
+  });
+
+  it('bind compiles a cull-none pipeline for a double-sided material', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const material = createToonMaterial();
+    material.doubleSided = true;
+    toonWgpuMeshMaterialRenderer.bind(state, material, makeLights(), makeCamera());
+    const pipelineCall = fake.calls.find((c) => c.name === 'createRenderPipeline');
+    const descriptor = pipelineCall!.args[0] as { primitive: { cullMode: string } };
+    expect(descriptor.primitive.cullMode).toBe('none');
+  });
+
+  it('draw uploads geometry and issues an indexed draw over the subset range', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const proxy = makeProxy();
+    const geometry = createBoxMeshGeometry();
+    toonWgpuMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    toonWgpuMeshMaterialRenderer.draw(state, proxy, geometry);
+
+    const drawCall = fake.calls.find((c) => c.name === 'drawIndexed');
+    expect(drawCall).toBeDefined();
+    expect(drawCall!.args[0]).toBe(proxy.subset.indexCount);
+    expect(drawCall!.args[2]).toBe(proxy.subset.indexOffset);
+    expect(fake.calls.some((c) => c.name === 'setIndexBuffer')).toBe(true);
+    expect(fake.calls.some((c) => c.name === 'setVertexBuffer')).toBe(true);
+  });
+
+  it('draw is a no-op when bind has not selected a pipeline', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    toonWgpuMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(fake.calls.some((c) => c.name === 'drawIndexed')).toBe(false);
+  });
+});

package/src/transmissionVolumePbrWgpuMeshMaterialRenderer.test.ts

@@ -0,0 +1,97 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createTransmissionVolumePbrMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Matrix3, Matrix4, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { TransmissionVolumePbrMaterialKind } from '@flighthq/types';
+
+import {
+  registerTransmissionVolumePbrWgpuMaterial,
+  transmissionVolumePbrWgpuMeshMaterialRenderer,
+} from './transmissionVolumePbrWgpuMeshMaterialRenderer';
+import { getWgpuMeshMaterialRenderer } from './wgpuMeshMaterialRegistry';
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+
+function makeCamera(): Camera3D {
+  return createCamera3D({ far: 100, near: 0.1, projection: { aspect: 1, fovY: Math.PI / 3, kind: 'perspective' } });
+}
+
+function makeLights(): Scene3DLightBlock {
+  const data = new Float32Array(12);
+  data[1] = -1;
+  data[4] = 1;
+  data[5] = 1;
+  data[6] = 1;
+  data[8] = 0.1;
+  data[9] = 0.1;
+  data[10] = 0.1;
+  return { ambientCount: 1, data, directionalCount: 1, hemisphereCount: 0, pointCount: 0, spotCount: 0, version: 1 };
+}
+
+function makeProxy(): Scene3DRenderProxy {
+  const geometry = createBoxMeshGeometry();
+  return {
+    material: createTransmissionVolumePbrMaterial({ transmission: 0.9 }),
+    normalMatrix: createMatrix3() as Matrix3,
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4() as Matrix4,
+  };
+}
+
+describe('registerTransmissionVolumePbrWgpuMaterial', () => {
+  it('installs the renderer for TransmissionVolumePbrMaterialKind', () => {
+    const { state } = makeWgpuScene3DState();
+    registerTransmissionVolumePbrWgpuMaterial(state);
+    expect(getWgpuMeshMaterialRenderer(state, TransmissionVolumePbrMaterialKind)).toBe(
+      transmissionVolumePbrWgpuMeshMaterialRenderer,
+    );
+  });
+});
+
+describe('transmissionVolumePbrWgpuMeshMaterialRenderer', () => {
+  it('bind selects a pipeline and binds frame + material groups + uploads uniforms', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    transmissionVolumePbrWgpuMeshMaterialRenderer.bind(
+      state,
+      createTransmissionVolumePbrMaterial({ transmission: 0.9 }),
+      makeLights(),
+      makeCamera(),
+    );
+
+    expect(fake.calls.some((c) => c.name === 'createRenderPipeline')).toBe(true);
+    expect(fake.calls.some((c) => c.name === 'setPipeline')).toBe(true);
+    expect(fake.calls.filter((c) => c.name === 'setBindGroup').length).toBeGreaterThanOrEqual(2);
+    expect(fake.calls.some((c) => c.name === 'writeBuffer')).toBe(true);
+  });
+
+  it('bind compiles the TRANSMISSION extension variant', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    transmissionVolumePbrWgpuMeshMaterialRenderer.bind(
+      state,
+      createTransmissionVolumePbrMaterial(),
+      makeLights(),
+      makeCamera(),
+    );
+    const moduleCall = fake.calls.find((c) => c.name === 'createShaderModule');
+    const code = (moduleCall!.args[0] as { code: string }).code;
+    expect(code).toContain('const TRANSMISSION : bool = true;');
+  });
+
+  it('draw uploads geometry and issues an indexed draw over the subset range', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const proxy = makeProxy();
+    transmissionVolumePbrWgpuMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    transmissionVolumePbrWgpuMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+
+    const drawCall = fake.calls.find((c) => c.name === 'drawIndexed');
+    expect(drawCall).toBeDefined();
+    expect(drawCall!.args[0]).toBe(proxy.subset.indexCount);
+    expect(drawCall!.args[2]).toBe(proxy.subset.indexOffset);
+  });
+
+  it('draw is a no-op when bind has not selected a pipeline', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    transmissionVolumePbrWgpuMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(fake.calls.some((c) => c.name === 'drawIndexed')).toBe(false);
+  });
+});

package/src/unlitWgpuMeshMaterialRenderer.test.ts

@@ -0,0 +1,94 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createUnlitMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Scene3DLightBlock, Scene3DRenderProxy, VideoTexture } from '@flighthq/types';
+import { UnlitMaterialKind } from '@flighthq/types';
+
+import { registerUnlitWgpuMaterial, unlitWgpuMeshMaterialRenderer } from './unlitWgpuMeshMaterialRenderer';
+import { getWgpuMeshMaterialRenderer } from './wgpuMeshMaterialRegistry';
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+
+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: createUnlitMaterial(),
+    normalMatrix: createMatrix3(),
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4(),
+  };
+}
+
+describe('registerUnlitWgpuMaterial', () => {
+  it('installs the renderer for UnlitMaterialKind', () => {
+    const { state } = makeWgpuScene3DState();
+    registerUnlitWgpuMaterial(state);
+    expect(getWgpuMeshMaterialRenderer(state, UnlitMaterialKind)).toBe(unlitWgpuMeshMaterialRenderer);
+  });
+});
+
+describe('unlitWgpuMeshMaterialRenderer', () => {
+  it('bind selects a pipeline and binds the frame + material groups', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    unlitWgpuMeshMaterialRenderer.bind(state, createUnlitMaterial(), NO_LIGHTS, makeCamera());
+    expect(fake.calls.some((c) => c.name === 'createRenderPipeline')).toBe(true);
+    expect(fake.calls.some((c) => c.name === 'setPipeline')).toBe(true);
+    expect(fake.calls.filter((c) => c.name === 'setBindGroup').length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('uploads a ready dynamic video map into the color-map slot', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const material = createUnlitMaterial();
+    material.baseColorVideoMap = {
+      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;
+    unlitWgpuMeshMaterialRenderer.bind(state, material, NO_LIGHTS, makeCamera());
+    expect(fake.calls.some((c) => c.name === 'copyExternalImageToTexture')).toBe(true);
+  });
+
+  it('draw issues an indexed draw over the subset after bind', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const proxy = makeProxy();
+    unlitWgpuMeshMaterialRenderer.bind(state, proxy.material, NO_LIGHTS, makeCamera());
+    unlitWgpuMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+    const drawCall = fake.calls.find((c) => c.name === 'drawIndexed');
+    expect(drawCall).toBeDefined();
+    expect(drawCall!.args[0]).toBe(proxy.subset.indexCount);
+  });
+
+  it('draw is a no-op when bind has not selected a pipeline', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    unlitWgpuMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(fake.calls.some((c) => c.name === 'drawIndexed')).toBe(false);
+  });
+});

package/src/vertexColorWgpuMeshMaterialRenderer.test.ts

@@ -0,0 +1,62 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createVertexColorMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { VertexColorMaterialKind } from '@flighthq/types';
+
+import {
+  registerVertexColorWgpuMaterial,
+  vertexColorWgpuMeshMaterialRenderer,
+} from './vertexColorWgpuMeshMaterialRenderer';
+import { getWgpuMeshMaterialRenderer } from './wgpuMeshMaterialRegistry';
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+
+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: createVertexColorMaterial(),
+    normalMatrix: createMatrix3(),
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4(),
+  };
+}
+
+describe('registerVertexColorWgpuMaterial', () => {
+  it('installs the renderer for VertexColorMaterialKind', () => {
+    const { state } = makeWgpuScene3DState();
+    registerVertexColorWgpuMaterial(state);
+    expect(getWgpuMeshMaterialRenderer(state, VertexColorMaterialKind)).toBe(vertexColorWgpuMeshMaterialRenderer);
+  });
+});
+
+describe('vertexColorWgpuMeshMaterialRenderer', () => {
+  it('bind selects a pipeline and uploads the tint', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    vertexColorWgpuMeshMaterialRenderer.bind(state, createVertexColorMaterial(), NO_LIGHTS, makeCamera());
+    expect(fake.calls.some((c) => c.name === 'setPipeline')).toBe(true);
+    expect(fake.calls.some((c) => c.name === 'writeBuffer')).toBe(true);
+  });
+
+  it('draw issues an indexed draw over the subset after bind', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const proxy = makeProxy();
+    vertexColorWgpuMeshMaterialRenderer.bind(state, proxy.material, NO_LIGHTS, makeCamera());
+    vertexColorWgpuMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+    expect(fake.calls.some((c) => c.name === 'drawIndexed')).toBe(true);
+  });
+});