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

package/src/glPbrPrelude.test.ts

@@ -0,0 +1,178 @@
+import type { GlPbrDefineKey } from '@flighthq/types';
+
+import {
+  buildGlPbrDefineKey,
+  buildGlPbrDefineSource,
+  getGlPbrFragmentSource,
+  getGlPbrFragmentSourceForKey,
+  getGlPbrVertexSource,
+  getGlPbrVertexSourceForKey,
+} from './glPbrPrelude';
+
+function makeKey(overrides?: Partial<GlPbrDefineKey>): GlPbrDefineKey {
+  return {
+    alphaMaskEnabled: false,
+    anisotropyEnabled: false,
+    clearcoatEnabled: false,
+    hasAlphaMap: false,
+    hasBaseColorMap: false,
+    hasEmissiveMap: false,
+    hasMetallicRoughnessMap: false,
+    hasNormalMap: false,
+    hasOcclusionMap: false,
+    hasUvTransform: false,
+    iridescenceEnabled: false,
+    sheenEnabled: false,
+    specularEnabled: false,
+    subsurfaceEnabled: false,
+    transmissionEnabled: false,
+    ...overrides,
+  };
+}
+
+const NONE = makeKey();
+const STANDARD_ALL = makeKey({
+  alphaMaskEnabled: true,
+  hasBaseColorMap: true,
+  hasEmissiveMap: true,
+  hasMetallicRoughnessMap: true,
+  hasNormalMap: true,
+  hasOcclusionMap: true,
+});
+const ALL = makeKey({
+  ...STANDARD_ALL,
+  anisotropyEnabled: true,
+  clearcoatEnabled: true,
+  iridescenceEnabled: true,
+  sheenEnabled: true,
+  specularEnabled: true,
+  subsurfaceEnabled: true,
+  transmissionEnabled: true,
+});
+
+describe('buildGlPbrDefineKey', () => {
+  it('produces a stable, distinct string per flag set', () => {
+    expect(buildGlPbrDefineKey(NONE)).toBe('--------:--------');
+    expect(buildGlPbrDefineKey(STANDARD_ALL)).toBe('mbnroe--:--------');
+    expect(buildGlPbrDefineKey(ALL)).toBe('mbnroe--:CSAIPUT-');
+    expect(buildGlPbrDefineKey(makeKey({ hasBaseColorMap: true }))).toBe('-b------:--------');
+    expect(buildGlPbrDefineKey(makeKey({ clearcoatEnabled: true }))).toBe('--------:C-------');
+    expect(buildGlPbrDefineKey(makeKey({ hasAlphaMap: true }))).toBe('------a-:--------');
+  });
+
+  it('encodes the HAS_UV_TRANSFORM variant as a distinct standard-block slot', () => {
+    expect(buildGlPbrDefineKey(makeKey({ hasUvTransform: true }))).toBe('-------u:--------');
+    expect(buildGlPbrDefineKey(makeKey({ hasUvTransform: true }))).not.toBe(buildGlPbrDefineKey(NONE));
+  });
+
+  it('encodes the HAS_SKIN variant as a distinct trailing slot', () => {
+    expect(buildGlPbrDefineKey(makeKey({ hasSkin: true }))).toBe('--------:-------k');
+    expect(buildGlPbrDefineKey(makeKey({ hasSkin: true }))).not.toBe(buildGlPbrDefineKey(NONE));
+  });
+
+  it('is identical for equal flag sets', () => {
+    expect(buildGlPbrDefineKey(makeKey(ALL))).toBe(buildGlPbrDefineKey(makeKey(ALL)));
+  });
+});
+
+describe('buildGlPbrDefineSource', () => {
+  it('emits a define for each enabled flag and none for disabled flags', () => {
+    const all = buildGlPbrDefineSource(ALL);
+    expect(all).toContain('#define ALPHA_MASK');
+    expect(all).toContain('#define HAS_BASE_COLOR_MAP');
+    expect(all).toContain('#define HAS_NORMAL_MAP');
+    expect(all).toContain('#define HAS_METALLIC_ROUGHNESS_MAP');
+    expect(all).toContain('#define HAS_OCCLUSION_MAP');
+    expect(all).toContain('#define HAS_EMISSIVE_MAP');
+    expect(all).toContain('#define CLEARCOAT');
+    expect(all).toContain('#define SHEEN');
+    expect(all).toContain('#define ANISOTROPY');
+    expect(all).toContain('#define IRIDESCENCE');
+    expect(all).toContain('#define SPECULAR_EXT');
+    expect(all).toContain('#define SUBSURFACE');
+    expect(all).toContain('#define TRANSMISSION');
+
+    const none = buildGlPbrDefineSource(NONE);
+    expect(none).not.toContain('#define ALPHA_MASK');
+    expect(none).not.toContain('#define HAS_BASE_COLOR_MAP');
+    expect(none).not.toContain('#define CLEARCOAT');
+    expect(none).not.toContain('#define HAS_ALPHA_MAP');
+  });
+
+  it('gates the HAS_ALPHA_MAP define off the dedicated coverage-map flag', () => {
+    expect(buildGlPbrDefineSource(makeKey({ hasAlphaMap: true }))).toContain('#define HAS_ALPHA_MAP');
+  });
+
+  it('opens with the GLSL 300 es version directive', () => {
+    expect(buildGlPbrDefineSource(NONE).startsWith('#version 300 es')).toBe(true);
+  });
+});
+
+describe('getGlPbrFragmentSource', () => {
+  it('declares the PBR fragment interface and outputs linear HDR radiance', () => {
+    const src = getGlPbrFragmentSource();
+    expect(src).toContain('out vec4 fragColor');
+    expect(src).toContain('distributionGgx');
+    expect(src).toContain('fresnelSchlick');
+    expect(src).toContain('u_directionalRadiance');
+  });
+
+  it('does not embed a version directive (that comes from the define block)', () => {
+    expect(getGlPbrFragmentSource()).not.toContain('#version');
+  });
+});
+
+describe('getGlPbrFragmentSourceForKey', () => {
+  it('prepends the define block to the fragment body', () => {
+    const src = getGlPbrFragmentSourceForKey(STANDARD_ALL);
+    expect(src.startsWith('#version 300 es')).toBe(true);
+    expect(src).toContain('#define HAS_NORMAL_MAP');
+    expect(src).toContain('out vec4 fragColor');
+  });
+
+  it('emits the MAX_FORWARD_LIGHTS spec constant and loops the punctual light arrays', () => {
+    const src = getGlPbrFragmentSourceForKey(NONE);
+    expect(src).toContain('#define MAX_FORWARD_LIGHTS');
+    expect(src).toContain('u_pointLights');
+    expect(src).toContain('u_spotLights');
+    expect(src).toContain('u_hemisphereLights');
+    // Directional, point, and spot lights share the one Cook-Torrance BRDF (no forked shading model).
+    expect(src).toContain('shadePbrPunctual');
+  });
+});
+
+describe('getGlPbrVertexSource', () => {
+  it('declares the canonical PBR vertex attributes and model/view-projection uniforms', () => {
+    const src = getGlPbrVertexSource();
+    expect(src).toContain('layout(location = 0) in vec3 a_position');
+    expect(src).toContain('layout(location = 1) in vec3 a_normal');
+    expect(src).toContain('layout(location = 2) in vec4 a_tangent');
+    expect(src).toContain('layout(location = 3) in vec2 a_uv0');
+    expect(src).toContain('u_viewProjection');
+    expect(src).toContain('u_model');
+    expect(src).toContain('u_normalMatrix');
+  });
+});
+
+describe('getGlPbrVertexSourceForKey', () => {
+  it('injects the skin declarations and HAS_SKIN define only for the skinned variant', () => {
+    const rigid = getGlPbrVertexSourceForKey(NONE);
+    expect(rigid).not.toContain('#define HAS_SKIN');
+    expect(rigid).not.toContain('a_joints0');
+    expect(rigid).not.toContain('mat4 skinMatrix()');
+
+    const skinned = getGlPbrVertexSourceForKey(makeKey({ hasSkin: true }));
+    expect(skinned).toContain('#define HAS_SKIN');
+    expect(skinned).not.toContain('#define MAX_JOINTS');
+    expect(skinned).toContain('sampler2D u_jointTexture');
+    expect(skinned).toContain('texelFetch');
+    expect(skinned).toContain('mat4 skinMatrix()');
+    expect(skinned).toContain('a_joints0');
+  });
+
+  it('prepends the define block to the vertex body', () => {
+    const src = getGlPbrVertexSourceForKey(NONE);
+    expect(src.startsWith('#version 300 es')).toBe(true);
+    expect(src).toContain('gl_Position');
+  });
+});

