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

package/src/blinnPhongWgpuMeshMaterialRenderer.test.ts

@@ -0,0 +1,82 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createBlinnPhongMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import type { Camera3D, Matrix3, Matrix4, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { BlinnPhongMaterialKind } from '@flighthq/types';
+
+import {
+  blinnPhongWgpuMeshMaterialRenderer,
+  registerBlinnPhongWgpuMaterial,
+} from './blinnPhongWgpuMeshMaterialRenderer';
+import { getWgpuMeshMaterialRenderer } from './wgpuMeshMaterialRegistry';
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+
+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[0] = 0;
+  data[1] = -1;
+  data[2] = 0;
+  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() as Matrix3,
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4() as Matrix4,
+  };
+}
+
+describe('blinnPhongWgpuMeshMaterialRenderer', () => {
+  it('bind selects a blinnphong pipeline and binds frame + material groups + uploads uniforms', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    blinnPhongWgpuMeshMaterialRenderer.bind(state, createBlinnPhongMaterial(), makeLights(), makeCamera());
+
+    const moduleCall = fake.calls.find((c) => c.name === 'createShaderModule');
+    const code = (moduleCall!.args[0] as { code: string }).code;
+    expect(code).toContain('const LIGHTING_BLINNPHONG : bool = true;');
+    expect(fake.calls.some((c) => c.name === 'setPipeline')).toBe(true);
+    expect(fake.calls.filter((c) => c.name === 'setBindGroup').length).toBeGreaterThanOrEqual(2);
+    expect(fake.calls.some((c) => c.name === 'writeBuffer')).toBe(true);
+  });
+
+  it('draw uploads geometry and issues an indexed draw over the subset range', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const proxy = makeProxy();
+    const geometry = createBoxMeshGeometry();
+    blinnPhongWgpuMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    blinnPhongWgpuMeshMaterialRenderer.draw(state, proxy, geometry);
+
+    const drawCall = fake.calls.find((c) => c.name === 'drawIndexed');
+    expect(drawCall).toBeDefined();
+    expect(drawCall!.args[0]).toBe(proxy.subset.indexCount);
+    expect(drawCall!.args[2]).toBe(proxy.subset.indexOffset);
+  });
+
+  it('draw is a no-op when bind has not selected a pipeline', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    blinnPhongWgpuMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(fake.calls.some((c) => c.name === 'drawIndexed')).toBe(false);
+  });
+});
+
+describe('registerBlinnPhongWgpuMaterial', () => {
+  it('installs the renderer for BlinnPhongMaterialKind', () => {
+    const { state } = makeWgpuScene3DState();
+    registerBlinnPhongWgpuMaterial(state);
+    expect(getWgpuMeshMaterialRenderer(state, BlinnPhongMaterialKind)).toBe(blinnPhongWgpuMeshMaterialRenderer);
+  });
+});

package/src/clearcoatPbrWgpuMeshMaterialRenderer.test.ts

