@forgeax/engine-runtime 0.1.3 → 0.1.6

package/src/__tests__/render-feature-prepared-graphics.fixture.ts

@@ -0,0 +1,104 @@
+import { World } from '@forgeax/engine-ecs';
+import type {
+  Renderer,
+  RenderFeature,
+  RenderFeaturePlan,
+  RenderFrameInput,
+} from '@forgeax/engine-render';
+import { Camera } from '@forgeax/engine-render';
+import { Transform } from '@forgeax/engine-scene';
+import { ok } from '@forgeax/engine-types';
+
+export type PreparedFeatureMode = 'accepted' | 'empty' | 'mismatch' | 'recovery';
+
+export const preparedManifest = `data:application/json,${encodeURIComponent(
+  JSON.stringify({
+    schemaVersion: '1.0.0',
+    entries: [
+      { hash: 'pbr00000', wgsl: '/* pbr stub */', glsl: '', bindings: '' },
+      { hash: 'unlit000', wgsl: '/* unlit stub */', glsl: '', bindings: '' },
+      { hash: 'tonemap0', wgsl: '/* tonemap stub */', glsl: '', bindings: '' },
+    ],
+  }),
+)}`;
+
+export function preparedFeature(
+  identity: string,
+  mode: PreparedFeatureMode = 'accepted',
+): RenderFeature<{ readonly draw: boolean }> {
+  let firstPlan = true;
+
+  return {
+    identity,
+    extract: () => ok({ draw: mode !== 'empty' }),
+    plan: (data, context) => {
+      if (!data.draw) return ok({ resources: [], passes: [] });
+      const target = context.targets.find((candidate) => candidate.kind === 'color');
+      const targetName = target?.name ?? 'swapchain';
+      const mismatch = mode === 'mismatch' || (mode === 'recovery' && firstPlan);
+      firstPlan = false;
+      const plan: RenderFeaturePlan = {
+        resources: [
+          {
+            kind: 'graphics-program',
+            name: 'forward-program',
+            program: {
+              shader: 'forgeax::tonemap',
+              vertexLayout: 'position',
+              colorFormats: [target?.format ?? 'rgba16float'],
+            },
+          },
+          {
+            kind: 'graphics-bindings',
+            name: 'forward-bindings',
+            program: 'forward-program',
+            values: {},
+          },
+          {
+            kind: 'graphics-bindings',
+            name: 'input-bindings',
+            program: 'forward-program',
+            values: { group: 1 },
+          },
+          {
+            kind: 'vertex-data',
+            name: 'triangle-vertices',
+            layout: 'position',
+            data: new Float32Array([0, 0, 0, 1, 0, 0, 0, 1, 0]),
+          },
+        ],
+        passes: [
+          {
+            kind: 'raster',
+            name: 'forward',
+            colorAttachments: [{ target: targetName, loadOp: 'load', storeOp: 'store' }],
+            draws: [
+              {
+                program: mismatch ? 'forged-program' : 'forward-program',
+                bindings: ['forward-bindings', 'input-bindings'],
+                vertexData: [{ slot: 0, resource: 'triangle-vertices' }],
+                draw: { kind: 'draw', vertexCount: 3, instanceCount: 1 },
+              },
+            ],
+          },
+        ],
+      };
+      return ok(plan);
+    },
+  };
+}
+
+export function preparedWorld(): World {
+  const world = new World();
+  world.spawn(
+    { component: Transform, data: { pos: [0, 0, 3], quat: [0, 0, 0, 1], scale: [1, 1, 1] } },
+    { component: Camera, data: { fov: 60, aspect: 1, near: 0.1, far: 100 } },
+  );
+  return world;
+}
+
+export function frameRequest(
+  lease: Parameters<Renderer['draw']>[0]['leases'][number],
+): RenderFrameInput {
+  return { leases: [lease], camera: { lease }, environment: { lease } };
+}

package/src/__tests__/render-feature-prepared-graphics.integration.test.ts