package/src/glPbrProgramCache.test.ts

@@ -0,0 +1,116 @@
+import type { GlPbrDefineKey } from '@flighthq/types';
+
+import { compileGlPbrProgram, ensureGlPbrProgram } from './glPbrProgramCache';
+import { getGlScene3DRuntime } from './glScene3DRuntime';
+import { makeFakeGl2, makeGlScene3DState } from './glScene3DTestHelper';
+
+function makeKey(overrides?: Partial<GlPbrDefineKey>): GlPbrDefineKey {
+  return {
+    alphaMaskEnabled: false,
+    anisotropyEnabled: false,
+    clearcoatEnabled: false,
+    hasAlphaMap: false,
+    hasBaseColorMap: false,
+    hasEmissiveMap: false,
+    hasMetallicRoughnessMap: false,
+    hasNormalMap: false,
+    hasOcclusionMap: false,
+    hasUvTransform: false,
+    iridescenceEnabled: false,
+    sheenEnabled: false,
+    specularEnabled: false,
+    subsurfaceEnabled: false,
+    transmissionEnabled: false,
+    ...overrides,
+  };
+}
+
+const KEY = makeKey();
+
+describe('compileGlPbrProgram', () => {
+  it('compiles, links, and resolves the PBR uniform locations', () => {
+    const gl = makeFakeGl2();
+    const program = compileGlPbrProgram(gl, KEY);
+    expect(program.program).not.toBeNull();
+    expect(program.locViewProjection).not.toBeNull();
+    expect(program.locBaseColor).not.toBeNull();
+    expect(program.locDirectionalRadiance).not.toBeNull();
+    expect(gl.calls.some((c) => c.name === 'linkProgram')).toBe(true);
+  });
+
+  it('resolves the full standard-block map uniforms', () => {
+    const gl = makeFakeGl2();
+    const program = compileGlPbrProgram(gl, KEY);
+    expect(program.locMetallicRoughnessMap).not.toBeNull();
+    expect(program.locOcclusionMap).not.toBeNull();
+    expect(program.locOcclusionStrength).not.toBeNull();
+    expect(program.locEmissiveMap).not.toBeNull();
+  });
+
+  it('resolves every extension uniform', () => {
+    const gl = makeFakeGl2();
+    const program = compileGlPbrProgram(gl, KEY);
+    expect(program.locClearcoat).not.toBeNull();
+    expect(program.locSheenColor).not.toBeNull();
+    expect(program.locAnisotropyStrength).not.toBeNull();
+    expect(program.locIridescence).not.toBeNull();
+    expect(program.locSpecular).not.toBeNull();
+    expect(program.locSubsurface).not.toBeNull();
+    expect(program.locTransmission).not.toBeNull();
+    expect(program.locAttenuationColor).not.toBeNull();
+  });
+
+  it('throws on a shader compile failure', () => {
+    const gl = makeFakeGl2({ compileOk: false });
+    expect(() => compileGlPbrProgram(gl, KEY)).toThrow(/compile error/);
+  });
+
+  it('throws on a program link failure', () => {
+    const gl = makeFakeGl2({ linkOk: false });
+    expect(() => compileGlPbrProgram(gl, KEY)).toThrow(/link error/);
+  });
+});
+
+describe('ensureGlPbrProgram', () => {
+  it('compiles a variant once and caches it by define key', () => {
+    const { state, gl } = makeGlScene3DState();
+    const first = ensureGlPbrProgram(state, KEY);
+    const linkCount = gl.calls.filter((c) => c.name === 'linkProgram').length;
+    const second = ensureGlPbrProgram(state, KEY);
+    expect(second).toBe(first);
+    expect(gl.calls.filter((c) => c.name === 'linkProgram').length).toBe(linkCount);
+    expect(getGlScene3DRuntime(state).programCache.size).toBe(1);
+  });
+
+  it('compiles a distinct program for a different standard map flag', () => {
+    const { state } = makeGlScene3DState();
+    ensureGlPbrProgram(state, KEY);
+    ensureGlPbrProgram(state, makeKey({ hasBaseColorMap: true }));
+    expect(getGlScene3DRuntime(state).programCache.size).toBe(2);
+  });
+
+  it('folds the render-state skinned-run flag into a distinct HAS_SKIN variant', () => {
+    const { state } = makeGlScene3DState();
+    const rigid = ensureGlPbrProgram(state, KEY);
+    getGlScene3DRuntime(state).activeSkinnedRun = true;
+    const skinned = ensureGlPbrProgram(state, KEY);
+
+    expect(skinned).not.toBe(rigid);
+    expect([...getGlScene3DRuntime(state).programCache.keys()]).toContain('pbr:--------:-------k');
+    expect(skinned.locJointTexture).not.toBeNull();
+  });
+
+  it('caches a distinct entry per extension define under the pbr: namespace', () => {
+    const { state } = makeGlScene3DState();
+    ensureGlPbrProgram(state, makeKey({ clearcoatEnabled: true }));
+    ensureGlPbrProgram(state, makeKey({ sheenEnabled: true }));
+    ensureGlPbrProgram(state, makeKey({ anisotropyEnabled: true }));
+    ensureGlPbrProgram(state, makeKey({ iridescenceEnabled: true }));
+    ensureGlPbrProgram(state, makeKey({ specularEnabled: true }));
+    ensureGlPbrProgram(state, makeKey({ subsurfaceEnabled: true }));
+    ensureGlPbrProgram(state, makeKey({ transmissionEnabled: true }));
+    const cache = getGlScene3DRuntime(state).programCache;
+    expect(cache.size).toBe(7);
+    for (const key of cache.keys()) expect(key.startsWith('pbr:')).toBe(true);
+  });
+});

