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

package/src/lambertGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,92 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createLambertMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { LambertMaterialKind } from '@flighthq/types';
+
+import { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { getGlScene3DRuntime } from './glScene3DRuntime';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import { lambertGlMeshMaterialRenderer, registerLambertGlMaterial } from './lambertGlMeshMaterialRenderer';
+
+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[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: createLambertMaterial(),
+    normalMatrix: createMatrix3(),
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4(),
+  };
+}
+
+describe('lambertGlMeshMaterialRenderer', () => {
+  it('bind selects a program, sets depth/cull, and uploads light block + diffuse color', () => {
+    const { state, gl } = makeGlScene3DState();
+    lambertGlMeshMaterialRenderer.bind(state, createLambertMaterial(), 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 === 'enable' && c.args[0] === gl.CULL_FACE)).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniformMatrix4fv')).toBe(true);
+    // The light block uploads two vec4 (directional + radiance) and the diffuse color adds a third.
+    expect(gl.calls.filter((c) => c.name === 'uniform4f').length).toBeGreaterThanOrEqual(3);
+  });
+
+  it('bind caches the program under the classic namespace with a lambert key', () => {
+    const { state } = makeGlScene3DState();
+    lambertGlMeshMaterialRenderer.bind(state, createLambertMaterial(), makeLights(), makeCamera());
+    const keys = [...getGlScene3DRuntime(state).programCache.keys()];
+    expect(keys.some((k) => k.startsWith('classic:l'))).toBe(true);
+  });
+
+  it('bind disables back-face culling for a double-sided material', () => {
+    const { state, gl } = makeGlScene3DState();
+    const material = createLambertMaterial();
+    material.doubleSided = true;
+    lambertGlMeshMaterialRenderer.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();
+    lambertGlMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    lambertGlMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+
+    const drawCall = gl.calls.find((c) => c.name === 'drawElements');
+    expect(drawCall).toBeDefined();
+    expect(drawCall!.args[1]).toBe(proxy.subset.indexCount);
+  });
+
+  it('draw is a no-op when bind has not selected a program', () => {
+    const { state, gl } = makeGlScene3DState();
+    lambertGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+});
+
+describe('registerLambertGlMaterial', () => {
+  it('installs the renderer for LambertMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerLambertGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, LambertMaterialKind)).toBe(lambertGlMeshMaterialRenderer);
+  });
+});