@@ -0,0 +1,90 @@
+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 {
+  clearcoatPbrWgpuMeshMaterialRenderer,
+  registerClearcoatPbrWgpuMaterial,
+} from './clearcoatPbrWgpuMeshMaterialRenderer';
+import { getWgpuMeshMaterialRenderer } from './wgpuMeshMaterialRegistry';
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+
+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({ clearcoat: 1 }),
+    normalMatrix: createMatrix3() as Matrix3,
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4() as Matrix4,
+  };
+}
+
+describe('clearcoatPbrWgpuMeshMaterialRenderer', () => {
+  it('bind selects a pipeline and binds frame + material groups + uploads uniforms', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    clearcoatPbrWgpuMeshMaterialRenderer.bind(
+      state,
+      createClearcoatPbrMaterial({ clearcoat: 1 }),
+      makeLights(),
+      makeCamera(),
+    );
+
+    expect(fake.calls.some((c) => c.name === 'createRenderPipeline')).toBe(true);
+    expect(fake.calls.some((c) => c.name === 'setPipeline')).toBe(true);
+    expect(fake.calls.filter((c) => c.name === 'setBindGroup').length).toBeGreaterThanOrEqual(2);
+    expect(fake.calls.some((c) => c.name === 'writeBuffer')).toBe(true);
+  });
+
+  it('bind compiles the CLEARCOAT extension variant', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    clearcoatPbrWgpuMeshMaterialRenderer.bind(state, createClearcoatPbrMaterial(), makeLights(), makeCamera());
+    const moduleCall = fake.calls.find((c) => c.name === 'createShaderModule');
+    const code = (moduleCall!.args[0] as { code: string }).code;
+    expect(code).toContain('const CLEARCOAT : bool = true;');
+  });
+
+  it('draw uploads geometry and issues an indexed draw over the subset range', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const proxy = makeProxy();
+    clearcoatPbrWgpuMeshMaterialRenderer.bind(state, proxy.material, makeLights(), makeCamera());
+    clearcoatPbrWgpuMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+
+    const drawCall = fake.calls.find((c) => c.name === 'drawIndexed');
+    expect(drawCall).toBeDefined();
+    expect(drawCall!.args[0]).toBe(proxy.subset.indexCount);
+    expect(drawCall!.args[2]).toBe(proxy.subset.indexOffset);
+  });
+
+  it('draw is a no-op when bind has not selected a pipeline', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    clearcoatPbrWgpuMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(fake.calls.some((c) => c.name === 'drawIndexed')).toBe(false);
+  });
+});
+
+describe('registerClearcoatPbrWgpuMaterial', () => {
+  it('installs the renderer for ClearcoatPbrMaterialKind', () => {
+    const { state } = makeWgpuScene3DState();
+    registerClearcoatPbrWgpuMaterial(state);
+    expect(getWgpuMeshMaterialRenderer(state, ClearcoatPbrMaterialKind)).toBe(clearcoatPbrWgpuMeshMaterialRenderer);
+  });
+});

package/src/customShaderWgpuMeshMaterialRenderer.test.ts

