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

package/src/normalWgpuMeshMaterialRenderer.test.ts

@@ -0,0 +1,69 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createNormalMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { NormalMaterialKind } from '@flighthq/types';
+
+import { normalWgpuMeshMaterialRenderer, registerNormalWgpuMaterial } from './normalWgpuMeshMaterialRenderer';
+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: createNormalMaterial(),
+    normalMatrix: createMatrix3(),
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4(),
+  };
+}
+
+describe('normalWgpuMeshMaterialRenderer', () => {
+  it('bind selects the normal pipeline and writes the frame + material uniforms', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    normalWgpuMeshMaterialRenderer.bind(state, createNormalMaterial({ normalScale: 2 }), 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.some((c) => c.name === 'writeBuffer')).toBe(true);
+    expect(fake.calls.filter((c) => c.name === 'setBindGroup').length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('draw issues an indexed draw over the subset after bind', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const proxy = makeProxy();
+    normalWgpuMeshMaterialRenderer.bind(state, proxy.material, NO_LIGHTS, makeCamera());
+    normalWgpuMeshMaterialRenderer.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();
+    normalWgpuMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(fake.calls.some((c) => c.name === 'drawIndexed')).toBe(false);
+  });
+});
+
+describe('registerNormalWgpuMaterial', () => {
+  it('installs the renderer for NormalMaterialKind', () => {
+    const { state } = makeWgpuScene3DState();
+    registerNormalWgpuMaterial(state);
+    expect(getWgpuMeshMaterialRenderer(state, NormalMaterialKind)).toBe(normalWgpuMeshMaterialRenderer);
+  });
+});

package/src/phongWgpuMeshMaterialRenderer.test.ts

@@ -0,0 +1,79 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createPhongMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Matrix3, Matrix4, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { PhongMaterialKind } from '@flighthq/types';
+
+import { phongWgpuMeshMaterialRenderer, registerPhongWgpuMaterial } from './phongWgpuMeshMaterialRenderer';
+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: createPhongMaterial(),
+    normalMatrix: createMatrix3() as Matrix3,
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4() as Matrix4,
+  };
+}
+
+describe('phongWgpuMeshMaterialRenderer', () => {
+  it('bind selects a phong pipeline and binds frame + material groups + uploads uniforms', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    phongWgpuMeshMaterialRenderer.bind(state, createPhongMaterial(), makeLights(), makeCamera());
+
+    const moduleCall = fake.calls.find((c) => c.name === 'createShaderModule');
+    const code = (moduleCall!.args[0] as { code: string }).code;
+    expect(code).toContain('const LIGHTING_PHONG : bool = 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('draw uploads geometry and issues an indexed draw over the subset range', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const proxy = makeProxy();
+    const geometry = createBoxMeshGeometry();
+    phongWgpuMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    phongWgpuMeshMaterialRenderer.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);
+  });
+
+  it('draw is a no-op when bind has not selected a pipeline', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    phongWgpuMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(fake.calls.some((c) => c.name === 'drawIndexed')).toBe(false);
+  });
+});
+
+describe('registerPhongWgpuMaterial', () => {
+  it('installs the renderer for PhongMaterialKind', () => {
+    const { state } = makeWgpuScene3DState();
+    registerPhongWgpuMaterial(state);
+    expect(getWgpuMeshMaterialRenderer(state, PhongMaterialKind)).toBe(phongWgpuMeshMaterialRenderer);
+  });
+});

package/src/prepareWgpuScene3DForwardLights.test.ts