package/src/glPbrStandardBlock.test.ts

@@ -0,0 +1,85 @@
+import { createStandardPbrMaterial, createStandardPbrMaterialProperties } from '@flighthq/materials';
+import type { StandardPbrMaterialProperties, Texture } from '@flighthq/types';
+
+import { compileGlPbrProgram } from './glPbrProgramCache';
+import {
+  bindGlPbrStandardBlock,
+  bindGlPbrStandardTexture,
+  buildGlPbrStandardDefineKey,
+  isGlTextureReady,
+} from './glPbrStandardBlock';
+import { makeFakeGl2, makeGlScene3DState } from './glScene3DTestHelper';
+
+function makeProgram() {
+  return compileGlPbrProgram(makeFakeGl2(), buildGlPbrStandardDefineKey(null, null));
+}
+
+// A texture that reports pixels (isGlTextureReady === true) without a real upload.
+const READY_TEXTURE = { image: { source: {}, data: null, compressed: null } } as unknown as Texture;
+
+describe('bindGlPbrStandardBlock', () => {
+  it('uploads neutral defaults for a null block', () => {
+    const { state, gl } = makeGlScene3DState();
+    bindGlPbrStandardBlock(state, makeProgram(), null);
+    expect(gl.calls.some((c) => c.name === 'uniform4f')).toBe(true);
+    expect(gl.calls.filter((c) => c.name === 'uniform1f').length).toBeGreaterThanOrEqual(4);
+  });
+
+  it('uploads the metallic-roughness scalars and emissive for a material block', () => {
+    const { state, gl } = makeGlScene3DState();
+    const standard = createStandardPbrMaterialProperties({ metallic: 0.5, occlusionStrength: 0.3, roughness: 0.6 });
+    bindGlPbrStandardBlock(state, makeProgram(), standard);
+    expect(gl.calls.some((c) => c.name === 'uniform4f')).toBe(true);
+    expect(gl.calls.some((c) => c.name === 'uniform3f')).toBe(true);
+    expect(gl.calls.filter((c) => c.name === 'uniform1f').length).toBeGreaterThanOrEqual(4);
+    // No textures bound when every map is null.
+    expect(gl.calls.some((c) => c.name === 'activeTexture')).toBe(false);
+  });
+});
+
+describe('bindGlPbrStandardTexture', () => {
+  it('is a no-op when the texture slot is empty', () => {
+    const { state, gl } = makeGlScene3DState();
+    bindGlPbrStandardTexture(state, null, makeProgram().locBaseColorMap, 0);
+    expect(gl.calls.some((c) => c.name === 'activeTexture')).toBe(false);
+  });
+});
+
+describe('buildGlPbrStandardDefineKey', () => {
+  it('propagates the alpha-mask flag from the surface material', () => {
+    expect(buildGlPbrStandardDefineKey(null, createStandardPbrMaterial({ alphaMode: 'mask' })).alphaMaskEnabled).toBe(
+      true,
+    );
+  });
+
+  it('samples the alpha map for mask/blend but not for an opaque material', () => {
+    const standard = { alphaMap: READY_TEXTURE } as unknown as StandardPbrMaterialProperties;
+    expect(buildGlPbrStandardDefineKey(standard, createStandardPbrMaterial({ alphaMode: 'mask' })).hasAlphaMap).toBe(
+      true,
+    );
+    expect(buildGlPbrStandardDefineKey(standard, createStandardPbrMaterial({ alphaMode: 'blend' })).hasAlphaMap).toBe(
+      true,
+    );
+    expect(buildGlPbrStandardDefineKey(standard, createStandardPbrMaterial({ alphaMode: 'opaque' })).hasAlphaMap).toBe(
+      false,
+    );
+  });
+
+  it('returns all-false map and extension flags for a null block', () => {
+    const key = buildGlPbrStandardDefineKey(null, null);
+    expect(key.clearcoatEnabled).toBe(false);
+    expect(key.hasAlphaMap).toBe(false);
+    expect(key.hasBaseColorMap).toBe(false);
+    expect(key.hasEmissiveMap).toBe(false);
+    expect(key.hasMetallicRoughnessMap).toBe(false);
+    expect(key.hasOcclusionMap).toBe(false);
+    expect(key.hasUvTransform).toBe(false);
+    expect(key.transmissionEnabled).toBe(false);
+  });
+});
+
+describe('isGlTextureReady', () => {
+  it('is false for a null texture', () => {
+    expect(isGlTextureReady(null)).toBe(false);
+  });
+});

