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

package/src/sheenPbrGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,83 @@
+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 { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { getGlScene3DRuntime } from './glScene3DRuntime';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import { registerSheenPbrGlMaterial, sheenPbrGlMeshMaterialRenderer } from './sheenPbrGlMeshMaterialRenderer';
+
+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(),
+    normalMatrix: createMatrix3() as Matrix3,
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4() as Matrix4,
+  };
+}
+
+describe('registerSheenPbrGlMaterial', () => {
+  it('installs the renderer for SheenPbrMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerSheenPbrGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, SheenPbrMaterialKind)).toBe(sheenPbrGlMeshMaterialRenderer);
+  });
+});
+
+describe('sheenPbrGlMeshMaterialRenderer', () => {
+  it('bind uploads the light block, standard block, and sheen uniforms', () => {
+    const { state, gl } = makeGlScene3DState();
+    sheenPbrGlMeshMaterialRenderer.bind(
+      state,
+      createSheenPbrMaterial({ sheenColor: 0x80604000 }),
+      makeLights(),
+      makeCamera(),
+    );
+    expect(gl.calls.some((c) => c.name === 'useProgram')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform4f')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform3f')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniformMatrix4fv')).toBe(true);
+  });
+
+  it('caches the sheen program under the pbr: namespace', () => {
+    const { state } = makeGlScene3DState();
+    sheenPbrGlMeshMaterialRenderer.bind(state, createSheenPbrMaterial(), makeLights(), makeCamera());
+    const cache = getGlScene3DRuntime(state).programCache;
+    expect(cache.size).toBe(1);
+    expect([...cache.keys()][0].startsWith('pbr:')).toBe(true);
+  });
+
+  it('draw issues an indexed draw after bind', () => {
+    const { state, gl } = makeGlScene3DState();
+    const proxy = makeProxy();
+    sheenPbrGlMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    sheenPbrGlMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(true);
+  });
+
+  it('draw is a no-op before bind', () => {
+    const { state, gl } = makeGlScene3DState();
+    sheenPbrGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+});

package/src/specularGlossinessPbrGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,96 @@
+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 { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { getGlScene3DRuntime } from './glScene3DRuntime';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import {
+  registerSpecularGlossinessPbrGlMaterial,
+  specularGlossinessPbrGlMeshMaterialRenderer,
+} from './specularGlossinessPbrGlMeshMaterialRenderer';
+
+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(),
+    normalMatrix: createMatrix3() as Matrix3,
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4() as Matrix4,
+  };
+}
+
+describe('registerSpecularGlossinessPbrGlMaterial', () => {
+  it('installs the renderer for SpecularGlossinessPbrMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerSpecularGlossinessPbrGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, SpecularGlossinessPbrMaterialKind)).toBe(
+      specularGlossinessPbrGlMeshMaterialRenderer,
+    );
+  });
+});
+
+describe('specularGlossinessPbrGlMeshMaterialRenderer', () => {
+  it('bind converts spec-gloss to a standard block and uploads it through the base PBR program', () => {
+    const { state, gl } = makeGlScene3DState();
+    specularGlossinessPbrGlMeshMaterialRenderer.bind(
+      state,
+      createSpecularGlossinessPbrMaterial({ diffuse: 0xc08040ff, glossiness: 0.7, specular: 0x404040ff }),
+      makeLights(),
+      makeCamera(),
+    );
+    expect(gl.calls.some((c) => c.name === 'useProgram')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform4f')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniformMatrix4fv')).toBe(true);
+  });
+
+  it('binds the base PBR program (no extension define) under the pbr: namespace', () => {
+    const { state } = makeGlScene3DState();
+    specularGlossinessPbrGlMeshMaterialRenderer.bind(
+      state,
+      createSpecularGlossinessPbrMaterial(),
+      makeLights(),
+      makeCamera(),
+    );
+    const cache = getGlScene3DRuntime(state).programCache;
+    expect(cache.size).toBe(1);
+    const key = [...cache.keys()][0];
+    expect(key.startsWith('pbr:')).toBe(true);
+    // The extension half of the key (after ':') is all dashes — no extension lobe enabled, and the
+    // trailing dash is the (unset) skin flag.
+    expect(key.split(':')[2]).toBe('--------');
+  });
+
+  it('draw issues an indexed draw after bind', () => {
+    const { state, gl } = makeGlScene3DState();
+    const proxy = makeProxy();
+    specularGlossinessPbrGlMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    specularGlossinessPbrGlMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(true);
+  });
+
+  it('draw is a no-op before bind', () => {
+    const { state, gl } = makeGlScene3DState();
+    specularGlossinessPbrGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+});

package/src/specularPbrGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,83 @@
+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 { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { getGlScene3DRuntime } from './glScene3DRuntime';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import { registerSpecularPbrGlMaterial, specularPbrGlMeshMaterialRenderer } from './specularPbrGlMeshMaterialRenderer';
+
+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(),
+    normalMatrix: createMatrix3() as Matrix3,
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4() as Matrix4,
+  };
+}
+
+describe('registerSpecularPbrGlMaterial', () => {
+  it('installs the renderer for SpecularPbrMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerSpecularPbrGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, SpecularPbrMaterialKind)).toBe(specularPbrGlMeshMaterialRenderer);
+  });
+});
+
+describe('specularPbrGlMeshMaterialRenderer', () => {
+  it('bind uploads the light block, standard block, and specular uniforms', () => {
+    const { state, gl } = makeGlScene3DState();
+    specularPbrGlMeshMaterialRenderer.bind(
+      state,
+      createSpecularPbrMaterial({ specular: 0.8, specularColor: 0x80a0c000 }),
+      makeLights(),
+      makeCamera(),
+    );
+    expect(gl.calls.some((c) => c.name === 'useProgram')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform4f')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform3f')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniformMatrix4fv')).toBe(true);
+  });
+
+  it('caches the specular program under the pbr: namespace', () => {
+    const { state } = makeGlScene3DState();
+    specularPbrGlMeshMaterialRenderer.bind(state, createSpecularPbrMaterial(), makeLights(), makeCamera());
+    const cache = getGlScene3DRuntime(state).programCache;
+    expect(cache.size).toBe(1);
+    expect([...cache.keys()][0].startsWith('pbr:')).toBe(true);
+  });
+
+  it('draw issues an indexed draw after bind', () => {
+    const { state, gl } = makeGlScene3DState();
+    const proxy = makeProxy();
+    specularPbrGlMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    specularPbrGlMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(true);
+  });
+
+  it('draw is a no-op before bind', () => {
+    const { state, gl } = makeGlScene3DState();
+    specularPbrGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+});

package/src/standardPbrGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,88 @@
+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 } from '@flighthq/types';
+
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import { standardPbrGlMeshMaterialRenderer } from './standardPbrGlMeshMaterialRenderer';
+
+function makeCamera(): Camera3D {
+  return createCamera3D({ far: 100, near: 0.1, projection: { aspect: 1, fovY: Math.PI / 3, kind: 'perspective' } });
+}
+
+function makeLights(): Scene3DLightBlock {
+  // Directional { dir.xyz @0, _pad, radiance.rgb @4, _pad } + ambient { radiance.rgb @8 }.
+  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('standardPbrGlMeshMaterialRenderer', () => {
+  it('bind selects a program, sets depth/cull state, and uploads camera + light + material uniforms', () => {
+    const { state, gl } = makeGlScene3DState();
+    standardPbrGlMeshMaterialRenderer.bind(state, createStandardPbrMaterial(), makeLights(), makeCamera());
+
+    expect(gl.calls.some((c) => c.name === 'useProgram')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'enable' && c.args[0] === gl.DEPTH_TEST)).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'depthFunc' && c.args[0] === gl.LESS)).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'enable' && c.args[0] === gl.CULL_FACE)).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniformMatrix4fv')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform4f')).toBe(true);
+  });
+
+  it('bind disables back-face culling for a double-sided material', () => {
+    const { state, gl } = makeGlScene3DState();
+    const material = createStandardPbrMaterial();
+    material.doubleSided = true;
+    standardPbrGlMeshMaterialRenderer.bind(state, material, makeLights(), makeCamera());
+    expect(gl.calls.some((c) => c.name === 'disable' && c.args[0] === gl.CULL_FACE)).toBe(true);
+  });
+
+  it('draw uploads geometry and issues an indexed draw over the subset range', () => {
+    const { state, gl } = makeGlScene3DState();
+    const proxy = makeProxy();
+    const geometry = createBoxMeshGeometry();
+    standardPbrGlMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    standardPbrGlMeshMaterialRenderer.draw(state, proxy, geometry);
+
+    const drawCall = gl.calls.find((c) => c.name === 'drawElements');
+    expect(drawCall).toBeDefined();
+    expect(drawCall!.args[1]).toBe(proxy.subset.indexCount);
+    expect(gl.calls.some((c) => c.name === 'uniformMatrix3fv')).toBe(true);
+  });
+
+  it('draw is a no-op when bind has not selected a program', () => {
+    const { state, gl } = makeGlScene3DState();
+    standardPbrGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+
+  it('bind uploads the full standard block including occlusion strength and emissive', () => {
+    const { state, gl } = makeGlScene3DState();
+    const material = createStandardPbrMaterial({ metallic: 0.25, occlusionStrength: 0.7, roughness: 0.4 });
+    standardPbrGlMeshMaterialRenderer.bind(state, material, makeLights(), makeCamera());
+    // The standard block uploads metallic + roughness + normalScale + emissiveStrength +
+    // occlusionStrength as uniform1f, so at least five scalar uploads land.
+    expect(gl.calls.filter((c) => c.name === 'uniform1f').length).toBeGreaterThanOrEqual(5);
+    expect(gl.calls.some((c) => c.name === 'uniform3f')).toBe(true);
+  });
+});