package/src/matcapGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,70 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createMatcapMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { MatcapMaterialKind } from '@flighthq/types';
+
+import { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import { matcapGlMeshMaterialRenderer, registerMatcapGlMaterial } from './matcapGlMeshMaterialRenderer';
+
+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: createMatcapMaterial(),
+    normalMatrix: createMatrix3(),
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4(),
+  };
+}
+
+describe('matcapGlMeshMaterialRenderer', () => {
+  it('bind selects a program, sets depth/cull, view-projection, u_view, and the tint uniform', () => {
+    const { state, gl } = makeGlScene3DState();
+    matcapGlMeshMaterialRenderer.bind(state, createMatcapMaterial(), NO_LIGHTS, 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);
+    // The view-projection and u_view are both mat4 uploads.
+    expect(gl.calls.filter((c) => c.name === 'uniformMatrix4fv').length).toBeGreaterThanOrEqual(2);
+    expect(gl.calls.some((c) => c.name === 'uniform4f')).toBe(true);
+  });
+
+  it('draw issues an indexed draw over the subset after bind', () => {
+    const { state, gl } = makeGlScene3DState();
+    const proxy = makeProxy();
+    matcapGlMeshMaterialRenderer.bind(state, proxy.material, NO_LIGHTS, makeCamera());
+    matcapGlMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+    const draw = gl.calls.find((c) => c.name === 'drawElements');
+    expect(draw).toBeDefined();
+    expect(draw!.args[1]).toBe(proxy.subset.indexCount);
+  });
+
+  it('draw is a no-op when bind has not selected a program', () => {
+    const { state, gl } = makeGlScene3DState();
+    matcapGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+});
+
+describe('registerMatcapGlMaterial', () => {
+  it('installs the renderer for MatcapMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerMatcapGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, MatcapMaterialKind)).toBe(matcapGlMeshMaterialRenderer);
+  });
+});

package/src/normalGlMeshMaterialRenderer.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 { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import { normalGlMeshMaterialRenderer, registerNormalGlMaterial } from './normalGlMeshMaterialRenderer';
+
+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('normalGlMeshMaterialRenderer', () => {
+  it('bind selects a program, sets depth/cull, view-projection, and the normal scale uniform', () => {
+    const { state, gl } = makeGlScene3DState();
+    normalGlMeshMaterialRenderer.bind(state, createNormalMaterial(), NO_LIGHTS, 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 === 'uniformMatrix4fv')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform1f')).toBe(true);
+  });
+
+  it('draw issues an indexed draw over the subset after bind', () => {
+    const { state, gl } = makeGlScene3DState();
+    const proxy = makeProxy();
+    normalGlMeshMaterialRenderer.bind(state, proxy.material, NO_LIGHTS, makeCamera());
+    normalGlMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+    const draw = gl.calls.find((c) => c.name === 'drawElements');
+    expect(draw).toBeDefined();
+    expect(draw!.args[1]).toBe(proxy.subset.indexCount);
+  });
+
+  it('draw is a no-op when bind has not selected a program', () => {
+    const { state, gl } = makeGlScene3DState();
+    normalGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+});
+
+describe('registerNormalGlMaterial', () => {
+  it('installs the renderer for NormalMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerNormalGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, NormalMaterialKind)).toBe(normalGlMeshMaterialRenderer);
+  });
+});

package/src/phongGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,94 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createPhongMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { PhongMaterialKind } from '@flighthq/types';
+
+import { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { getGlScene3DRuntime } from './glScene3DRuntime';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import { phongGlMeshMaterialRenderer, registerPhongGlMaterial } from './phongGlMeshMaterialRenderer';
+
+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[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: createPhongMaterial(),
+    normalMatrix: createMatrix3(),
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4(),
+  };
+}
+
+describe('phongGlMeshMaterialRenderer', () => {
+  it('bind selects a program, uploads camera position + light block + diffuse/specular colors', () => {
+    const { state, gl } = makeGlScene3DState();
+    phongGlMeshMaterialRenderer.bind(state, createPhongMaterial(), 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 === 'uniformMatrix4fv')).toBe(true);
+    // Light block (2 vec4) + diffuse + specular colors → at least 4 uniform4f.
+    expect(gl.calls.filter((c) => c.name === 'uniform4f').length).toBeGreaterThanOrEqual(4);
+    // Camera3D position is a vec3; the ambient radiance is too — at least 2 uniform3f.
+    expect(gl.calls.filter((c) => c.name === 'uniform3f').length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('bind caches the program under the classic namespace with a phong key', () => {
+    const { state } = makeGlScene3DState();
+    phongGlMeshMaterialRenderer.bind(state, createPhongMaterial(), makeLights(), makeCamera());
+    const keys = [...getGlScene3DRuntime(state).programCache.keys()];
+    expect(keys.some((k) => k.startsWith('classic:p'))).toBe(true);
+  });
+
+  it('bind disables back-face culling for a double-sided material', () => {
+    const { state, gl } = makeGlScene3DState();
+    const material = createPhongMaterial();
+    material.doubleSided = true;
+    phongGlMeshMaterialRenderer.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();
+    phongGlMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    phongGlMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+
+    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();
+    phongGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+});
+
+describe('registerPhongGlMaterial', () => {
+  it('installs the renderer for PhongMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerPhongGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, PhongMaterialKind)).toBe(phongGlMeshMaterialRenderer);
+  });
+});

package/src/prepareGlScene3DForwardLights.test.ts

@@ -0,0 +1,106 @@
+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 { makeGlScene3DState } from './glScene3DTestHelper';
+import { prepareGlScene3DForwardLights } from './prepareGlScene3DForwardLights';
+
+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: [
+      createPointLight({ position: { x: 8, y: 0, z: 0 }, range: -1 }),
+      createPointLight({ position: { x: 8, y: 1, z: 0 }, range: -1 }),
+      createPointLight({ position: { x: 8, y: -1, z: 0 }, range: -1 }),
+      createPointLight({ position: { x: 8, y: 0, z: 1 }, range: -1 }),
+      createPointLight({ position: { x: 0, y: 0, z: 0 }, range: -1 }),
+      createPointLight({ position: { x: 0, y: 1, z: 0 }, range: -1 }),
+      createPointLight({ position: { x: 0, y: -1, z: 0 }, range: -1 }),
+      createPointLight({ position: { x: 0, y: 0, z: 1 }, range: -1 }),
+    ],
+  };
+}
+
+describe('prepareGlScene3DForwardLights', () => {
+  it('packs four selected points and four selected spots from independent family budgets', () => {
+    const { state } = makeGlScene3DState();
+    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 renderList = prepareScene3DRender(state, scene, camera(), lights);
+    const block = prepareGlScene3DForwardLights(state, renderList, lights).meshLightBlocks[0];
+    expect(block.pointCount).toBe(4);
+    expect(block.spotCount).toBe(4);
+  });
+
+  it('selects punctual lights per visible mesh and deduplicates identical tuples', () => {
+    const { state } = makeGlScene3DState();
+    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 selected = prepareGlScene3DForwardLights(state, renderList, lights);
+
+    expect(selected.meshCount).toBe(3);
+    expect(selected.meshLightBlocks[0]).toBe(selected.meshLightBlocks[1]);
+    expect(selected.meshLightBlocks[0]).not.toBe(selected.meshLightBlocks[2]);
+    expect(selected.meshLightBlocks[0].pointCount).toBe(4);
+    expect(selected.meshLightBlocks[0].data[SCENE_LIGHT_POINT_OFFSET]).toBe(0);
+    expect(selected.meshLightBlocks[2].data[SCENE_LIGHT_POINT_OFFSET]).toBe(8);
+  });
+
+  it('reuses its list, mesh array, and packed blocks across frames', () => {
+    const { state } = makeGlScene3DState();
+    const scene = createNode3D(Node3DKind);
+    addNodeChild(scene, createMesh(createBoxMeshGeometry(), []));
+    const lights = clusteredLights();
+    const renderList = prepareScene3DRender(state, scene, camera(), lights);
+    const first = prepareGlScene3DForwardLights(state, renderList, lights);
+    const meshBlocks = first.meshLightBlocks;
+    const block = first.meshLightBlocks[0];
+
+    const second = prepareGlScene3DForwardLights(state, renderList, lights);
+    expect(second).toBe(first);
+    expect(second.meshLightBlocks).toBe(meshBlocks);
+    expect(second.meshLightBlocks[0]).toBe(block);
+  });
+});

package/src/presentGlScene3D.test.ts

@@ -0,0 +1,98 @@
+import { createCamera3D, setCamera3DViewMatrix4FromLookAt } from '@flighthq/camera';
+import { createVector3 } from '@flighthq/geometry';
+import { createAmbientLight, createDirectionalLight } from '@flighthq/lighting';
+import { createStandardPbrMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import { addNodeChild } from '@flighthq/node';
+import { createMesh, createNode3D, Node3DKind } from '@flighthq/scene3d';
+import type { Camera3D, GlRenderTarget, Scene3DLightsLike } from '@flighthq/types';
+
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import { presentGlScene3D } from './presentGlScene3D';
+import { registerStandardPbrGlMaterial } from './registerStandardPbrGlMaterial';
+
+function makeCamera(): Camera3D {
+  const camera = createCamera3D({
+    far: 100,
+    near: 0.1,
+    projection: { aspect: 1, fovY: Math.PI / 3, kind: 'perspective' },
+  });
+  setCamera3DViewMatrix4FromLookAt(camera, { x: 0, y: 0, z: 5 }, { x: 0, y: 0, z: 0 }, { x: 0, y: 1, z: 0 });
+  return camera;
+}
+
+function makeTarget(): GlRenderTarget {
+  return {
+    width: 256,
+    height: 256,
+    format: 'rgba16f',
+    colorSpace: 'linear',
+    clearColors: [],
+    clearDepth: 1,
+    sampleCount: 1,
+    framebuffer: { id: 'sceneFb' } as unknown as WebGLFramebuffer,
+    resolveFramebuffer: null,
+    textures: [{ id: 'sceneTex' } as unknown as WebGLTexture],
+    texture: { id: 'sceneTex' } as unknown as WebGLTexture,
+    depthTexture: null,
+    colorRenderbuffers: [],
+    depthStencilRenderbuffer: { id: 'sceneDepth' } as unknown as WebGLRenderbuffer,
+  };
+}
+
+const LIGHTS: Scene3DLightsLike = {
+  ambient: createAmbientLight({ color: 0xffffffff, intensity: 0.2 }),
+  directional: createDirectionalLight({ color: 0xffffffff, direction: createVector3(0, -1, -1), intensity: 1 }),
+};
+
+describe('presentGlScene3D', () => {
+  it('renders into the target then presents to the canvas (default framebuffer)', () => {
+    const { state, gl } = makeGlScene3DState();
+    registerStandardPbrGlMaterial(state);
+    const scene = createNode3D(Node3DKind);
+    addNodeChild(scene, createMesh(createBoxMeshGeometry(), [createStandardPbrMaterial()]));
+    const target = makeTarget();
+
+    presentGlScene3D(state, target, scene, makeCamera(), LIGHTS);
+
+    const framebufferBinds = gl.calls.filter((c) => c.name === 'bindFramebuffer');
+    // The scene is drawn into the target's framebuffer...
+    expect(framebufferBinds.some((c) => c.args[1] === target.framebuffer)).toBe(true);
+    // ...and the linear->sRGB present writes to the canvas (default framebuffer = null).
+    expect(framebufferBinds.some((c) => c.args[1] === null)).toBe(true);
+  });
+
+  it('clears the background color and the depth buffer before drawing', () => {
+    const { state, gl } = makeGlScene3DState();
+    registerStandardPbrGlMaterial(state);
+    const scene = createNode3D(Node3DKind);
+    addNodeChild(scene, createMesh(createBoxMeshGeometry(), [createStandardPbrMaterial()]));
+
+    presentGlScene3D(state, makeTarget(), scene, makeCamera(), LIGHTS);
+
+    // beginGlRenderPass clears per-attachment (clearBufferfv for color location 0) and the depth/stencil
+    // buffer (clearBufferfi), the WebGL2 path that lets each MRT attachment carry its own clear value.
+    const colorClears = gl.calls.filter((c) => c.name === 'clearBufferfv' && c.args[0] === gl.COLOR);
+    expect(colorClears.some((c) => c.args[1] === 0)).toBe(true);
+    const depthClears = gl.calls.filter((c) => c.name === 'clearBufferfi' && c.args[0] === gl.DEPTH_STENCIL);
+    expect(depthClears.length).toBeGreaterThan(0);
+  });
+
+  it('presents to the canvas after the scene draw, so the encode reads the rendered target', () => {
+    const { state, gl } = makeGlScene3DState();
+    registerStandardPbrGlMaterial(state);
+    const scene = createNode3D(Node3DKind);
+    addNodeChild(scene, createMesh(createBoxMeshGeometry(), [createStandardPbrMaterial()]));
+    const target = makeTarget();
+
+    presentGlScene3D(state, target, scene, makeCamera(), LIGHTS);
+
+    const names = gl.calls.map((c) => c.name);
+    const lastTargetBind = names.lastIndexOf('bindTexture');
+    const lastDraw = names.lastIndexOf('drawElements');
+    // The present pass binds the scene texture and draws the fullscreen quad as the final operations.
+    expect(lastTargetBind).toBeGreaterThan(0);
+    expect(lastDraw).toBeGreaterThan(0);
+    expect(gl.calls.some((c) => c.name === 'bindTexture' && c.args[1] === target.texture)).toBe(true);
+  });
+});

package/src/registerStandardPbrGlMaterial.test.ts

@@ -0,0 +1,14 @@
+import { StandardPbrMaterialKind } from '@flighthq/types';
+
+import { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import { registerStandardPbrGlMaterial } from './registerStandardPbrGlMaterial';
+import { standardPbrGlMeshMaterialRenderer } from './standardPbrGlMeshMaterialRenderer';
+
+describe('registerStandardPbrGlMaterial', () => {
+  it('registers the StandardPbr renderer for StandardPbrMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerStandardPbrGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, StandardPbrMaterialKind)).toBe(standardPbrGlMeshMaterialRenderer);
+  });
+});

package/src/shadedGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,106 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import { createEmissiveModifier, createRimModifier, createShadedMaterial } from '@flighthq/shading';
+import type { Camera3D, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { ShadedMaterialKind } from '@flighthq/types';
+
+import { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { getGlScene3DRuntime } from './glScene3DRuntime';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import { setGlScene3DTime } from './glScene3DTime';
+import { registerBuiltInGlModifierSnippets } from './glShadedBuiltInModifiers';
+import { registerShadedGlMaterial, shadedGlMeshMaterialRenderer } from './shadedGlMeshMaterialRenderer';
+
+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: createShadedMaterial(),
+    normalMatrix: createMatrix3(),
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4(),
+  };
+}
+
+describe('registerShadedGlMaterial', () => {
+  it('installs the renderer for ShadedMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerShadedGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, ShadedMaterialKind)).toBe(shadedGlMeshMaterialRenderer);
+  });
+});
+
+describe('shadedGlMeshMaterialRenderer', () => {
+  it('bind selects a program and uploads camera + light block + base colors + time', () => {
+    const { state, gl } = makeGlScene3DState();
+    shadedGlMeshMaterialRenderer.bind(state, createShadedMaterial(), 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);
+    // Light block (2 vec4) + diffuse + specular colors → at least 4 uniform4f.
+    expect(gl.calls.filter((c) => c.name === 'uniform4f').length).toBeGreaterThanOrEqual(4);
+    // u_time is a uniform1f uploaded every bind.
+    expect(gl.calls.some((c) => c.name === 'uniform1f')).toBe(true);
+  });
+
+  it('bind caches the program under the shaded: namespace', () => {
+    const { state } = makeGlScene3DState();
+    shadedGlMeshMaterialRenderer.bind(state, createShadedMaterial(), makeLights(), makeCamera());
+    const keys = [...getGlScene3DRuntime(state).programCache.keys()];
+    expect(keys.some((k) => k.startsWith('shaded:'))).toBe(true);
+  });
+
+  it('a plain ShadedMaterial (empty stack) compiles the lean base variant', () => {
+    const { state } = makeGlScene3DState();
+    shadedGlMeshMaterialRenderer.bind(state, createShadedMaterial(), makeLights(), makeCamera());
+    const keys = [...getGlScene3DRuntime(state).programCache.keys()];
+    // Empty modifier feature-set → the define-key trails with an empty modifier segment. The last two
+    // base flags are the (unset) uv-transform and skin flags.
+    expect(keys).toContain('shaded:------|');
+  });
+
+  it('binds modifier uniforms for a material carrying a modifier stack', () => {
+    const { state, gl } = makeGlScene3DState();
+    registerBuiltInGlModifierSnippets(state);
+    setGlScene3DTime(state, 1.5);
+    const material = createShadedMaterial({
+      modifiers: [createEmissiveModifier({ color: 0xffcc88ff }), createRimModifier({ color: 0x88ccffff })],
+    });
+    shadedGlMeshMaterialRenderer.bind(state, material, makeLights(), makeCamera());
+    // Emissive color + rim color each upload a uniform3f (vec3), on top of camera/ambient vec3s.
+    expect(gl.calls.filter((c) => c.name === 'uniform3f').length).toBeGreaterThanOrEqual(4);
+  });
+
+  it('draw uploads geometry and issues an indexed draw over the subset range', () => {
+    const { state, gl } = makeGlScene3DState();
+    const proxy = makeProxy();
+    shadedGlMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    shadedGlMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+
+    const drawCall = gl.calls.find((c) => c.name === 'drawElements');
+    expect(drawCall).toBeDefined();
+    expect(drawCall!.args[1]).toBe(proxy.subset.indexCount);
+  });
+
+  it('draw is a no-op when bind has not selected a program', () => {
+    const { state, gl } = makeGlScene3DState();
+    shadedGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+});