@@ -1,264 +1,56 @@
 import { World } from '@forgeax/engine-ecs';
-import type {
-  RenderFeature,
-  RenderFeatureDrawRecord,
-  RenderFeaturePreparedRef,
-  RenderPipeline,
-} from '@forgeax/engine-render';
-import { createRenderFeatureTarget, createRenderPipelineTarget } from '@forgeax/engine-render';
-import type { RhiDevice } from '@forgeax/engine-rhi';
 import { rhi } from '@forgeax/engine-rhi-null';
-import { err, ok } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import { createRenderer } from '../createRenderer';
-
-const manifest = `data:application/json,${encodeURIComponent(
-  JSON.stringify({
-    schemaVersion: '1.0.0',
-    entries: [
-      { hash: 'pbr00000', wgsl: '/* pbr stub */', glsl: '', bindings: '' },
-      { hash: 'unlit000', wgsl: '/* unlit stub */', glsl: '', bindings: '' },
-      { hash: 'tonemap0', wgsl: '/* tonemap stub */', glsl: '', bindings: '' },
-    ],
-    materialShaders: [
-      {
-        identifier: 'forgeax::default-standard-pbr',
-        sourcePath: 'forgeax::default-standard-pbr.wgsl',
-        composedWgsl: '/* stub */',
-        paramSchema: '[]',
-        variants: [],
-      },
-      {
-        identifier: 'forgeax::default-unlit',
-        sourcePath: 'forgeax::default-unlit.wgsl',
-        composedWgsl: '/* stub */',
-        paramSchema: '[]',
-        variants: [],
-      },
-    ],
-  }),
-)}`;
+import { constructRendererHost } from '../../../render/src/construct-renderer';
+import {
+  frameRequest,
+  preparedFeature,
+  preparedManifest,
+  preparedWorld,
+} from './render-feature-prepared-graphics.fixture';
 
 function canvas(): HTMLCanvasElement {
-  return {
-    width: 64,
-    height: 64,
-    getContext: () => null,
-    addEventListener: () => undefined,
-    removeEventListener: () => undefined,
-  } as unknown as HTMLCanvasElement;
-}
-
-function observeDrawCalls(device: RhiDevice): () => number {
-  let count = 0;
-  const createCommandEncoder = device.createCommandEncoder.bind(device);
-  device.createCommandEncoder = (descriptor) => {
-    const result = createCommandEncoder(descriptor);
-    if (!result.ok) return result;
-    const encoder = result.value;
-    const beginRenderPass = encoder.beginRenderPass.bind(encoder);
-    encoder.beginRenderPass = (passDescriptor) => {
-      const pass = beginRenderPass(passDescriptor);
-      const draw = pass.draw.bind(pass);
-      const drawIndexed = pass.drawIndexed.bind(pass);
-      pass.draw = (...args) => {
-        count += 1;
-        draw(...args);
-      };
-      pass.drawIndexed = (...args) => {
-        count += 1;
-        drawIndexed(...args);
-      };
-      return pass;
-    };
-    return result;
-  };
-  return () => count;
-}
-
-function pipeline(): RenderPipeline {
-  return {
-    build: ({ graph, contributeFeatures }) => {
-      const scene = createRenderPipelineTarget(graph, 'prepared-scene', {
-        format: 'rgba8unorm',
-        size: 'surface',
-      });
-      if (!scene.ok) return scene;
-      const base = graph.addRasterPass('base', {
-        accesses: [{ resource: scene.value.view, usage: 'color-attachment' }],
-        colorAttachments: [
-          {
-            view: scene.value.view,
-            loadOp: 'clear',
-            storeOp: 'store',
-            clearValue: { r: 0, g: 0, b: 0, a: 1 },
-          },
-        ],
-        encode: () => undefined,
-      });
-      if (!base.ok) return base;
-      return contributeFeatures([
-        {
-          kind: 'scene-color',
-          texture: scene.value.texture,
-          view: scene.value.view,
-          format: scene.value.format,
-          sampleCount: 1,
-        },
-      ]);
-    },
-  };
+  return { width: 64, height: 64, getContext: () => null } as unknown as HTMLCanvasElement;
 }
 
