@forgeax/engine-runtime 0.1.26 → 0.1.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeax/engine-runtime",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "private": false,
   "type": "module",
   "license": "Apache-2.0",
@@ -26,37 +26,39 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@forgeax/engine-animation": "0.1.26",
-    "@forgeax/engine-assets-runtime": "0.1.26",
-    "@forgeax/engine-audio-webaudio": "0.1.26",
-    "@forgeax/engine-codec": "0.1.26",
-    "@forgeax/engine-debug-draw": "0.1.26",
-    "@forgeax/engine-ecs": "0.1.26",
-    "@forgeax/engine-font": "0.1.26",
-    "@forgeax/engine-geometry": "0.1.26",
-    "@forgeax/engine-graphics-extras": "0.1.26",
-    "@forgeax/engine-image": "0.1.26",
-    "@forgeax/engine-input": "0.1.26",
-    "@forgeax/engine-math": "0.1.26",
-    "@forgeax/engine-pack": "0.1.26",
-    "@forgeax/engine-profiler": "0.1.26",
-    "@forgeax/engine-render": "0.1.26",
-    "@forgeax/engine-render-graph": "0.1.26",
-    "@forgeax/engine-rhi": "0.1.26",
-    "@forgeax/engine-rhi-null": "0.1.26",
-    "@forgeax/engine-rhi-webgpu": "0.1.26",
-    "@forgeax/engine-rhi-wgpu": "0.1.26",
-    "@forgeax/engine-scene": "0.1.26",
-    "@forgeax/engine-shader": "0.1.26",
-    "@forgeax/engine-skinning": "0.1.26",
-    "@forgeax/engine-types": "0.1.26",
-    "@forgeax/engine-vfx": "0.1.26"
+    "@forgeax/engine-animation": "0.1.28",
+    "@forgeax/engine-assets-runtime": "0.1.28",
+    "@forgeax/engine-audio-webaudio": "0.1.28",
+    "@forgeax/engine-codec": "0.1.28",
+    "@forgeax/engine-debug-draw": "0.1.28",
+    "@forgeax/engine-ecs": "0.1.28",
+    "@forgeax/engine-font": "0.1.28",
+    "@forgeax/engine-geometry": "0.1.28",
+    "@forgeax/engine-graphics-extras": "0.1.28",
+    "@forgeax/engine-image": "0.1.28",
+    "@forgeax/engine-input": "0.1.28",
+    "@forgeax/engine-math": "0.1.28",
+    "@forgeax/engine-pack": "0.1.28",
+    "@forgeax/engine-profiler": "0.1.28",
+    "@forgeax/engine-render": "0.1.28",
+    "@forgeax/engine-render-graph": "0.1.28",
+    "@forgeax/engine-rhi": "0.1.28",
+    "@forgeax/engine-rhi-null": "0.1.28",
+    "@forgeax/engine-rhi-webgpu": "0.1.28",
+    "@forgeax/engine-rhi-wgpu": "0.1.28",
+    "@forgeax/engine-scene": "0.1.28",
+    "@forgeax/engine-shader": "0.1.28",
+    "@forgeax/engine-skinning": "0.1.28",
+    "@forgeax/engine-types": "0.1.28",
+    "@forgeax/engine-vfx": "0.1.28"
   },
   "devDependencies": {
-    "@forgeax/engine-import": "0.1.26",
-    "@forgeax/engine-naga": "0.1.26",
-    "@forgeax/engine-state": "0.1.26",
-    "@forgeax/engine-vite-plugin-shader": "0.1.26",
+    "@forgeax/engine-import": "0.1.28",
+    "@forgeax/engine-naga": "0.1.28",
+    "@forgeax/engine-physics": "0.1.28",
+    "@forgeax/engine-physics-rapier3d": "0.1.28",
+    "@forgeax/engine-state": "0.1.28",
+    "@forgeax/engine-vite-plugin-shader": "0.1.28",
     "@types/node": "^20.14.0"
   },
   "forgeax": {

package/src/__tests__/propagate-transforms.cases.unit.test.ts

@@ -105,6 +105,7 @@ import type {
 } from '@forgeax/engine-types';
 import { toShared } from '@forgeax/engine-types';
 import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { componentId } from '../../../ecs/src/component';
 import { worldInternal } from '../../../ecs/src/world-internal';
 import {
   SPRITE_PLAYBACK_MODE_CLAMP,
@@ -489,7 +490,10 @@ type __MergedKeep =
       if (archetype === undefined || record === undefined) throw new Error('child row missing');
       const tableRow = archetype.rows[record.archetypeRow];
       if (tableRow === undefined) throw new Error('child table row missing');
-      world[worldInternal].writeRow(archetype, ChildOf, tableRow, { parent: ghost });
+      const table = world[worldInternal].getGraph().tables[archetype.tableId];
+      const parentColumn = table?.storage.get(componentId(ChildOf))?.fields.get('parent');
+      if (parentColumn === undefined) throw new Error('ChildOf.parent column missing');
+      parentColumn.view[tableRow] = ghost as number;
 
       const r = propagateTransforms(world);
       expect(r.ok).toBe(false);

package/src/__tests__/propagate-transforms.dawn.test.ts

@@ -25,6 +25,7 @@ import { World } from '@forgeax/engine-ecs';
 import { readRenderArrayView } from '@forgeax/engine-ecs/projection';
 import { ChildOf, GlobalTransform, propagateTransforms, Transform } from '@forgeax/engine-scene';
 import { describe, expect, it } from 'vitest';
+import { componentId } from '../../../ecs/src/component';
 import { worldInternal } from '../../../ecs/src/world-internal';
 import { TileLayer, Tilemap } from '../../../render/src/components';
 
@@ -258,7 +259,10 @@ describe('propagate-transforms.dawn - root-down DFS + stale ChildOf fail-fast (A
     if (archetype === undefined || record === undefined) throw new Error('orphan row missing');
     const tableRow = archetype.rows[record.archetypeRow];
     if (tableRow === undefined) throw new Error('orphan table row missing');
-    world[worldInternal].writeRow(archetype, ChildOf, tableRow, { parent: ghost });
+    const table = world[worldInternal].getGraph().tables[archetype.tableId];
+    const parentColumn = table?.storage.get(componentId(ChildOf))?.fields.get('parent');
+    if (parentColumn === undefined) throw new Error('ChildOf.parent column missing');
+    parentColumn.view[tableRow] = ghost as number;
 
     const r = propagateTransforms(world);
     expect(r.ok).toBe(false);

package/src/__tests__/render-system-extract.test.ts

@@ -13,6 +13,7 @@ import { AssetGuid } from '@forgeax/engine-pack/guid';
 import {
   Camera,
   DirectionalLight,
+  Materials,
   MeshFilter,
   MeshRenderer,
   PointLight,
@@ -284,6 +285,52 @@ import { makeMockShaderRegistry } from './helpers/mock-shader-registry';
       );
     });
 
+    it('keeps custom Standard Surface fields in the extracted material ABI', () => {
+      const world = new World();
+      spawnCamera(world);
+      const assets = new AssetRegistry(makeMockShaderRegistry());
+      const mesh = registerMesh(world);
+      const material = world.allocSharedRef<'MaterialAsset', MaterialAsset>(
+        'MaterialAsset',
+        Materials.standard({
+          surfaceModule: 'game_3d::rusted_iron_surface',
+          parameters: [
+            { name: 'ironColor', type: 'color' },
+            { name: 'rustDark', type: 'color' },
+            { name: 'rustBright', type: 'color' },
+            { name: 'noiseScale', type: 'f32' },
+          ],
+          values: {
+            ironColor: [0.4, 0.45, 0.47, 1],
+            rustDark: [0.42, 0.085, 0.018, 1],
+            rustBright: [0.95, 0.34, 0.055, 1],
+            noiseScale: 1.85,
+          },
+        }),
+      );
+      world
+        .spawn(
+          { component: Transform, data: { ...identity(), pos: [0, 0, -2] } },
+          { component: MeshFilter, data: { assetHandle: mesh } },
+          { component: MeshRenderer, data: { materials: [material] } },
+        )
+        .unwrap();
+
+      const frame = extractFrame(world, prepareExtractContext(world, { assets }));
+      const snapshot = frame.renderables[0]?.material;
+      const schemaNames = snapshot?.materialParamSchema?.map((entry) => entry.name) ?? [];
+
+      expect(schemaNames).toEqual(
+        expect.arrayContaining(['ironColor', 'rustDark', 'rustBright', 'noiseScale']),
+      );
+      expect(snapshot?.paramSnapshot).toMatchObject({
+        ironColor: [0.4, 0.45, 0.47].map(srgbChannelToLinear).concat(1),
+        rustDark: [0.42, 0.085, 0.018].map(srgbChannelToLinear).concat(1),
+        rustBright: [0.95, 0.34, 0.055].map(srgbChannelToLinear).concat(1),
+        noiseScale: 1.85,
+      });
+    });
+
     it('mesh-walk: RenderableSnapshot.transform.world is the resolved world mat4 (parent x child), zero per-snapshot compose', () => {
       const world = new World();
       world

package/src/__tests__/wave1-dynamic-geometry.browser.test.ts

@@ -0,0 +1,326 @@
+import { createWorldContext, FixedTime, World } from '@forgeax/engine-ecs';
+import { createBoxGeometry, meshFromInterleaved } from '@forgeax/engine-geometry';
+import { vec3 } from '@forgeax/engine-math';
+import { RigidBody, RigidBodyTypeValue } from '@forgeax/engine-physics';
+import {
+  createRapier3DPhysicsWorld,
+  loadRapier3D,
+  registerPhysicsSystems,
+} from '@forgeax/engine-physics-rapier3d';
+import {
+  ANTIALIAS_TAA,
+  Camera,
+  DirectionalLight,
+  type DynamicGeometryCandidate,
+  Materials,
+  MeshFilter,
+  MeshRenderer,
+} from '@forgeax/engine-render';
+import { ChildOf, propagateTransforms, scenePlugin, Transform } from '@forgeax/engine-scene';
+import { err, type MeshAsset, ok } from '@forgeax/engine-types';
+import { expect, it } from 'vitest';
+import { page } from 'vitest/browser';
+import { createRenderer } from '../createRenderer';
+
+// Deterministic external geometry output: four boxes form an aperture.
+// The Engine consumes an ordinary MeshAsset, without a voxel renderer.
+function aperture(): MeshAsset {
+  const vertices: number[] = [];
+  const indices: number[] = [];
+  for (const [x, y, w, h] of [
+    [-0.8, 0, 0.4, 2],
+    [0.8, 0, 0.4, 2],
+    [0, -0.8, 1.2, 0.4],
+    [0, 0.8, 1.2, 0.4],
+  ] as const) {
+    const box = createBoxGeometry(w, h, 0.5).unwrap();
+    const offset = vertices.length / 8;
+    const { position, normal, uv } = box.attributes;
+    if (position === undefined || normal === undefined || uv === undefined)
+      throw new Error('box attribute closure');
+    for (let i = 0; i < position.length / 3; i++) {
+      vertices.push(
+        (position[i * 3] ?? 0) + x,
+        (position[i * 3 + 1] ?? 0) + y,
+        position[i * 3 + 2] ?? 0,
+        normal[i * 3] ?? 0,
+        normal[i * 3 + 1] ?? 0,
+        normal[i * 3 + 2] ?? 0,
+        uv[i * 2] ?? 0,
+        uv[i * 2 + 1] ?? 0,
+      );
+    }
+    for (const index of box.indices) indices.push(index + offset);
+  }
+  return meshFromInterleaved(new Float32Array(vertices), new Uint16Array(indices)).unwrap();
+}
+
+it('atomically publishes physics and PBR apertures with shadow, parent motion and fresh TAA history', async () => {
+  const canvas = document.createElement('canvas');
+  canvas.width = 384;
+  canvas.height = 384;
+  canvas.style.width = '384px';
+  canvas.style.height = '384px';
+  document.body.appendChild(canvas);
+  const renderer = (
+    await createRenderer(canvas, {}, { shaderManifestUrl: '/shaders/manifest.json' })
+  ).unwrap();
+  const errors: string[] = [];
+  const unsubscribe = renderer.subscribe((event) => {
+    if (event.kind === 'error') errors.push(event.error.code);
+  });
+  const world = new World();
+  const scene = await createWorldContext(world, [scenePlugin()]);
+  const rapier = await loadRapier3D();
+  if ('code' in rapier) throw rapier;
+  const physics = createRapier3DPhysicsWorld(rapier);
+  world.insertResource('PhysicsWorld', physics);
+  const releasePhysics = registerPhysicsSystems(world);
+  try {
+    const material = world.allocSharedRef(
+      'MaterialAsset',
+      Materials.standard({ baseColor: [0.7, 0.24, 0.06, 1], metallic: 0.15, roughness: 0.45 }),
+    );
+    const gray = world.allocSharedRef(
+      'MaterialAsset',
+      Materials.standard({ baseColor: [0.55, 0.6, 0.65, 1], metallic: 0, roughness: 0.8 }),
+    );
+    const closedMesh = createBoxGeometry(2, 2, 0.5).unwrap();
+    const openMesh = aperture();
+    const closedHandle = world.allocSharedRef('MeshAsset', closedMesh);
+    const openHandle = world.allocSharedRef('MeshAsset', openMesh);
+    const parent = world
+      .spawn(
+        { component: Transform, data: {} },
+        { component: RigidBody, data: { type: RigidBodyTypeValue.static } },
+      )
+      .unwrap();
+    const entity = world
+      .spawn(
+        { component: Transform, data: {} },
+        { component: ChildOf, data: { parent } },
+        { component: MeshFilter, data: { assetHandle: closedHandle } },
+        { component: MeshRenderer, data: { materials: [material] } },
+      )
+      .unwrap();
+    const floor = world.allocSharedRef('MeshAsset', createBoxGeometry(7, 0.2, 7).unwrap());
+    world
+      .spawn(
+        { component: Transform, data: { pos: [0, -1.25, 0] } },
+        { component: MeshFilter, data: { assetHandle: floor } },
+        { component: MeshRenderer, data: { materials: [gray] } },
+      )
+      .unwrap();
+    const light = world
+      .spawn({
+        component: DirectionalLight,
+        data: { direction: [-0.5, -0.9, -0.7], intensity: 3, castShadow: true },
+      })
+      .unwrap();
+    const camera = world
+      .spawn(
+        { component: Transform, data: { pos: [0, 1, 7] } },
+        { component: Camera, data: { fov: Math.PI / 4, aspect: 1, near: 0.1, far: 40 } },
+      )
+      .unwrap();
+    const lease = renderer.attach(world).unwrap();
+    const physicsInput = (revision: number, opened: boolean) => {
+      const cells: [number, number, number][] = [];
+      for (let x = -2; x <= 2; x++)
+        for (let y = -2; y <= 2; y++) {
+          if (!opened || Math.abs(x) === 2 || Math.abs(y) === 2) cells.push([x, y, 0]);
+        }
+      return {
+        entity: parent,
+        revision,
+        sourceKey: 'wave1:slab',
+        worldIdentity: world,
+        bodyType: 'static' as const,
+        shapes: [
+          {
+            id: 'slab',
+            revision,
+            cells,
+            voxelSize: [0.4, 0.4, 0.5] as const,
+            origin: [-0.2, -0.2, -0.25] as const,
+          },
+        ],
+      };
+    };
+    const centerHit = () => physics.raycast(vec3.create(0, 0, 4), vec3.create(0, 0, -1), 8);
+    world.update(1 / 60).unwrap();
+    physics
+      .admitDerivedShapeCandidate(
+        physics.prepareDerivedShapeCandidate(physicsInput(1, false)).unwrap(),
+      )
+      .unwrap();
+    world.update(1 / 60).unwrap();
+    expect(centerHit()?.entity).toBe(parent);
+    const draw = async () => {
+      propagateTransforms(world).unwrap();
+      const receipt = renderer
+        .draw({ leases: [lease], camera: { lease }, environment: { lease } })
+        .unwrap();
+      (await receipt.completed).unwrap();
+      await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+      return receipt;
+    };
+    const shot = async (name: string) => {
+      const value = await page
+        .elementLocator(canvas)
+        .screenshot({ path: `wave1-${name}.png`, base64: true });
+      return typeof value === 'string' ? value : value.base64;
+    };
+    await draw();
+    const closed = await shot('closed');
+    const candidate = renderer
+      .prepareDynamicGeometry({
+        world,
+        entity,
+        physicsEntity: parent,
+        mesh: openMesh,
+        meshHandle: openHandle,
+        revision: 2,
+      })
+      .unwrap();
+    expect(world.get(entity, MeshFilter).unwrap().assetHandle).toBe(closedHandle);
+    await draw();
+    expect(await shot('prepared')).toBe(closed);
+    let accepted: DynamicGeometryCandidate | undefined;
+    physics
+      .admitDerivedShapeCandidate(
+        physics.prepareDerivedShapeCandidate(physicsInput(2, true)).unwrap(),
+        () => {
+          const result = renderer.acceptDynamicGeometry(candidate, {
+            world,
+            fixedStep: world.getResource(FixedTime).tick,
+          });
+          if (!result.ok) return err(result.error);
+          accepted = result.value;
+          expect(
+            renderer.draw({ leases: [lease], camera: { lease }, environment: { lease } }),
+          ).toMatchObject({ ok: false, error: { code: 'frame-input-invalid' } });
+          return ok(undefined);
+        },
+      )
+      .unwrap();
+    world.update(0).unwrap();
+    expect(accepted).toBeUndefined();
+    expect(centerHit()?.entity).toBe(parent);
+    world.update(2 / 60).unwrap();
+    expect(accepted).toBeDefined();
+    if (accepted === undefined) throw new Error('paired admission did not run');
+    expect(centerHit()).toBeUndefined();
+    const frame = await draw();
+    expect(renderer.dynamicGeometryReceipt(accepted)?.frameId).toBe(frame.frameId);
+    const opened = await shot('open');
+    expect(opened).not.toBe(closed);
+    world.set(light, DirectionalLight, { castShadow: false }).unwrap();
+    await draw();
+    expect(await shot('no-shadow')).not.toBe(opened);
+    world.set(light, DirectionalLight, { castShadow: true }).unwrap();
+    world.set(parent, Transform, { pos: [0.75, 0, 0] }).unwrap();
+    world.update(1 / 60).unwrap();
+    await draw();
+    expect(await shot('moved')).not.toBe(opened);
+    const replacement = renderer
+      .prepareDynamicGeometry({
+        world,
+        entity,
+        physicsEntity: parent,
+        mesh: closedMesh,
+        meshHandle: closedHandle,
+        materialIdentity: String(material),
+        revision: 3,
+      })
+      .unwrap();
+    world.set(entity, MeshRenderer, { materials: [gray] }).unwrap();
+    physics
+      .admitDerivedShapeCandidate(
+        physics.prepareDerivedShapeCandidate(physicsInput(3, false)).unwrap(),
+        () => {
+          const result = renderer.acceptDynamicGeometry(replacement, {
+            world,
+            fixedStep: world.getResource(FixedTime).tick,
+          });
+          return result.ok ? ok(undefined) : err(result.error);
+        },
+      )
+      .unwrap();
+    world.update(1 / 60).unwrap();
+    expect(physics.getDerivedPublication(parent)?.revision).toBe(2);
+    expect(physics.getDerivedFailure(parent)?.recovery).toBe('old-state-retained');
+    expect(world.get(entity, MeshFilter).unwrap().assetHandle).toBe(openHandle);
+    renderer.cancelDynamicGeometry(replacement).unwrap();
+    world.set(entity, MeshRenderer, { materials: [material] }).unwrap();
+    const sealedCandidate = renderer
+      .prepareDynamicGeometry({
+        world,
+        entity,
+        physicsEntity: parent,
+        mesh: closedMesh,
+        meshHandle: closedHandle,
+        revision: 4,
+      })
+      .unwrap();
+    physics
+      .admitDerivedShapeCandidate(
+        physics.prepareDerivedShapeCandidate(physicsInput(4, false)).unwrap(),
+        () => {
+          const result = renderer.acceptDynamicGeometry(sealedCandidate, {
+            world,
+            fixedStep: world.getResource(FixedTime).tick,
+          });
+          return result.ok ? ok(undefined) : err(result.error);
+        },
+      )
+      .unwrap();
+    world.update(1 / 60).unwrap();
+    expect(physics.getDerivedPublication(parent)?.revision).toBe(4);
+    await draw();
+    renderer.retireDynamicGeometry(accepted as DynamicGeometryCandidate).unwrap();
+    await shot('sealed');
+    world.set(camera, Camera, { antialias: ANTIALIAS_TAA }).unwrap();
+    for (let i = 0; i < 8; i++) await draw();
+    await shot('taa-sealed');
+    expect(renderer.inspect().temporal.mode).toBe('taa');
+    expect(renderer.inspect().temporal.historyValid).toBe(true);
+    expect(renderer.inspect().temporal.frameIndex).toBeGreaterThanOrEqual(7);
+    const taaCandidate = renderer
+      .prepareDynamicGeometry({
+        world,
+        entity,
+        physicsEntity: parent,
+        mesh: openMesh,
+        meshHandle: openHandle,
+        revision: 5,
+      })
+      .unwrap();
+    physics
+      .admitDerivedShapeCandidate(
+        physics.prepareDerivedShapeCandidate(physicsInput(5, true)).unwrap(),
+        () => {
+          const result = renderer.acceptDynamicGeometry(taaCandidate, {
+            world,
+            fixedStep: world.getResource(FixedTime).tick,
+          });
+          return result.ok ? ok(undefined) : err(result.error);
+        },
+      )
+      .unwrap();
+    world.update(1 / 60).unwrap();
+    await draw();
+    expect(renderer.inspect().temporal.frameIndex).toBe(0);
+    await shot('taa-open-first');
+    expect(errors).toEqual([]);
+  } finally {
+    unsubscribe();
+    await renderer.dispose();
+    releasePhysics();
+    const entities = [...world.query({ read: [Transform] }).unwrap()].map((row) => row.entity);
+    for (const entity of entities.reverse()) world.despawn(entity).unwrap();
+    await scene.fiber.dispose();
+    physics.dispose();
+    canvas.remove();
+  }
+}, 60000);