@@ -0,0 +1,207 @@
+import { createCamera3D } from '@flighthq/camera';
+import { createMatrix3, createMatrix4 } from '@flighthq/geometry';
+import { createCustomShaderMaterial } from '@flighthq/materials';
+import { createBoxMeshGeometry } from '@flighthq/mesh';
+import { createTexture } from '@flighthq/texture';
+import type { Camera3D, ImageResource, Scene3DLightBlock, Scene3DRenderProxy } from '@flighthq/types';
+import { CustomShaderMaterialKind } from '@flighthq/types';
+
+import {
+  customShaderWgpuMeshMaterialRenderer,
+  getWgpuCustomMaterialShaderSource,
+  registerCustomShaderWgpuMaterial,
+  registerWgpuCustomMaterialShader,
+} from './customShaderWgpuMeshMaterialRenderer';
+import { getWgpuMeshMaterialRenderer } from './wgpuMeshMaterialRegistry';
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+
+const SOURCE = `
+@group(0) @binding(0) var<uniform> frame: vec4f;
+@group(1) @binding(0) var<uniform> draw: vec4f;
+@group(2) @binding(0) var<uniform> user: vec4f;
+@vertex fn vs_main(@location(0) position: vec3f) -> @builtin(position) vec4f {
+  return vec4f(position, 1.0);
+}
+@fragment fn fs_main() -> @location(0) vec4f { return user; }
+`;
+
+const NO_LIGHTS: Scene3DLightBlock = {
+  ambientCount: 0,
+  data: new Float32Array(12),
+  directionalCount: 0,
+  hemisphereCount: 0,
+  pointCount: 0,
+  spotCount: 0,
+  version: 1,
+};
+
+function makeCamera(): Camera3D {
+  return createCamera3D({
+    far: 100,
+    near: 0.1,
+    projection: { aspect: 1, fovY: Math.PI / 3, kind: 'perspective' },
+  });
+}
+
+function makeProxy(): Scene3DRenderProxy {
+  const geometry = createBoxMeshGeometry();
+  return {
+    material: createCustomShaderMaterial({ shaderKey: 'test' }),
+    normalMatrix: createMatrix3(),
+    subset: geometry.subsets[0],
+    worldMatrix: createMatrix4(),
+  };
+}
+
+describe('customShaderWgpuMeshMaterialRenderer', () => {
+  it('reuses Frame/Draw layouts and binds reserved user + texture groups', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    registerWgpuCustomMaterialShader(state, 'test', SOURCE);
+    customShaderWgpuMeshMaterialRenderer.bind(
+      state,
+      createCustomShaderMaterial({ shaderKey: 'test' }),
+      NO_LIGHTS,
+      makeCamera(),
+    );
+
+    const layoutCall = fake.calls.find((call) => call.name === 'createPipelineLayout');
+    const descriptor = layoutCall?.args[0] as GPUPipelineLayoutDescriptor;
+    expect(descriptor.bindGroupLayouts).toHaveLength(4);
+    expect(fake.calls.filter((call) => call.name === 'setBindGroup').map((call) => call.args[0])).toEqual([0, 2, 3]);
+  });
+
+  it('packs logical values into alphabetically sorted vec4 slots', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    registerWgpuCustomMaterialShader(state, 'test', SOURCE);
+    customShaderWgpuMeshMaterialRenderer.bind(
+      state,
+      createCustomShaderMaterial({
+        shaderKey: 'test',
+        uniforms: { zeta: [5, 6], alpha: 2 },
+      }),
+      NO_LIGHTS,
+      makeCamera(),
+    );
+
+    const write = fake.calls.find((call) => call.name === 'writeBuffer');
+    const packed = new Float32Array(write!.args[2] as ArrayBuffer);
+    expect(Array.from(packed.slice(0, 8))).toEqual([2, 0, 0, 0, 5, 6, 0, 0]);
+  });
+
+  it('reuses the group(3) bind group when the texture bag is unchanged', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const material = createCustomShaderMaterial({
+      shaderKey: 'test',
+      textures: { map: createTexture() },
+    });
+    registerWgpuCustomMaterialShader(state, 'test', SOURCE);
+    customShaderWgpuMeshMaterialRenderer.bind(state, material, NO_LIGHTS, makeCamera());
+    const firstCount = fake.calls.filter((call) => call.name === 'createBindGroup').length;
+
+    customShaderWgpuMeshMaterialRenderer.bind(state, material, NO_LIGHTS, makeCamera());
+    expect(fake.calls.filter((call) => call.name === 'createBindGroup')).toHaveLength(firstCount);
+  });
+
+  it('rebuilds group(3) for readiness, replacement, sampler, key, and bag-order changes', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    state.device.createSampler = ((descriptor: GPUSamplerDescriptor) => {
+      fake.calls.push({ name: 'createSampler', args: [descriptor] });
+      return { descriptor } as unknown as GPUSampler;
+    }) as GPUDevice['createSampler'];
+    const first = createTexture();
+    const second = createTexture();
+    const material = createCustomShaderMaterial({
+      shaderKey: 'test',
+      textures: { first, second },
+    });
+    registerWgpuCustomMaterialShader(state, 'test', SOURCE);
+    const bindGroupCount = () => fake.calls.filter((call) => call.name === 'createBindGroup').length;
+    const bindAndExpectRebuild = (previous: number): number => {
+      customShaderWgpuMeshMaterialRenderer.bind(state, material, NO_LIGHTS, makeCamera());
+      const next = bindGroupCount();
+      expect(next).toBeGreaterThan(previous);
+      return next;
+    };
+
+    let count = bindAndExpectRebuild(0);
+    first.sampler.wrapU = 'repeat';
+    count = bindAndExpectRebuild(count);
+
+    first.image = makeImageResource(1);
+    count = bindAndExpectRebuild(count);
+    first.image = makeImageResource(2);
+    count = bindAndExpectRebuild(count);
+
+    material.textures = { renamed: first, second };
+    count = bindAndExpectRebuild(count);
+    material.textures = { second, renamed: first };
+    bindAndExpectRebuild(count);
+  });
+
+  it('draws an indexed subset after a valid bind and skips a missing shader', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const geometry = createBoxMeshGeometry();
+    const proxy = makeProxy();
+    customShaderWgpuMeshMaterialRenderer.bind(state, proxy.material, NO_LIGHTS, makeCamera());
+    customShaderWgpuMeshMaterialRenderer.draw(state, proxy, geometry);
+    expect(fake.calls.some((call) => call.name === 'drawIndexed')).toBe(false);
+
+    registerWgpuCustomMaterialShader(state, 'test', SOURCE);
+    customShaderWgpuMeshMaterialRenderer.bind(state, proxy.material, NO_LIGHTS, makeCamera());
+    customShaderWgpuMeshMaterialRenderer.draw(state, proxy, geometry);
+    expect(fake.calls.some((call) => call.name === 'drawIndexed')).toBe(true);
+  });
+
+  it('skips a user block that exceeds the fixed packing capacity', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    registerWgpuCustomMaterialShader(state, 'test', SOURCE);
+    const uniforms: Record<string, number> = {};
+    for (let i = 0; i < 33; i++) uniforms[`value${i}`] = i;
+    customShaderWgpuMeshMaterialRenderer.bind(
+      state,
+      createCustomShaderMaterial({ shaderKey: 'test', uniforms }),
+      NO_LIGHTS,
+      makeCamera(),
+    );
+    expect(fake.calls.some((call) => call.name === 'createRenderPipeline')).toBe(false);
+  });
+});
+
+function makeImageResource(version: number): ImageResource {
+  return {
+    alphaType: 'straight',
+    compressed: null,
+    data: null,
+    format: 'rgba8unorm',
+    height: 1,
+    source: {} as CanvasImageSource,
+    version,
+    width: 1,
+  } as ImageResource;
+}
+
+describe('getWgpuCustomMaterialShaderSource', () => {
+  it('returns null for an unknown key', () => {
+    const { state } = makeWgpuScene3DState();
+    expect(getWgpuCustomMaterialShaderSource(state, 'unknown')).toBeNull();
+  });
+});
+
+describe('registerCustomShaderWgpuMaterial', () => {
+  it('installs the renderer for CustomShaderMaterialKind', () => {
+    const { state } = makeWgpuScene3DState();
+    registerCustomShaderWgpuMaterial(state);
+    expect(getWgpuMeshMaterialRenderer(state, CustomShaderMaterialKind)).toBe(customShaderWgpuMeshMaterialRenderer);
+  });
+});
+
+describe('registerWgpuCustomMaterialShader', () => {
+  it('registers WGSL by key with last-write-wins lookup', () => {
+    const { state } = makeWgpuScene3DState();
+    registerWgpuCustomMaterialShader(state, 'ripple', SOURCE);
+    expect(getWgpuCustomMaterialShaderSource(state, 'ripple')).toBe(SOURCE);
+    registerWgpuCustomMaterialShader(state, 'ripple', `${SOURCE}\n// edited`);
+    expect(getWgpuCustomMaterialShaderSource(state, 'ripple')).toContain('edited');
+    expect(getWgpuCustomMaterialShaderSource(state, 'missing')).toBeNull();
+  });
+});