package/src/glScene3DRuntime.test.ts

@@ -0,0 +1,108 @@
+import type { GlRenderStateRuntime, GlRenderTarget, Matrix4, GlMeshProgram, GlScene3DIbl } from '@flighthq/types';
+import { EntityRuntimeKey } from '@flighthq/types';
+
+import { destroyGlScene3DRuntime, ensureGlSkinPalette, getGlScene3DRuntime } from './glScene3DRuntime';
+import { makeGlScene3DState } from './glScene3DTestHelper';
+
+describe('destroyGlScene3DRuntime', () => {
+  it('is a safe no-op when the state never allocated a scene runtime', () => {
+    const { state, gl } = makeGlScene3DState();
+    destroyGlScene3DRuntime(state);
+    expect(gl.calls.some((c) => c.name.startsWith('delete'))).toBe(false);
+  });
+
+  it('frees the cached programs, the IBL set, the environment cube, and the shadow target, then clears the slots', () => {
+    const { state, gl } = makeGlScene3DState();
+    const scene = getGlScene3DRuntime(state);
+
+    scene.programCache.set('a', { program: {} as WebGLProgram } as GlMeshProgram);
+    scene.programCache.set('b', { program: {} as WebGLProgram } as GlMeshProgram);
+    scene.activeMeshProgram = scene.programCache.get('a')!;
+    scene.ibl = {
+      brdfLut: {} as WebGLTexture,
+      intensity: 1,
+      irradianceCube: {} as WebGLTexture,
+      prefilteredCube: {} as WebGLTexture,
+      prefilteredMipCount: 5,
+    } satisfies GlScene3DIbl;
+    scene.iblBakeFramebuffer = {} as WebGLFramebuffer;
+    scene.environmentSourceCube = {} as WebGLTexture;
+    const depthTexture = {} as WebGLTexture;
+    scene.shadowTarget = {
+      colorRenderbuffers: [],
+      depthStencilRenderbuffer: null,
+      depthTexture,
+      framebuffer: {} as WebGLFramebuffer,
+      resolveFramebuffer: null,
+      textures: [],
+    } as unknown as GlRenderTarget;
+    scene.shadow = { matrix: {} as Matrix4, texture: depthTexture };
+    scene.skinPalette = { jointCapacity: 4, texture: {} as WebGLTexture };
+
+    destroyGlScene3DRuntime(state);
+
+    expect(gl.calls.filter((c) => c.name === 'deleteProgram').length).toBe(2);
+    // 3 IBL textures + the environment source cube + the shadow depth texture (owned by the target) +
+    // the skin-palette data texture.
+    expect(gl.calls.filter((c) => c.name === 'deleteTexture').length).toBe(6);
+    // The IBL bake framebuffer + the shadow target's framebuffer.
+    expect(gl.calls.filter((c) => c.name === 'deleteFramebuffer').length).toBe(2);
+
+    expect(scene.programCache.size).toBe(0);
+    expect(scene.activeMeshProgram).toBeNull();
+    expect(scene.ibl).toBeNull();
+    expect(scene.iblBakeFramebuffer).toBeNull();
+    expect(scene.environmentSourceCube).toBeNull();
+    expect(scene.shadowTarget).toBeNull();
+    expect(scene.shadow).toBeNull();
+    expect(scene.skinPalette).toBeNull();
+  });
+});
+
+describe('ensureGlSkinPalette', () => {
+  it('creates the palette texture lazily on first call and reuses it after', () => {
+    const { state } = makeGlScene3DState();
+    expect(getGlScene3DRuntime(state).skinPalette).toBeNull();
+
+    const first = ensureGlSkinPalette(state);
+    expect(first).toBe(getGlScene3DRuntime(state).skinPalette);
+    expect(first.jointCapacity).toBe(0);
+
+    const second = ensureGlSkinPalette(state);
+    expect(second).toBe(first);
+  });
+});
+
+describe('getGlScene3DRuntime', () => {
+  it('lazily allocates one runtime per state and returns the same instance', () => {
+    const { state } = makeGlScene3DState();
+    const first = getGlScene3DRuntime(state);
+    expect(first.activeMeshProgram).toBeNull();
+    expect(first.blendedDrawList).toBeInstanceOf(Array);
+    expect(first.blendedPool).toBeInstanceOf(Array);
+    expect(first.materialRegistry).toBeInstanceOf(Map);
+    expect(first.opaqueDrawList).toBeInstanceOf(Array);
+    expect(first.opaquePool).toBeInstanceOf(Array);
+    expect(first.programCache).toBeInstanceOf(Map);
+    expect(getGlScene3DRuntime(state)).toBe(first);
+  });
+
+  it('gives each render state its own draw-entry pools, not shared singletons', () => {
+    const { state: stateA } = makeGlScene3DState();
+    const { state: stateB } = makeGlScene3DState();
+    const rtA = getGlScene3DRuntime(stateA);
+    const rtB = getGlScene3DRuntime(stateB);
+    expect(rtA.opaquePool).not.toBe(rtB.opaquePool);
+    expect(rtA.blendedPool).not.toBe(rtB.blendedPool);
+    expect(rtA.opaqueDrawList).not.toBe(rtB.opaqueDrawList);
+    expect(rtA.blendedDrawList).not.toBe(rtB.blendedDrawList);
+  });
+
+  it('surfaces its registry and upload cache through the header runtime slots', () => {
+    const { state } = makeGlScene3DState();
+    const scene = getGlScene3DRuntime(state);
+    const stateRuntime = state[EntityRuntimeKey] as GlRenderStateRuntime;
+    expect(stateRuntime.sceneMeshMaterialRegistry).toBe(scene.materialRegistry);
+    expect(stateRuntime.sceneMeshUploadCache).toBe(scene.uploadCache);
+  });
+});