@@ -0,0 +1,84 @@
+import { createCamera3D, setCamera3DViewMatrix4FromLookAt } from '@flighthq/camera';
+import { createPointLight, createSpotLight } from '@flighthq/lighting';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import { addNodeChild } from '@flighthq/node';
+import { prepareScene3DRender } from '@flighthq/render';
+import { createMesh, createNode3D, Node3DKind } from '@flighthq/scene3d';
+import type { Camera3D, Scene3DLightsLike } from '@flighthq/types';
+import { SCENE_LIGHT_POINT_OFFSET } from '@flighthq/types';
+
+import { prepareWgpuScene3DForwardLights } from './prepareWgpuScene3DForwardLights';
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+
+function camera(): Camera3D {
+  const result = createCamera3D({
+    far: 100,
+    near: 0.1,
+    projection: { aspect: 1, fovY: Math.PI / 2, kind: 'perspective' },
+  });
+  setCamera3DViewMatrix4FromLookAt(result, { x: 4, y: 0, z: 20 }, { x: 4, y: 0, z: 0 }, { x: 0, y: 1, z: 0 });
+  return result;
+}
+
+function clusteredLights(): Scene3DLightsLike {
+  return {
+    ambient: null,
+    directional: null,
+    point: [8, 8, 8, 8, 0, 0, 0, 0].map((x, index) =>
+      createPointLight({ position: { x, y: index % 4, z: 0 }, range: -1 }),
+    ),
+  };
+}
+
+describe('prepareWgpuScene3DForwardLights', () => {
+  it('packs independent four-light point and spot budgets', () => {
+    const { state } = makeWgpuScene3DState();
+    const scene = createNode3D(Node3DKind);
+    addNodeChild(scene, createMesh(createBoxMeshGeometry(), []));
+    const lights: Scene3DLightsLike = {
+      ambient: null,
+      directional: null,
+      point: Array.from({ length: 6 }, (_, index) =>
+        createPointLight({ position: { x: index + 1, y: 0, z: 0 }, range: -1 }),
+      ),
+      spot: Array.from({ length: 6 }, (_, index) =>
+        createSpotLight({
+          direction: { x: -1, y: 0, z: 0 },
+          innerConeDegrees: 45,
+          outerConeDegrees: 60,
+          position: { x: index + 1, y: 0, z: 0 },
+          range: -1,
+        }),
+      ),
+    };
+    const block = prepareWgpuScene3DForwardLights(state, prepareScene3DRender(state, scene, camera(), lights), lights)
+      .meshLightBlocks[0];
+    expect(block.pointCount).toBe(4);
+    expect(block.spotCount).toBe(4);
+  });
+
+  it('selects per visible mesh, deduplicates tuples, and reuses scratch', () => {
+    const { state } = makeWgpuScene3DState();
+    const scene = createNode3D(Node3DKind);
+    const nearA = createMesh(createBoxMeshGeometry(), []);
+    const nearB = createMesh(createBoxMeshGeometry(), []);
+    nearB.position.x = 0.1;
+    const far = createMesh(createBoxMeshGeometry(), []);
+    far.position.x = 8;
+    addNodeChild(scene, nearA);
+    addNodeChild(scene, nearB);
+    addNodeChild(scene, far);
+    const lights = clusteredLights();
+    const renderList = prepareScene3DRender(state, scene, camera(), lights);
+    const first = prepareWgpuScene3DForwardLights(state, renderList, lights);
+    const blocks = first.meshLightBlocks;
+
+    expect(first.meshCount).toBe(3);
+    expect(blocks[0]).toBe(blocks[1]);
+    expect(blocks[0]).not.toBe(blocks[2]);
+    expect(blocks[0].data[SCENE_LIGHT_POINT_OFFSET]).toBe(0);
+    expect(blocks[2].data[SCENE_LIGHT_POINT_OFFSET]).toBe(8);
+    expect(prepareWgpuScene3DForwardLights(state, renderList, lights)).toBe(first);
+    expect(first.meshLightBlocks).toBe(blocks);
+  });
+});

package/src/registerStandardPbrWgpuMaterial.test.ts

@@ -0,0 +1,15 @@
+import { StandardPbrMaterialKind } from '@flighthq/types';
+
+import { registerStandardPbrWgpuMaterial } from './registerStandardPbrWgpuMaterial';
+import { standardPbrWgpuMeshMaterialRenderer } from './standardPbrWgpuMeshMaterialRenderer';
+import { getWgpuMeshMaterialRenderer } from './wgpuMeshMaterialRegistry';
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+
+describe('registerStandardPbrWgpuMaterial', () => {
+  it('registers the StandardPbr renderer for StandardPbrMaterialKind', () => {
+    const { state } = makeWgpuScene3DState();
+    expect(getWgpuMeshMaterialRenderer(state, StandardPbrMaterialKind)).toBeNull();
+    registerStandardPbrWgpuMaterial(state);
+    expect(getWgpuMeshMaterialRenderer(state, StandardPbrMaterialKind)).toBe(standardPbrWgpuMeshMaterialRenderer);
+  });
+});

package/src/shadedWgpuMeshMaterialRenderer.test.ts