package/src/subsurfacePbrGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,86 @@
+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 { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { getGlScene3DRuntime } from './glScene3DRuntime';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import {
+  registerSubsurfacePbrGlMaterial,
+  subsurfacePbrGlMeshMaterialRenderer,
+} from './subsurfacePbrGlMeshMaterialRenderer';
+
+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(),
+    normalMatrix: createMatrix3() as Matrix3,
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4() as Matrix4,
+  };
+}
+
+describe('registerSubsurfacePbrGlMaterial', () => {
+  it('installs the renderer for SubsurfacePbrMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerSubsurfacePbrGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, SubsurfacePbrMaterialKind)).toBe(subsurfacePbrGlMeshMaterialRenderer);
+  });
+});
+
+describe('subsurfacePbrGlMeshMaterialRenderer', () => {
+  it('bind uploads the light block, standard block, and subsurface uniforms', () => {
+    const { state, gl } = makeGlScene3DState();
+    subsurfacePbrGlMeshMaterialRenderer.bind(
+      state,
+      createSubsurfacePbrMaterial({ subsurface: 0.6, subsurfaceColor: 0xc06040ff, thickness: 0.3 }),
+      makeLights(),
+      makeCamera(),
+    );
+    expect(gl.calls.some((c) => c.name === 'useProgram')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform4f')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform3f')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniformMatrix4fv')).toBe(true);
+  });
+
+  it('caches the subsurface program under the pbr: namespace', () => {
+    const { state } = makeGlScene3DState();
+    subsurfacePbrGlMeshMaterialRenderer.bind(state, createSubsurfacePbrMaterial(), makeLights(), makeCamera());
+    const cache = getGlScene3DRuntime(state).programCache;
+    expect(cache.size).toBe(1);
+    expect([...cache.keys()][0].startsWith('pbr:')).toBe(true);
+  });
+
+  it('draw issues an indexed draw after bind', () => {
+    const { state, gl } = makeGlScene3DState();
+    const proxy = makeProxy();
+    subsurfacePbrGlMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    subsurfacePbrGlMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(true);
+  });
+
+  it('draw is a no-op before bind', () => {
+    const { state, gl } = makeGlScene3DState();
+    subsurfacePbrGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+});

package/src/toonGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,92 @@
+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 { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import { registerToonGlMaterial, toonGlMeshMaterialRenderer } from './toonGlMeshMaterialRenderer';
+
+function makeCamera(): Camera3D {
+  return createCamera3D({ far: 100, near: 0.1, projection: { aspect: 1, fovY: Math.PI / 3, kind: 'perspective' } });
+}
+
+function makeLights(): Scene3DLightBlock {
+  // Directional { dir.xyz @0, _pad, radiance.rgb @4, _pad } + ambient { radiance.rgb @8 }.
+  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('registerToonGlMaterial', () => {
+  it('installs the renderer for ToonMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerToonGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, ToonMaterialKind)).toBe(toonGlMeshMaterialRenderer);
+  });
+});
+
+describe('toonGlMeshMaterialRenderer', () => {
+  it('bind selects a program, sets depth/cull state, and uploads camera + light block + base color', () => {
+    const { state, gl } = makeGlScene3DState();
+    toonGlMeshMaterialRenderer.bind(state, createToonMaterial(), makeLights(), makeCamera());
+
+    expect(gl.calls.some((c) => c.name === 'useProgram')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'enable' && c.args[0] === gl.DEPTH_TEST)).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'depthFunc' && c.args[0] === gl.LESS)).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'enable' && c.args[0] === gl.CULL_FACE)).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniformMatrix4fv')).toBe(true);
+    // Light block: directional + directional-radiance (uniform4f x2), ambient (uniform3f + camera
+    // position uniform3f), the two count gates (uniform1f), plus the base color (uniform4f).
+    expect(gl.calls.filter((c) => c.name === 'uniform4f').length).toBeGreaterThanOrEqual(3);
+    expect(gl.calls.filter((c) => c.name === 'uniform3f').length).toBeGreaterThanOrEqual(2);
+    expect(gl.calls.filter((c) => c.name === 'uniform1f').length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('bind disables back-face culling for a double-sided material', () => {
+    const { state, gl } = makeGlScene3DState();
+    const material = createToonMaterial();
+    material.doubleSided = true;
+    toonGlMeshMaterialRenderer.bind(state, material, makeLights(), makeCamera());
+    expect(gl.calls.some((c) => c.name === 'disable' && c.args[0] === gl.CULL_FACE)).toBe(true);
+  });
+
+  it('draw uploads geometry and issues an indexed draw over the subset range', () => {
+    const { state, gl } = makeGlScene3DState();
+    const proxy = makeProxy();
+    const geometry = createBoxMeshGeometry();
+    toonGlMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    toonGlMeshMaterialRenderer.draw(state, proxy, geometry);
+
+    const drawCall = gl.calls.find((c) => c.name === 'drawElements');
+    expect(drawCall).toBeDefined();
+    expect(drawCall!.args[1]).toBe(proxy.subset.indexCount);
+    expect(gl.calls.some((c) => c.name === 'uniformMatrix3fv')).toBe(true);
+  });
+
+  it('draw is a no-op when bind has not selected a program', () => {
+    const { state, gl } = makeGlScene3DState();
+    toonGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+});

package/src/transmissionVolumePbrGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,93 @@
+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 { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { getGlScene3DRuntime } from './glScene3DRuntime';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import {
+  registerTransmissionVolumePbrGlMaterial,
+  transmissionVolumePbrGlMeshMaterialRenderer,
+} from './transmissionVolumePbrGlMeshMaterialRenderer';
+
+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(),
+    normalMatrix: createMatrix3() as Matrix3,
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4() as Matrix4,
+  };
+}
+
+describe('registerTransmissionVolumePbrGlMaterial', () => {
+  it('installs the renderer for TransmissionVolumePbrMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerTransmissionVolumePbrGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, TransmissionVolumePbrMaterialKind)).toBe(
+      transmissionVolumePbrGlMeshMaterialRenderer,
+    );
+  });
+});
+
+describe('transmissionVolumePbrGlMeshMaterialRenderer', () => {
+  it('bind uploads the light block, standard block, and transmission uniforms', () => {
+    const { state, gl } = makeGlScene3DState();
+    transmissionVolumePbrGlMeshMaterialRenderer.bind(
+      state,
+      createTransmissionVolumePbrMaterial({ attenuationColor: 0x80c0ffff, transmission: 0.9 }),
+      makeLights(),
+      makeCamera(),
+    );
+    expect(gl.calls.some((c) => c.name === 'useProgram')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform4f')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform3f')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniformMatrix4fv')).toBe(true);
+  });
+
+  it('caches the transmission program under the pbr: namespace', () => {
+    const { state } = makeGlScene3DState();
+    transmissionVolumePbrGlMeshMaterialRenderer.bind(
+      state,
+      createTransmissionVolumePbrMaterial(),
+      makeLights(),
+      makeCamera(),
+    );
+    const cache = getGlScene3DRuntime(state).programCache;
+    expect(cache.size).toBe(1);
+    expect([...cache.keys()][0].startsWith('pbr:')).toBe(true);
+  });
+
+  it('draw issues an indexed draw after bind', () => {
+    const { state, gl } = makeGlScene3DState();
+    const proxy = makeProxy();
+    transmissionVolumePbrGlMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    transmissionVolumePbrGlMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(true);
+  });
+
+  it('draw is a no-op before bind', () => {
+    const { state, gl } = makeGlScene3DState();
+    transmissionVolumePbrGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+});