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

package/src/blinnPhongGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,94 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createBlinnPhongMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { BlinnPhongMaterialKind } from '@flighthq/types';
+
+import { blinnPhongGlMeshMaterialRenderer, registerBlinnPhongGlMaterial } from './blinnPhongGlMeshMaterialRenderer';
+import { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { getGlScene3DRuntime } from './glScene3DRuntime';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+
+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: createBlinnPhongMaterial(),
+    normalMatrix: createMatrix3(),
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4(),
+  };
+}
+
+describe('blinnPhongGlMeshMaterialRenderer', () => {
+  it('bind selects a program, uploads camera position + light block + diffuse/specular colors', () => {
+    const { state, gl } = makeGlScene3DState();
+    blinnPhongGlMeshMaterialRenderer.bind(state, createBlinnPhongMaterial(), 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 blinnphong key', () => {
+    const { state } = makeGlScene3DState();
+    blinnPhongGlMeshMaterialRenderer.bind(state, createBlinnPhongMaterial(), makeLights(), makeCamera());
+    const keys = [...getGlScene3DRuntime(state).programCache.keys()];
+    expect(keys.some((k) => k.startsWith('classic:b'))).toBe(true);
+  });
+
+  it('bind disables back-face culling for a double-sided material', () => {
+    const { state, gl } = makeGlScene3DState();
+    const material = createBlinnPhongMaterial();
+    material.doubleSided = true;
+    blinnPhongGlMeshMaterialRenderer.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();
+    blinnPhongGlMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    blinnPhongGlMeshMaterialRenderer.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();
+    blinnPhongGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+});
+
+describe('registerBlinnPhongGlMaterial', () => {
+  it('installs the renderer for BlinnPhongMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerBlinnPhongGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, BlinnPhongMaterialKind)).toBe(blinnPhongGlMeshMaterialRenderer);
+  });
+});

package/src/clearcoatPbrGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,81 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createClearcoatPbrMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Matrix3, Matrix4, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { ClearcoatPbrMaterialKind } from '@flighthq/types';
+
+import {
+  clearcoatPbrGlMeshMaterialRenderer,
+  registerClearcoatPbrGlMaterial,
+} from './clearcoatPbrGlMeshMaterialRenderer';
+import { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { getGlScene3DRuntime } from './glScene3DRuntime';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+
+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: createClearcoatPbrMaterial(),
+    normalMatrix: createMatrix3() as Matrix3,
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4() as Matrix4,
+  };
+}
+
+describe('clearcoatPbrGlMeshMaterialRenderer', () => {
+  it('bind uploads the light block, standard block, and clearcoat uniforms', () => {
+    const { state, gl } = makeGlScene3DState();
+    clearcoatPbrGlMeshMaterialRenderer.bind(state, createClearcoatPbrMaterial(), 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);
+    expect(gl.calls.filter((c) => c.name === 'uniform1f').length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('caches the clearcoat program under the pbr: namespace', () => {
+    const { state } = makeGlScene3DState();
+    clearcoatPbrGlMeshMaterialRenderer.bind(state, createClearcoatPbrMaterial(), 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();
+    clearcoatPbrGlMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    clearcoatPbrGlMeshMaterialRenderer.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();
+    clearcoatPbrGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+});
+
+describe('registerClearcoatPbrGlMaterial', () => {
+  it('installs the renderer for ClearcoatPbrMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerClearcoatPbrGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, ClearcoatPbrMaterialKind)).toBe(clearcoatPbrGlMeshMaterialRenderer);
+  });
+});

package/src/customShaderGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,169 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createCustomShaderMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { CustomShaderMaterialKind } from '@flighthq/types';
+
+import {
+  customShaderGlMeshMaterialRenderer,
+  getGlCustomMaterialShaderSource,
+  registerCustomShaderGlMaterial,
+  registerGlCustomMaterialShader,
+} from './customShaderGlMeshMaterialRenderer';
+import { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+
+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,
+};
+
+const VERTEX_SRC = `#version 300 es
+layout(location = 0) in vec3 a_position;
+layout(location = 1) in vec3 a_normal;
+layout(location = 2) in vec4 a_tangent;
+layout(location = 3) in vec2 a_uv0;
+uniform mat4 u_viewProjection;
+uniform mat4 u_model;
+uniform mat3 u_normalMatrix;
+uniform vec3 u_cameraPosition;
+void main() {
+  gl_Position = u_viewProjection * u_model * vec4(a_position, 1.0);
+}`;
+
+const FRAGMENT_SRC = `#version 300 es
+precision highp float;
+uniform float u_time;
+out vec4 fragColor;
+void main() {
+  fragColor = vec4(1.0, 0.0, u_time, 1.0);
+}`;
+
+function makeProxy(): Scene3DRenderProxy {
+  const geometry = createBoxMeshGeometry();
+  return {
+    material: createCustomShaderMaterial({ shaderKey: 'test' }),
+    normalMatrix: createMatrix3(),
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4(),
+  };
+}
+
+describe('customShaderGlMeshMaterialRenderer', () => {
+  it('bind selects a program and uploads view-projection and camera position when shader is registered', () => {
+    const { state, gl } = makeGlScene3DState();
+    registerGlCustomMaterialShader(state, 'test', { fragment: FRAGMENT_SRC, vertex: VERTEX_SRC });
+    customShaderGlMeshMaterialRenderer.bind(
+      state,
+      createCustomShaderMaterial({ shaderKey: 'test' }),
+      NO_LIGHTS,
+      makeCamera(),
+    );
+    expect(gl.calls.some((c) => c.name === 'useProgram')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniformMatrix4fv')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform3f')).toBe(true);
+  });
+
+  it('bind uploads custom uniforms from the material', () => {
+    const { state, gl } = makeGlScene3DState();
+    registerGlCustomMaterialShader(state, 'test', { fragment: FRAGMENT_SRC, vertex: VERTEX_SRC });
+    customShaderGlMeshMaterialRenderer.bind(
+      state,
+      createCustomShaderMaterial({ shaderKey: 'test', uniforms: { u_time: 0.5, u_scale: [2, 3] } }),
+      NO_LIGHTS,
+      makeCamera(),
+    );
+    expect(gl.calls.some((c) => c.name === 'uniform1f' && c.args[1] === 0.5)).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform2fv')).toBe(true);
+  });
+
+  it('bind is a no-op (sets active program null) when shaderKey is not registered', () => {
+    const { state, gl } = makeGlScene3DState();
+    customShaderGlMeshMaterialRenderer.bind(
+      state,
+      createCustomShaderMaterial({ shaderKey: 'missing' }),
+      NO_LIGHTS,
+      makeCamera(),
+    );
+    expect(gl.calls.some((c) => c.name === 'useProgram')).toBe(false);
+  });
+
+  it('bind is a no-op when shaderKey is empty', () => {
+    const { state, gl } = makeGlScene3DState();
+    customShaderGlMeshMaterialRenderer.bind(state, createCustomShaderMaterial(), NO_LIGHTS, makeCamera());
+    expect(gl.calls.some((c) => c.name === 'useProgram')).toBe(false);
+  });
+
+  it('draw issues an indexed draw over the subset after bind', () => {
+    const { state, gl } = makeGlScene3DState();
+    registerGlCustomMaterialShader(state, 'test', { fragment: FRAGMENT_SRC, vertex: VERTEX_SRC });
+    const proxy = makeProxy();
+    customShaderGlMeshMaterialRenderer.bind(state, proxy.material, NO_LIGHTS, makeCamera());
+    customShaderGlMeshMaterialRenderer.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 skipped due to missing shader key', () => {
+    const { state, gl } = makeGlScene3DState();
+    customShaderGlMeshMaterialRenderer.bind(
+      state,
+      createCustomShaderMaterial({ shaderKey: 'missing' }),
+      NO_LIGHTS,
+      makeCamera(),
+    );
+    customShaderGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+});
+
+describe('getGlCustomMaterialShaderSource', () => {
+  it('returns the source registered under the given key', () => {
+    const { state } = makeGlScene3DState();
+    const source = { fragment: FRAGMENT_SRC, vertex: VERTEX_SRC };
+    registerGlCustomMaterialShader(state, 'ripple', source);
+    expect(getGlCustomMaterialShaderSource(state, 'ripple')).toBe(source);
+  });
+
+  it('returns null for an unregistered key', () => {
+    const { state } = makeGlScene3DState();
+    expect(getGlCustomMaterialShaderSource(state, 'nope')).toBeNull();
+  });
+});
+
+describe('registerCustomShaderGlMaterial', () => {
+  it('installs the renderer for CustomShaderMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerCustomShaderGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, CustomShaderMaterialKind)).toBe(customShaderGlMeshMaterialRenderer);
+  });
+});
+
+describe('registerGlCustomMaterialShader', () => {
+  it('stores shader source retrievable by key', () => {
+    const { state } = makeGlScene3DState();
+    const source = { fragment: FRAGMENT_SRC, vertex: VERTEX_SRC };
+    registerGlCustomMaterialShader(state, 'ripple', source);
+    expect(getGlCustomMaterialShaderSource(state, 'ripple')).toBe(source);
+  });
+
+  it('last write wins per key', () => {
+    const { state } = makeGlScene3DState();
+    const a = { fragment: 'a', vertex: 'a' };
+    const b = { fragment: 'b', vertex: 'b' };
+    registerGlCustomMaterialShader(state, 'key', a);
+    registerGlCustomMaterialShader(state, 'key', b);
+    expect(getGlCustomMaterialShaderSource(state, 'key')).toBe(b);
+  });
+});

package/src/depthGlMeshMaterialRenderer.test.ts

@@ -0,0 +1,69 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createDepthMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { DepthMaterialKind } from '@flighthq/types';
+
+import { depthGlMeshMaterialRenderer, registerDepthGlMaterial } from './depthGlMeshMaterialRenderer';
+import { getGlMeshMaterialRenderer } from './glMeshMaterialRegistry';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+
+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: createDepthMaterial(),
+    normalMatrix: createMatrix3(),
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4(),
+  };
+}
+
+describe('depthGlMeshMaterialRenderer', () => {
+  it('bind selects a program, sets depth/cull, view-projection, and the near/far range', () => {
+    const { state, gl } = makeGlScene3DState();
+    depthGlMeshMaterialRenderer.bind(state, createDepthMaterial(), 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.filter((c) => c.name === 'uniform1f').length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('draw issues an indexed draw over the subset after bind', () => {
+    const { state, gl } = makeGlScene3DState();
+    const proxy = makeProxy();
+    depthGlMeshMaterialRenderer.bind(state, proxy.material, NO_LIGHTS, makeCamera());
+    depthGlMeshMaterialRenderer.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();
+    depthGlMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(gl.calls.some((c) => c.name === 'drawElements')).toBe(false);
+  });
+});
+
+describe('registerDepthGlMaterial', () => {
+  it('installs the renderer for DepthMaterialKind', () => {
+    const { state } = makeGlScene3DState();
+    registerDepthGlMaterial(state);
+    expect(getGlMeshMaterialRenderer(state, DepthMaterialKind)).toBe(depthGlMeshMaterialRenderer);
+  });
+});