@@ -0,0 +1,63 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createShadedMaterial } from '@flighthq/shading';
+import type { Scene3DLightBlock } from '@flighthq/types';
+import { ShadedMaterialKind } from '@flighthq/types';
+
+import {
+  getWgpuShadedBaseFlags,
+  registerShadedWgpuMaterial,
+  shadedWgpuMeshMaterialRenderer,
+} from './shadedWgpuMeshMaterialRenderer';
+
+describe('getWgpuShadedBaseFlags', () => {
+  it('resolves the base pipeline flags from a material', () => {
+    const material = createShadedMaterial();
+    material.alphaMode = 'mask';
+    material.doubleSided = true;
+    expect(getWgpuShadedBaseFlags(material)).toEqual({
+      alphaMaskEnabled: true,
+      doubleSided: true,
+      hasDiffuseMap: false,
+      hasNormalMap: false,
+      hasSpecularMap: false,
+    });
+  });
+});
+import { getWgpuMeshMaterialRenderer } from './wgpuMeshMaterialRegistry';
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+
+describe('registerShadedWgpuMaterial', () => {
+  it('installs the renderer for ShadedMaterialKind', () => {
+    const { state } = makeWgpuScene3DState();
+    registerShadedWgpuMaterial(state);
+    expect(getWgpuMeshMaterialRenderer(state, ShadedMaterialKind)).toBe(shadedWgpuMeshMaterialRenderer);
+  });
+});
+
+describe('shadedWgpuMeshMaterialRenderer', () => {
+  it('bind compiles a shaded module and binds frame, material, and sample groups', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const camera = createCamera3D({
+      far: 100,
+      near: 0.1,
+      projection: { aspect: 1, fovY: Math.PI / 3, kind: 'perspective' },
+    });
+    shadedWgpuMeshMaterialRenderer.bind(state, createShadedMaterial(), LIGHTS, camera);
+    const module = fake.calls.find((call) => call.name === 'createShaderModule');
+    expect(module).toBeDefined();
+    expect((module!.args[0] as { code: string }).code).toContain('struct ClassicMaterial');
+    expect((module!.args[0] as { code: string }).code).not.toContain('modifierData');
+    expect(fake.calls.some((call) => call.name === 'setPipeline')).toBe(true);
+    expect(fake.calls.filter((call) => call.name === 'setBindGroup').length).toBeGreaterThanOrEqual(3);
+  });
+});
+
+const LIGHTS: Scene3DLightBlock = {
+  ambientCount: 0,
+  data: new Float32Array(128),
+  directionalCount: 0,
+  hemisphereCount: 0,
+  pointCount: 0,
+  spotCount: 0,
+  version: 1,
+};

package/src/sheenPbrWgpuMeshMaterialRenderer.test.ts

@@ -0,0 +1,87 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createSheenPbrMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Matrix3, Matrix4, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { SheenPbrMaterialKind } from '@flighthq/types';
+
+import { registerSheenPbrWgpuMaterial, sheenPbrWgpuMeshMaterialRenderer } from './sheenPbrWgpuMeshMaterialRenderer';
+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: createSheenPbrMaterial({ sheenColor: 0xffffffff }),
+    normalMatrix: createMatrix3() as Matrix3,
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4() as Matrix4,
+  };
+}
+
+describe('registerSheenPbrWgpuMaterial', () => {
+  it('installs the renderer for SheenPbrMaterialKind', () => {
+    const { state } = makeWgpuScene3DState();
+    registerSheenPbrWgpuMaterial(state);
+    expect(getWgpuMeshMaterialRenderer(state, SheenPbrMaterialKind)).toBe(sheenPbrWgpuMeshMaterialRenderer);
+  });
+});
+
+describe('sheenPbrWgpuMeshMaterialRenderer', () => {
+  it('bind selects a pipeline and binds frame + material groups + uploads uniforms', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    sheenPbrWgpuMeshMaterialRenderer.bind(
+      state,
+      createSheenPbrMaterial({ sheenColor: 0xffffffff }),
+      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 SHEEN extension variant', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    sheenPbrWgpuMeshMaterialRenderer.bind(state, createSheenPbrMaterial(), makeLights(), makeCamera());
+    const moduleCall = fake.calls.find((c) => c.name === 'createShaderModule');
+    const code = (moduleCall!.args[0] as { code: string }).code;
+    expect(code).toContain('const SHEEN : bool = true;');
+  });
+
+  it('draw uploads geometry and issues an indexed draw over the subset range', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const proxy = makeProxy();
+    sheenPbrWgpuMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    sheenPbrWgpuMeshMaterialRenderer.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();
+    sheenPbrWgpuMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(fake.calls.some((c) => c.name === 'drawIndexed')).toBe(false);
+  });
+});

package/src/specularGlossinessPbrWgpuMeshMaterialRenderer.test.ts

