@flighthq/render 0.1.0

package/src/renderer.test.ts

@@ -0,0 +1,128 @@
+import type { DisplayObjectClipHooks, Renderer, RenderState } from '@flighthq/types';
+
+import {
+  copyAllRenderersFromRenderState,
+  copyRenderersFromRenderState,
+  noopRendererData,
+  registerRenderer,
+} from './renderer';
+import { createRenderState, getRenderStateRuntime } from './renderState';
+
+describe('copyAllRenderersFromRenderState', () => {
+  it('copies all registrations and the clip hooks from source to target', () => {
+    const source = createRenderState();
+    const target = createRenderState();
+    const kind = 'kind';
+    const renderer = { createData: vi.fn(), submit: vi.fn() } as unknown as Renderer;
+    const hooks = {
+      finalize: vi.fn(),
+      popClip: vi.fn(),
+      pushClip: vi.fn(),
+    } as unknown as DisplayObjectClipHooks;
+    registerRenderer(source, kind, renderer);
+    source.displayObjectClipHooks = hooks;
+
+    copyAllRenderersFromRenderState(target, source);
+
+    expect(getRenderStateRuntime(target).rendererMap.get(kind)).toBe(renderer);
+    expect(target.displayObjectClipHooks).toBe(hooks);
+  });
+
+  it('is a no-op when source has no registrations', () => {
+    const source = createRenderState();
+    const target = createRenderState();
+    copyAllRenderersFromRenderState(target, source);
+    expect(getRenderStateRuntime(target).rendererMap.size).toBe(0);
+    expect(target.displayObjectClipHooks).toBeNull();
+  });
+});
+
+describe('copyRenderersFromRenderState', () => {
+  it('copies all renderer registrations from source to target', () => {
+    const source = createRenderState();
+    const target = createRenderState();
+    const kind = 'kind';
+    const renderer = { createData: vi.fn(), submit: vi.fn() } as unknown as Renderer;
+    registerRenderer(source, kind, renderer);
+    copyRenderersFromRenderState(target, source);
+    expect(getRenderStateRuntime(target).rendererMap.get(kind)).toBe(renderer);
+  });
+
+  it('is a no-op when source has no renderer registrations', () => {
+    const source = createRenderState();
+    const target = createRenderState();
+    copyRenderersFromRenderState(target, source);
+    expect(getRenderStateRuntime(target).rendererMap.size).toBe(0);
+  });
+
+  it('does not affect source rendererMapId', () => {
+    const source = createRenderState();
+    const target = createRenderState();
+    const kind = 'kind';
+    const renderer = { createData: vi.fn(), submit: vi.fn() } as unknown as Renderer;
+    registerRenderer(source, kind, renderer);
+    const sourceIdBeforeCopy = getRenderStateRuntime(source).rendererMapId;
+    copyRenderersFromRenderState(target, source);
+    expect(getRenderStateRuntime(source).rendererMapId).toBe(sourceIdBeforeCopy);
+  });
+});
+
+describe('noopRendererData', () => {
+  it('returns null', () => {
+    const state = createRenderState();
+    expect(noopRendererData(state, {} as any)).toBeNull();
+  });
+});
+
+describe('registerRenderer', () => {
+  let state: RenderState;
+  let kindA: string;
+  let kindB: string;
+  let renderer1: Renderer;
+  let renderer2: Renderer;
+
+  beforeEach(() => {
+    kindA = 'kindA';
+    kindB = 'kindB';
+    renderer1 = { render: vi.fn() } as unknown as Renderer;
+    renderer2 = { render: vi.fn() } as unknown as Renderer;
+    state = createRenderState();
+  });
+
+  it('should register a new renderer', () => {
+    expect(getRenderStateRuntime(state).rendererMap.has(kindA)).toBe(false);
+    registerRenderer(state, kindA, renderer1);
+    expect(getRenderStateRuntime(state).rendererMap.get(kindA)).toBe(renderer1);
+    expect(getRenderStateRuntime(state).rendererMapId).toBe(1);
+  });
+
+  it('should increment rendererMapId for each new renderer', () => {
+    registerRenderer(state, kindA, renderer1);
+    const idAfterFirst = getRenderStateRuntime(state).rendererMapId;
+    registerRenderer(state, kindB, renderer2);
+    expect(getRenderStateRuntime(state).rendererMap.get(kindB)).toBe(renderer2);
+    expect(getRenderStateRuntime(state).rendererMapId).toBe(idAfterFirst + 1);
+  });
+
+  it('should not increment rendererMapId if the same renderer is registered', () => {
+    registerRenderer(state, kindA, renderer1);
+    const idBefore = getRenderStateRuntime(state).rendererMapId;
+    registerRenderer(state, kindA, renderer1);
+    expect(getRenderStateRuntime(state).rendererMap.get(kindA)).toBe(renderer1);
+    expect(getRenderStateRuntime(state).rendererMapId).toBe(idBefore);
+  });
+
+  it('should update renderer and increment rendererMapId if different renderer is registered', () => {
+    registerRenderer(state, kindA, renderer1);
+    const idBefore = getRenderStateRuntime(state).rendererMapId;
+    registerRenderer(state, kindA, renderer2);
+    expect(getRenderStateRuntime(state).rendererMap.get(kindA)).toBe(renderer2);
+    expect(getRenderStateRuntime(state).rendererMapId).toBe(idBefore + 1);
+  });
+
+  it('should wrap around rendererMapId correctly using >>> 0', () => {
+    getRenderStateRuntime(state).rendererMapId = 0xffffffff;
+    registerRenderer(state, kindA, renderer1);
+    expect(getRenderStateRuntime(state).rendererMapId).toBe(0);
+  });
+});