-function preparedFeature(
-  identity: string,
-  draws: readonly RenderFeatureDrawRecord[],
-): RenderFeature<{ readonly draws: readonly RenderFeatureDrawRecord[] }> {
-  let pipelineRef: RenderFeaturePreparedRef<'pipeline'> | undefined;
-  let bindingsRef: RenderFeaturePreparedRef<'bindings'> | undefined;
-  let verticesRef: RenderFeaturePreparedRef<'vertex-data'> | undefined;
-  let indicesRef: RenderFeaturePreparedRef<'index-data'> | undefined;
-
-  return {
-    identity,
-    extract: () => ok({ draws }),
-    prepare: (_data, context) => {
-      const pipelineResult = context.graphics.preparePipeline('forward', {
-        shader: 'synthetic.unlit',
-        vertexLayout: 'position',
-        colorFormats: ['rgba8unorm'],
-      });
-      if (!pipelineResult.ok) return pipelineResult;
-      const bindingsResult = context.graphics.prepareBindings('forward', {
-        pipeline: pipelineResult.value,
-        values: { opacity: 1 },
-      });
-      if (!bindingsResult.ok) return bindingsResult;
-      const verticesResult = context.graphics.prepareVertexData('quad', {
-        layout: 'position',
-        data: new Float32Array([0, 0, 0]),
-      });
-      if (!verticesResult.ok) return verticesResult;
-      const indicesResult = context.graphics.prepareIndexData('quad', {
-        format: 'uint16',
-        data: new Uint16Array([0, 1, 2]),
-      });
-      if (!indicesResult.ok) return indicesResult;
-      pipelineRef = pipelineResult.value;
-      bindingsRef = bindingsResult.value;
-      verticesRef = verticesResult.value;
-      indicesRef = indicesResult.value;
-      return ok(undefined);
-    },
-    contribute: (data, context) => {
-      if (data.draws.length === 0) return ok(undefined);
-      if (
-        pipelineRef === undefined ||
-        bindingsRef === undefined ||
-        verticesRef === undefined ||
-        indicesRef === undefined
-      ) {
-        return err(new Error('prepared refs missing') as never);
-      }
-      const preparedPipeline = pipelineRef;
-      const preparedBindings = bindingsRef;
-      const preparedVertices = verticesRef;
-      const preparedIndices = indicesRef;
-      const normalized: RenderFeatureDrawRecord[] = data.draws.map((draw) => ({
-        ...draw,
-        pipeline: preparedPipeline,
-        bindings: [preparedBindings],
-        vertexData: [{ slot: 0, resource: preparedVertices }],
-        ...(draw.kind === 'draw-indexed'
-          ? { indexData: { resource: preparedIndices, format: 'uint16' as const } }
-          : {}),
-      }));
-      return context.staging.addGraphicsPass('forward', {
-        attachments: {
-          colors: [
-            {
-              resource: createRenderFeatureTarget({
-                kind: 'scene-color',
-                format: 'rgba8unorm',
-                sampleCount: 1,
-              }),
-              format: 'rgba8unorm',
-              loadOp: 'load',
-              storeOp: 'store',
-            },
-          ],
-        },
-        draws: normalized,
-      });
-    },
-  };
-}
-
-describe('prepared graphics null integration', () => {
-  it('records vertex-only and indexed work through one graph and submit boundary', async () => {
-    const vertex: RenderFeatureDrawRecord = {
-      kind: 'draw',
-      pipeline: { kind: 'pipeline', generation: 0 },
-      bindings: [{ kind: 'bindings', generation: 0 }],
-      vertexData: [{ slot: 0, resource: { kind: 'vertex-data', generation: 0 } }],
-      command: { vertexCount: 3, instanceCount: 1 },
-    };
-    const indexed: RenderFeatureDrawRecord = {
-      kind: 'draw-indexed',
-      pipeline: vertex.pipeline,
-      bindings: vertex.bindings,
-      vertexData: vertex.vertexData,
-      indexData: { resource: { kind: 'index-data', generation: 0 }, format: 'uint16' },
-      command: { indexCount: 3, instanceCount: 1 },
-    };
-    const renderer = await createRenderer(
+describe('prepared graphics Standard host integration', () => {
+  it('records prepared work through RendererOptions.features and returns a receipt', async () => {
+    const host = await constructRendererHost(
       canvas(),
-      { rhi, features: [preparedFeature('synthetic.prepared', [vertex, indexed])] },
-      { shaderManifestUrl: manifest },
+      { rhi, features: [preparedFeature('synthetic.prepared')] },
+      { shaderManifestUrl: preparedManifest },
     );
-    renderer.registerPipeline('synthetic::prepared', pipeline());
-    expect(
-      renderer.installPipeline({ kind: 'render-pipeline', pipelineId: 'synthetic::prepared' }).ok,
-    ).toBe(true);
-    expect((await renderer.ready).ok).toBe(true);
-    const drawCount = observeDrawCalls(renderer.device);
-    const queue = renderer.device.queue;
-    let submitCount = 0;
-    const submit = queue.submit.bind(queue);
-    queue.submit = (buffers) => {
-      submitCount += 1;
-      return submit(buffers);
-    };
-
-    const world = new World();
-    const attachment = renderer.attachWorld(world);
-    if (!attachment.ok) throw attachment.error;
-    world.update().unwrap();
-    const result = renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-    expect(result.ok).toBe(true);
-    expect(renderer.perFramePassNames).toContain('synthetic.prepared::forward');
-    expect(drawCount()).toBeGreaterThanOrEqual(2);
-    expect(submitCount).toBe(1);
-    renderer.dispose();
+    expect(host.ok).toBe(true);
+    if (!host.ok) return;
+    const world = preparedWorld();
+    const attached = host.value.renderer.attach(world);
+    expect(attached.ok).toBe(true);
+    if (!attached.ok) return;
+    expect(world.update().ok).toBe(true);
+    const frame = host.value.renderer.draw(frameRequest(attached.value));
+    expect(frame.ok).toBe(true);
+    if (frame.ok) {
+      const observed = await host.value.renderer.observe(frame.value, { include: ['draws'] });
+      expect(observed.ok).toBe(true);
+    }
+    expect(host.value.renderer.inspect().state).toBe('alive');
+    host.value.renderer.dispose();
   });
 
-  it('keeps empty prepared work out of the active graph', async () => {
-    const renderer = await createRenderer(
+  it('keeps empty prepared work out of the frame without a registration call', async () => {
+    const host = await constructRendererHost(
       canvas(),
-      { rhi, features: [preparedFeature('synthetic.empty', [])] },
-      { shaderManifestUrl: manifest },
+      { rhi, features: [preparedFeature('synthetic.empty', 'empty')] },
+      { shaderManifestUrl: preparedManifest },
     );
-    renderer.registerPipeline('synthetic::empty', pipeline());
-    expect(
-      renderer.installPipeline({ kind: 'render-pipeline', pipelineId: 'synthetic::empty' }).ok,
-    ).toBe(true);
-    expect((await renderer.ready).ok).toBe(true);
+    expect(host.ok).toBe(true);
+    if (!host.ok) return;
     const world = new World();
-    const attachment = renderer.attachWorld(world);
-    if (!attachment.ok) throw attachment.error;
-    world.update().unwrap();
-    expect(renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
-    expect(renderer.perFramePassNames).not.toContain('synthetic.empty::forward');
-    renderer.dispose();
+    const attached = host.value.renderer.attach(world);
+    expect(attached.ok).toBe(true);
+    if (!attached.ok) return;
+    expect(world.update().ok).toBe(true);
+    expect(host.value.renderer.draw(frameRequest(attached.value)).ok).toBe(true);
+    host.value.renderer.dispose();
   });
 });