@@ -0,0 +1,100 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createSpecularGlossinessPbrMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Matrix3, Matrix4, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { SpecularGlossinessPbrMaterialKind } from '@flighthq/types';
+
+import {
+  registerSpecularGlossinessPbrWgpuMaterial,
+  specularGlossinessPbrWgpuMeshMaterialRenderer,
+} from './specularGlossinessPbrWgpuMeshMaterialRenderer';
+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: createSpecularGlossinessPbrMaterial({ glossiness: 0.7 }),
+    normalMatrix: createMatrix3() as Matrix3,
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4() as Matrix4,
+  };
+}
+
+describe('registerSpecularGlossinessPbrWgpuMaterial', () => {
+  it('installs the renderer for SpecularGlossinessPbrMaterialKind', () => {
+    const { state } = makeWgpuScene3DState();
+    registerSpecularGlossinessPbrWgpuMaterial(state);
+    expect(getWgpuMeshMaterialRenderer(state, SpecularGlossinessPbrMaterialKind)).toBe(
+      specularGlossinessPbrWgpuMeshMaterialRenderer,
+    );
+  });
+});
+
+describe('specularGlossinessPbrWgpuMeshMaterialRenderer', () => {
+  it('bind selects a pipeline and binds frame + material groups + uploads uniforms', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    specularGlossinessPbrWgpuMeshMaterialRenderer.bind(
+      state,
+      createSpecularGlossinessPbrMaterial(),
+      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('drives the base PBR program with no extension flag (CPU spec-gloss conversion)', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    specularGlossinessPbrWgpuMeshMaterialRenderer.bind(
+      state,
+      createSpecularGlossinessPbrMaterial(),
+      makeLights(),
+      makeCamera(),
+    );
+    const moduleCall = fake.calls.find((c) => c.name === 'createShaderModule');
+    const code = (moduleCall!.args[0] as { code: string }).code;
+    expect(code).toContain('const CLEARCOAT : bool = false;');
+    expect(code).toContain('const SHEEN : bool = false;');
+    expect(code).toContain('const SPECULAR_EXT : bool = false;');
+    expect(code).toContain('const TRANSMISSION : bool = false;');
+  });
+
+  it('draw uploads geometry and issues an indexed draw over the subset range', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const proxy = makeProxy();
+    specularGlossinessPbrWgpuMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    specularGlossinessPbrWgpuMeshMaterialRenderer.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();
+    specularGlossinessPbrWgpuMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(fake.calls.some((c) => c.name === 'drawIndexed')).toBe(false);
+  });
+});

package/src/specularPbrWgpuMeshMaterialRenderer.test.ts

@@ -0,0 +1,90 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createSpecularPbrMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Matrix3, Matrix4, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { SpecularPbrMaterialKind } from '@flighthq/types';
+
+import {
+  registerSpecularPbrWgpuMaterial,
+  specularPbrWgpuMeshMaterialRenderer,
+} from './specularPbrWgpuMeshMaterialRenderer';
+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: createSpecularPbrMaterial({ specular: 0.5 }),
+    normalMatrix: createMatrix3() as Matrix3,
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4() as Matrix4,
+  };
+}
+
+describe('registerSpecularPbrWgpuMaterial', () => {
+  it('installs the renderer for SpecularPbrMaterialKind', () => {
+    const { state } = makeWgpuScene3DState();
+    registerSpecularPbrWgpuMaterial(state);
+    expect(getWgpuMeshMaterialRenderer(state, SpecularPbrMaterialKind)).toBe(specularPbrWgpuMeshMaterialRenderer);
+  });
+});
+
+describe('specularPbrWgpuMeshMaterialRenderer', () => {
+  it('bind selects a pipeline and binds frame + material groups + uploads uniforms', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    specularPbrWgpuMeshMaterialRenderer.bind(
+      state,
+      createSpecularPbrMaterial({ specular: 0.5 }),
+      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 SPECULAR_EXT extension variant', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    specularPbrWgpuMeshMaterialRenderer.bind(state, createSpecularPbrMaterial(), makeLights(), makeCamera());
+    const moduleCall = fake.calls.find((c) => c.name === 'createShaderModule');
+    const code = (moduleCall!.args[0] as { code: string }).code;
+    expect(code).toContain('const SPECULAR_EXT : bool = true;');
+  });
+
+  it('draw uploads geometry and issues an indexed draw over the subset range', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const proxy = makeProxy();
+    specularPbrWgpuMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    specularPbrWgpuMeshMaterialRenderer.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();
+    specularPbrWgpuMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(fake.calls.some((c) => c.name === 'drawIndexed')).toBe(false);
+  });
+});