package/src/glScene3DTime.test.ts

@@ -0,0 +1,31 @@
+import { makeGlScene3DState } from './glScene3DTestHelper';
+import { getGlScene3DTime, setGlScene3DTime } from './glScene3DTime';
+
+describe('getGlScene3DTime', () => {
+  it('defaults to 0 before any setGlScene3DTime', () => {
+    const { state } = makeGlScene3DState();
+    expect(getGlScene3DTime(state)).toBe(0);
+  });
+
+  it('returns the value set by setGlScene3DTime', () => {
+    const { state } = makeGlScene3DState();
+    setGlScene3DTime(state, 2.75);
+    expect(getGlScene3DTime(state)).toBe(2.75);
+  });
+});
+
+describe('setGlScene3DTime', () => {
+  it('overwrites the stored time on repeated calls', () => {
+    const { state } = makeGlScene3DState();
+    setGlScene3DTime(state, 1);
+    setGlScene3DTime(state, 4.5);
+    expect(getGlScene3DTime(state)).toBe(4.5);
+  });
+
+  it('keeps time per state (two states do not share)', () => {
+    const a = makeGlScene3DState();
+    const b = makeGlScene3DState();
+    setGlScene3DTime(a.state, 3);
+    expect(getGlScene3DTime(b.state)).toBe(0);
+  });
+});