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

package/src/glLitProgram.test.ts

@@ -0,0 +1,181 @@
+import type { GlRenderState, GlLitProgram } from '@flighthq/types';
+import { EntityRuntimeKey, SCENE_LIGHT_BLOCK_FLOATS } from '@flighthq/types';
+
+import { bindGlMeshLightBlock, GL_MESH_LIGHT_BLOCK_GLSL, resolveGlLitLocations } from './glLitProgram';
+import { makeFakeGl2 } from './glScene3DTestHelper';
+
+function makeLitProgram(): GlLitProgram {
+  const loc = (name: string): WebGLUniformLocation => ({ name }) as WebGLUniformLocation;
+  return {
+    locAmbientCount: loc('u_ambientCount'),
+    locAmbientRadiance: loc('u_ambientRadiance'),
+    locCameraPosition: loc('u_cameraPosition'),
+    locDirectional: loc('u_directional'),
+    locDirectionalCount: loc('u_directionalCount'),
+    locDirectionalRadiance: loc('u_directionalRadiance'),
+    locHemisphereCount: loc('u_hemisphereCount'),
+    locHemisphereLights: loc('u_hemisphereLights'),
+    locIblBrdf: loc('u_iblBrdf'),
+    locIblEnabled: loc('u_iblEnabled'),
+    locIblIntensity: loc('u_iblIntensity'),
+    locIblIrradiance: loc('u_iblIrradiance'),
+    locIblMaxMip: loc('u_iblMaxMip'),
+    locIblPrefiltered: loc('u_iblPrefiltered'),
+    locModel: loc('u_model'),
+    locNormalMatrix: loc('u_normalMatrix'),
+    locPointCount: loc('u_pointCount'),
+    locPointLights: loc('u_pointLights'),
+    locShadowEnabled: loc('u_shadowEnabled'),
+    locShadowMap: loc('u_shadowMap'),
+    locShadowMatrix: loc('u_shadowMatrix'),
+    locSpotCount: loc('u_spotCount'),
+    locSpotLights: loc('u_spotLights'),
+    locViewProjection: loc('u_viewProjection'),
+    program: {} as WebGLProgram,
+  };
+}
+
+function makeState(gl: ReturnType<typeof makeFakeGl2>): GlRenderState {
+  return { [EntityRuntimeKey]: {}, gl } as unknown as GlRenderState;
+}
+
+describe('bindGlMeshLightBlock', () => {
+  it('uploads the directional, ambient, count, shadow-gate, and ibl-gate uniforms from the packed block', () => {
+    const gl = makeFakeGl2();
+    const data = new Float32Array(SCENE_LIGHT_BLOCK_FLOATS);
+    data[0] = 0;
+    data[1] = -1;
+    data[4] = 1;
+    data[5] = 1;
+    data[6] = 1;
+    data[8] = 0.2;
+    bindGlMeshLightBlock(makeState(gl), makeLitProgram(), {
+      ambientCount: 1,
+      data,
+      directionalCount: 1,
+      hemisphereCount: 0,
+      pointCount: 0,
+      spotCount: 0,
+      version: 1,
+    });
+    expect(gl.calls.filter((c) => c.name === 'uniform4f').length).toBe(2);
+    expect(gl.calls.filter((c) => c.name === 'uniform3f').length).toBe(1);
+    // directionalCount + ambientCount + shadowEnabled (0, no active shadow) + iblEnabled (0, no IBL).
+    expect(gl.calls.filter((c) => c.name === 'uniform1f').length).toBe(4);
+  });
+
+  it('skips the light uniform upload when the program already holds the block version', () => {
+    const gl = makeFakeGl2();
+    const program = makeLitProgram();
+    const state = makeState(gl);
+    const block = {
+      ambientCount: 1,
+      data: new Float32Array(SCENE_LIGHT_BLOCK_FLOATS),
+      directionalCount: 1,
+      hemisphereCount: 0,
+      pointCount: 0,
+      spotCount: 0,
+      version: 7,
+    };
+    bindGlMeshLightBlock(state, program, block);
+    bindGlMeshLightBlock(state, program, block);
+    // Two binds, one program, one version: locDirectional/locDirectionalRadiance (uniform4f) and
+    // locAmbientRadiance (uniform3f) upload exactly once — only the light block is gated.
+    expect(gl.calls.filter((c) => c.name === 'uniform4f').length).toBe(2);
+    expect(gl.calls.filter((c) => c.name === 'uniform3f').length).toBe(1);
+  });
+
+  it('re-uploads the light uniforms when the block version changes', () => {
+    const gl = makeFakeGl2();
+    const program = makeLitProgram();
+    const state = makeState(gl);
+    const data = new Float32Array(SCENE_LIGHT_BLOCK_FLOATS);
+    const block = { ambientCount: 1, data, directionalCount: 1, hemisphereCount: 0, pointCount: 0, spotCount: 0 };
+    bindGlMeshLightBlock(state, program, { ...block, version: 1 });
+    bindGlMeshLightBlock(state, program, { ...block, version: 2 });
+    expect(gl.calls.filter((c) => c.name === 'uniform4f').length).toBe(4);
+  });
+
+  it('re-uploads when a different per-object block has the same version', () => {
+    const gl = makeFakeGl2();
+    const program = makeLitProgram();
+    const state = makeState(gl);
+    const common = {
+      ambientCount: 0,
+      directionalCount: 0,
+      hemisphereCount: 0,
+      pointCount: 1,
+      spotCount: 0,
+      version: 1,
+    };
+    bindGlMeshLightBlock(state, program, { ...common, data: new Float32Array(SCENE_LIGHT_BLOCK_FLOATS) });
+    bindGlMeshLightBlock(state, program, { ...common, data: new Float32Array(SCENE_LIGHT_BLOCK_FLOATS) });
+    expect(gl.calls.filter((c) => c.name === 'uniform4f')).toHaveLength(4);
+  });
+
+  it('uploads the punctual light arrays and their int counts from the packed block', () => {
+    const gl = makeFakeGl2();
+    bindGlMeshLightBlock(makeState(gl), makeLitProgram(), {
+      ambientCount: 0,
+      data: new Float32Array(SCENE_LIGHT_BLOCK_FLOATS),
+      directionalCount: 0,
+      hemisphereCount: 3,
+      pointCount: 2,
+      spotCount: 1,
+      version: 1,
+    });
+    // Three vec4 arrays uploaded: point, spot, hemisphere.
+    const arrayUploads = gl.calls.filter((c) => c.name === 'uniform4fv');
+    expect(arrayUploads.length).toBe(3);
+    // Each count uploads as an int uniform (u_pointCount / u_spotCount / u_hemisphereCount).
+    const intUploads = gl.calls.filter(
+      (c) =>
+        c.name === 'uniform1i' &&
+        typeof (c.args[0] as { name?: string })?.name === 'string' &&
+        (c.args[0] as { name: string }).name.endsWith('Count'),
+    );
+    expect(intUploads.map((c) => (c.args[0] as { name: string }).name).sort()).toEqual([
+      'u_hemisphereCount',
+      'u_pointCount',
+      'u_spotCount',
+    ]);
+    expect(intUploads.find((c) => (c.args[0] as { name: string }).name === 'u_pointCount')?.args[1]).toBe(2);
+    expect(intUploads.find((c) => (c.args[0] as { name: string }).name === 'u_spotCount')?.args[1]).toBe(1);
+    expect(intUploads.find((c) => (c.args[0] as { name: string }).name === 'u_hemisphereCount')?.args[1]).toBe(3);
+  });
+});
+
+describe('GL_MESH_LIGHT_BLOCK_GLSL', () => {
+  it('declares every uniform the CPU upload sets', () => {
+    for (const name of [
+      'u_directional',
+      'u_directionalRadiance',
+      'u_ambientRadiance',
+      'u_directionalCount',
+      'u_ambientCount',
+      'u_cameraPosition',
+      'u_shadowMap',
+      'u_shadowMatrix',
+      'u_shadowEnabled',
+      'u_pointLights',
+      'u_spotLights',
+      'u_hemisphereLights',
+      'u_pointCount',
+      'u_spotCount',
+      'u_hemisphereCount',
+    ]) {
+      expect(GL_MESH_LIGHT_BLOCK_GLSL).toContain(name);
+    }
+  });
+});
+
+describe('resolveGlLitLocations', () => {
+  it('resolves the standard lit uniform locations', () => {
+    const gl = makeFakeGl2();
+    const locations = resolveGlLitLocations(gl, {} as WebGLProgram);
+    expect(locations.locDirectional).not.toBeNull();
+    expect(locations.locAmbientRadiance).not.toBeNull();
+    expect(locations.locCameraPosition).not.toBeNull();
+    expect(locations.locShadowMap).not.toBeNull();
+  });
+});