package/src/depthWgpuMeshMaterialRenderer.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 { depthWgpuMeshMaterialRenderer, registerDepthWgpuMaterial } from './depthWgpuMeshMaterialRenderer';
+import { getWgpuMeshMaterialRenderer } from './wgpuMeshMaterialRegistry';
+import { makeWgpuScene3DState } from './wgpuScene3DTestHelper';
+
+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('depthWgpuMeshMaterialRenderer', () => {
+  it('bind selects the depth pipeline and writes the frame + material uniforms', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    depthWgpuMeshMaterialRenderer.bind(state, createDepthMaterial({ far: 50, near: 1 }), NO_LIGHTS, makeCamera());
+    expect(fake.calls.some((c) => c.name === 'createRenderPipeline')).toBe(true);
+    expect(fake.calls.some((c) => c.name === 'setPipeline')).toBe(true);
+    expect(fake.calls.some((c) => c.name === 'writeBuffer')).toBe(true);
+    expect(fake.calls.filter((c) => c.name === 'setBindGroup').length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('draw issues an indexed draw over the subset after bind', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    const proxy = makeProxy();
+    depthWgpuMeshMaterialRenderer.bind(state, proxy.material, NO_LIGHTS, makeCamera());
+    depthWgpuMeshMaterialRenderer.draw(state, proxy, createBoxMeshGeometry());
+    const drawCall = fake.calls.find((c) => c.name === 'drawIndexed');
+    expect(drawCall).toBeDefined();
+    expect(drawCall!.args[0]).toBe(proxy.subset.indexCount);
+  });
+
+  it('draw is a no-op when bind has not selected a pipeline', () => {
+    const { fake, state } = makeWgpuScene3DState();
+    depthWgpuMeshMaterialRenderer.draw(state, makeProxy(), createBoxMeshGeometry());
+    expect(fake.calls.some((c) => c.name === 'drawIndexed')).toBe(false);
+  });
+});
+
+describe('registerDepthWgpuMaterial', () => {
+  it('installs the renderer for DepthMaterialKind', () => {
+    const { state } = makeWgpuScene3DState();
+    registerDepthWgpuMaterial(state);
+    expect(getWgpuMeshMaterialRenderer(state, DepthMaterialKind)).toBe(depthWgpuMeshMaterialRenderer);
+  });
+});