package/src/sceneRender.test.ts

@@ -0,0 +1,207 @@
+import { createCamera, createPerspectiveProjection, setCameraViewMatrix4FromLookAt } from '@flighthq/camera';
+import { createAabb } from '@flighthq/geometry';
+import { createAmbientLight, createDirectionalLight } from '@flighthq/lighting';
+import { unpackColorToLinear } from '@flighthq/materials';
+import { computeMeshGeometryBounds, createBoxMeshGeometry } from '@flighthq/mesh';
+import { addNodeChild, invalidateNodeLocalTransform } from '@flighthq/node';
+import { createMesh, createScene } from '@flighthq/scene';
+import type { Camera, Material, MeshGeometry, SceneLightBlock, SceneLights } from '@flighthq/types';
+import { describe, expect, it } from 'vitest';
+
+import { createRenderState } from './renderState';
+import { packSceneLightBlock, prepareSceneRender } from './sceneRender';
+
+function boundedBox(): MeshGeometry {
+  const geometry = createBoxMeshGeometry(2, 2, 2);
+  const bounds = createAabb();
+  computeMeshGeometryBounds(bounds, geometry);
+  geometry.bounds = bounds;
+  return geometry;
+}
+
+function frontCamera(): Camera {
+  const camera = createCamera({
+    far: 100,
+    near: 0.1,
+    projection: createPerspectiveProjection({ aspect: 1, fovY: Math.PI / 3 }),
+  });
+  setCameraViewMatrix4FromLookAt(camera, { x: 0, y: 0, z: 10 }, { x: 0, y: 0, z: 0 }, { x: 0, y: 1, z: 0 });
+  return camera;
+}
+
+function emptyLights(): SceneLights {
+  return { ambient: null, directional: null };
+}
+
+function newLightBlock(): SceneLightBlock {
+  return {
+    ambientCount: 0,
+    data: new Float32Array(12),
+    directionalCount: 0,
+    hemisphereCount: 0,
+    pointCount: 0,
+    spotCount: 0,
+    version: 0,
+  };
+}
+
+describe('packSceneLightBlock', () => {
+  it('zeroes the block and clears counts when no lights are present', () => {
+    const block = newLightBlock();
+    block.data[0] = 5;
+    packSceneLightBlock(block, emptyLights());
+    expect(block.directionalCount).toBe(0);
+    expect(block.ambientCount).toBe(0);
+    expect(block.data[0]).toBe(0);
+  });
+
+  it('packs the directional direction and linear, premultiplied radiance', () => {
+    const block = newLightBlock();
+    const directional = createDirectionalLight({ color: 0xffffffff, direction: { x: 0, y: -1, z: 0 }, intensity: 2 });
+    packSceneLightBlock(block, { ambient: null, directional });
+    expect(block.directionalCount).toBe(1);
+    expect(block.data[0]).toBeCloseTo(0);
+    expect(block.data[1]).toBeCloseTo(-1);
+    expect(block.data[2]).toBeCloseTo(0);
+    const expected = unpackColorToLinear([0, 0, 0, 0], 0xffffffff);
+    expect(block.data[4]).toBeCloseTo(expected[0] * 2);
+    expect(block.data[5]).toBeCloseTo(expected[1] * 2);
+    expect(block.data[6]).toBeCloseTo(expected[2] * 2);
+  });
+
+  it('packs the ambient radiance into the ambient slot', () => {
+    const block = newLightBlock();
+    const ambient = createAmbientLight({ color: 0xffffffff, intensity: 0.5 });
+    packSceneLightBlock(block, { ambient, directional: null });
+    expect(block.ambientCount).toBe(1);
+    const expected = unpackColorToLinear([0, 0, 0, 0], 0xffffffff);
+    expect(block.data[8]).toBeCloseTo(expected[0] * 0.5);
+    expect(block.data[9]).toBeCloseTo(expected[1] * 0.5);
+    expect(block.data[10]).toBeCloseTo(expected[2] * 0.5);
+  });
+
+  it('bumps version when the packed block changes', () => {
+    const block = newLightBlock();
+    packSceneLightBlock(block, emptyLights());
+    const v = block.version;
+    packSceneLightBlock(block, {
+      ambient: createAmbientLight({ color: 0xffffffff, intensity: 0.5 }),
+      directional: null,
+    });
+    expect(block.version).toBe(v + 1);
+  });
+
+  it('does not bump version when re-packed with identical lights', () => {
+    const block = newLightBlock();
+    const lights = { ambient: createAmbientLight({ color: 0xffffffff, intensity: 0.5 }), directional: null };
+    packSceneLightBlock(block, lights);
+    const v = block.version;
+    packSceneLightBlock(block, lights);
+    expect(block.version).toBe(v);
+  });
+
+  it('decodes sRgb color to linear (a mid-gray channel is darker in linear)', () => {
+    const block = newLightBlock();
+    const ambient = createAmbientLight({ color: 0x808080ff, intensity: 1 });
+    packSceneLightBlock(block, { ambient, directional: null });
+    expect(block.data[8]).toBeLessThan(0x80 / 0xff);
+    expect(block.data[8]).toBeGreaterThan(0);
+  });
+});
+
+describe('prepareSceneRender', () => {
+  it('returns the lit, view-projected frame with the visible mesh', () => {
+    const state = createRenderState();
+    const scene = createScene();
+    const mesh = createMesh(boundedBox(), [null]);
+    addNodeChild(scene, mesh);
+
+    const list = prepareSceneRender(state, scene, frontCamera(), {
+      ambient: createAmbientLight(),
+      directional: createDirectionalLight(),
+    });
+
+    expect(list.meshCount).toBe(1);
+    expect(list.visibleMeshes[0]).toBe(mesh);
+    expect(list.lights.directionalCount).toBe(1);
+    expect(list.lights.ambientCount).toBe(1);
+  });
+
+  it('computes a non-identity view-projection', () => {
+    const state = createRenderState();
+    const scene = createScene();
+    const list = prepareSceneRender(state, scene, frontCamera(), emptyLights());
+    // A perspective view-projection is not the identity matrix.
+    expect(list.viewProjection.m[15]).not.toBe(1);
+  });
+
+  it('culls a mesh placed far behind the camera', () => {
+    const state = createRenderState();
+    const scene = createScene();
+    const mesh = createMesh(boundedBox(), [null]);
+    mesh.localMatrix.m[14] = 1000;
+    invalidateNodeLocalTransform(mesh);
+    addNodeChild(scene, mesh);
+
+    const list = prepareSceneRender(state, scene, frontCamera(), emptyLights());
+    expect(list.meshCount).toBe(0);
+  });
+
+  it('keeps a mesh whose geometry has no cached bounds', () => {
+    const state = createRenderState();
+    const scene = createScene();
+    const mesh = createMesh(createBoxMeshGeometry(), [null]);
+    mesh.geometry.bounds = null;
+    mesh.localMatrix.m[14] = 1000;
+    invalidateNodeLocalTransform(mesh);
+    addNodeChild(scene, mesh);
+
+    const list = prepareSceneRender(state, scene, frontCamera(), emptyLights());
+    expect(list.meshCount).toBe(1);
+  });
+
+  it('skips disabled subtrees', () => {
+    const state = createRenderState();
+    const scene = createScene();
+    const group = createScene({ enabled: false });
+    const mesh = createMesh(boundedBox(), [null]);
+    addNodeChild(group, mesh);
+    addNodeChild(scene, group);
+
+    const list = prepareSceneRender(state, scene, frontCamera(), emptyLights());
+    expect(list.meshCount).toBe(0);
+  });
+
+  it('resolves world transforms through nested groups', () => {
+    const state = createRenderState();
+    const scene = createScene();
+    const group = createScene();
+    const mesh = createMesh(boundedBox(), [null]);
+    addNodeChild(group, mesh);
+    addNodeChild(scene, group);
+    group.localMatrix.m[12] = 1;
+    invalidateNodeLocalTransform(group);
+
+    const list = prepareSceneRender(state, scene, frontCamera(), emptyLights());
+    expect(list.meshCount).toBe(1);
+    expect(list.visibleMeshes[0]).toBe(mesh);
+  });
+
+  it('reuses the same list per render state across calls', () => {
+    const state = createRenderState();
+    const scene = createScene();
+    const first = prepareSceneRender(state, scene, frontCamera(), emptyLights());
+    const second = prepareSceneRender(state, scene, frontCamera(), emptyLights());
+    expect(second).toBe(first);
+  });
+
+  it('honors a positional material on a mesh', () => {
+    const state = createRenderState();
+    const scene = createScene();
+    const material = { kind: 'TestMaterial' } as unknown as Material;
+    const mesh = createMesh(boundedBox(), [material]);
+    addNodeChild(scene, mesh);
+    const list = prepareSceneRender(state, scene, frontCamera(), emptyLights());
+    expect(list.visibleMeshes[0].materials[0]).toBe(material);
+  });
+});