package/src/glMatcapPrelude.test.ts

@@ -0,0 +1,74 @@
+import type { LinearColor, GlMatcapDefineKey } from '@flighthq/types';
+
+import {
+  bindGlMatcapSurface,
+  buildGlMatcapDefineKey,
+  compileGlMatcapProgram,
+  ensureGlMatcapProgram,
+  getGlMatcapFragmentSourceForKey,
+  getGlMatcapVertexSourceForKey,
+} from './glMatcapPrelude';
+import { getGlScene3DRuntime } from './glScene3DRuntime';
+import { makeFakeGl2, makeGlScene3DState } from './glScene3DTestHelper';
+
+const FLAT: GlMatcapDefineKey = { alphaMaskEnabled: false, hasMatcap: false };
+const TINT: LinearColor = [0.5, 0.25, 0.1, 1];
+
+describe('bindGlMatcapSurface', () => {
+  it('uploads the tint and alpha cutoff with no texture bind when the matcap is absent', () => {
+    const { state, gl } = makeGlScene3DState();
+    const program = compileGlMatcapProgram(gl, FLAT);
+    bindGlMatcapSurface(state, program, TINT, null, 0.5);
+    expect(gl.calls.some((c) => c.name === 'uniform4f')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform1f')).toBe(true);
+    // No matcap → no texture bind.
+    expect(gl.calls.some((c) => c.name === 'bindTexture')).toBe(false);
+  });
+});
+
+describe('buildGlMatcapDefineKey', () => {
+  it('produces distinct stable strings per flag set', () => {
+    expect(buildGlMatcapDefineKey(FLAT)).toBe('--');
+    expect(buildGlMatcapDefineKey({ alphaMaskEnabled: true, hasMatcap: true })).toBe('mt');
+    expect(buildGlMatcapDefineKey({ ...FLAT, hasMatcap: true })).toBe('-t');
+  });
+});
+
+describe('compileGlMatcapProgram', () => {
+  it('compiles, links, and resolves the matcap uniforms including the normal matrix and view', () => {
+    const gl = makeFakeGl2();
+    const program = compileGlMatcapProgram(gl, FLAT);
+    expect(program.locTint).not.toBeNull();
+    expect(program.locView).not.toBeNull();
+    expect(program.locNormalMatrix).not.toBeNull();
+    expect(gl.calls.some((c) => c.name === 'linkProgram')).toBe(true);
+  });
+});
+
+describe('ensureGlMatcapProgram', () => {
+  it('caches a variant under the matcap namespace and reuses it', () => {
+    const { state, gl } = makeGlScene3DState();
+    const first = ensureGlMatcapProgram(state, FLAT);
+    const links = gl.calls.filter((c) => c.name === 'linkProgram').length;
+    const second = ensureGlMatcapProgram(state, FLAT);
+    expect(second).toBe(first);
+    expect(gl.calls.filter((c) => c.name === 'linkProgram').length).toBe(links);
+    expect([...getGlScene3DRuntime(state).programCache.keys()].some((k) => k.startsWith('matcap:'))).toBe(true);
+  });
+});
+
+describe('getGlMatcapFragmentSourceForKey', () => {
+  it('includes feature defines only when their flag is set', () => {
+    expect(getGlMatcapFragmentSourceForKey(FLAT)).not.toContain('#define HAS_MATCAP');
+    expect(getGlMatcapFragmentSourceForKey({ ...FLAT, hasMatcap: true })).toContain('#define HAS_MATCAP');
+    expect(getGlMatcapFragmentSourceForKey({ ...FLAT, alphaMaskEnabled: true })).toContain('#define ALPHA_MASK');
+  });
+});
+
+describe('getGlMatcapVertexSourceForKey', () => {
+  it('builds the view-space normal from u_view and the normal matrix', () => {
+    const src = getGlMatcapVertexSourceForKey(FLAT);
+    expect(src).toContain('layout(location = 1) in vec3 a_normal');
+    expect(src).toContain('mat3(u_view) * (u_normalMatrix * a_normal)');
+  });
+});

package/src/glMeshMaterialRegistry.test.ts

@@ -0,0 +1,52 @@
+import type { GlMeshMaterialRenderer, Material } from '@flighthq/types';
+import { DefaultMaterialKind } from '@flighthq/types';
+
+import {
+  getGlMeshMaterialRenderer,
+  registerGlMeshMaterialRenderer,
+  resolveGlMeshMaterialRenderer,
+} from './glMeshMaterialRegistry';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+
+const TestKind = 'TestMeshMaterial';
+const renderer: GlMeshMaterialRenderer = { bind() {}, draw() {} };
+
+function makeMaterial(kind: string): Material {
+  return { kind } as Material;
+}
+
+describe('getGlMeshMaterialRenderer', () => {
+  it('returns null when nothing is registered for the kind', () => {
+    const { state } = makeGlScene3DState();
+    expect(getGlMeshMaterialRenderer(state, TestKind)).toBeNull();
+  });
+});
+
+describe('registerGlMeshMaterialRenderer', () => {
+  it('registers a renderer retrievable by kind', () => {
+    const { state } = makeGlScene3DState();
+    registerGlMeshMaterialRenderer(state, TestKind, renderer);
+    expect(getGlMeshMaterialRenderer(state, TestKind)).toBe(renderer);
+  });
+});
+
+describe('resolveGlMeshMaterialRenderer', () => {
+  it('returns null when nothing is registered — no built-in fallback', () => {
+    const { state } = makeGlScene3DState();
+    expect(resolveGlMeshMaterialRenderer(state, null)).toBeNull();
+    expect(resolveGlMeshMaterialRenderer(state, makeMaterial(TestKind))).toBeNull();
+  });
+
+  it('resolves by the material kind', () => {
+    const { state } = makeGlScene3DState();
+    registerGlMeshMaterialRenderer(state, TestKind, renderer);
+    expect(resolveGlMeshMaterialRenderer(state, makeMaterial(TestKind))).toBe(renderer);
+  });
+
+  it('falls back to the DefaultMaterialKind renderer', () => {
+    const { state } = makeGlScene3DState();
+    registerGlMeshMaterialRenderer(state, DefaultMaterialKind, renderer);
+    expect(resolveGlMeshMaterialRenderer(state, makeMaterial('Other'))).toBe(renderer);
+    expect(resolveGlMeshMaterialRenderer(state, null)).toBe(renderer);
+  });
+});