@forgeax/engine-render 0.1.7 → 0.1.19

package/src/__tests__/urp-pipeline-targets.unit.test.ts

@@ -16,7 +16,7 @@ function targets(
 }
 
 describe('urp render feature targets', () => {
-  it('publishes the linear-LDR target used by native no-tonemap frames', () => {
+  it('keeps the storage-buffer no-tonemap no-FXAA path in a linear target', () => {
     expect(targets('none', 'none', true)?.[0]).toMatchObject({
       kind: 'scene-color',
       format: 'rgba16float',
@@ -24,6 +24,14 @@ describe('urp render feature targets', () => {
     });
   });
 
+  it('publishes a float target for no-tonemap FXAA before the OETF boundary', () => {
+    expect(targets('none', 'fxaa', true)?.[0]).toMatchObject({
+      kind: 'scene-color',
+      format: 'rgba16float',
+      sampleCount: 1,
+    });
+  });
+
   it('publishes the MSAA linear-LDR target with the graph sample count', () => {
     expect(targets('none', 'msaa', true)?.[0]).toMatchObject({
       kind: 'scene-color',
@@ -39,4 +47,20 @@ describe('urp render feature targets', () => {
       sampleCount: 1,
     });
   });
+
+  it('keeps a linear target when MSAA is unavailable on a storage-buffer lane', () => {
+    expect(
+      resolveStandardRenderFeatureTargets({
+        tonemap: 'none',
+        antialias: 'msaa',
+        colorAttachmentFormat: 'bgra8unorm-srgb',
+        storageBuffer: true,
+        multisample: false,
+      })[0],
+    ).toMatchObject({
+      kind: 'scene-color',
+      format: 'rgba16float',
+      sampleCount: 1,
+    });
+  });
 });

package/src/__tests__/urp-pipeline.unit.test.ts

@@ -6,9 +6,10 @@ describe('Standard forward post color-domain order', () => {
     expect(resolvePostColorDomainContract('linear-ldr')).toEqual([
       ['transparent-blend', 'linear-ldr', 'linear-ldr'],
       ['bloom', 'linear-hdr', 'linear-hdr'],
-      ['tone', 'linear-hdr', 'linear-ldr'],
-      ['fxaa', 'linear-ldr', 'linear-ldr'],
-      ['output', 'linear-ldr', 'display-encoded'],
+      ['output-transform', 'linear-ldr', 'display-encoded'],
+      ['fxaa', 'display-encoded', 'display-encoded'],
+      ['post-effect', 'display-encoded', 'display-encoded'],
+      ['present', 'display-encoded', 'display-encoded'],
     ]);
   });
 });

package/src/__tests__/visibility-extract.integration.test.ts

@@ -1,6 +1,7 @@
 import { World } from '@forgeax/engine-ecs';
 import { ChildOf, registerPropagateTransforms, Transform } from '@forgeax/engine-scene';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
+import { Fog } from '../components/fog';
 import { Visibility, VisibilityStateValue } from '../components/visibility';
 import { extractFrame, extractFrames, prepareExtractContext } from '../render-system-extract';
 
@@ -32,6 +33,31 @@ function makeWorld() {
 }
 
 describe('visibility extract orchestration', () => {
+  it('selects Fog once at the resource-owner frame boundary', () => {
+    const cameraWorld = new World();
+    const resourceWorld = new World();
+    resourceWorld
+      .spawn({
+        component: Fog,
+        data: { color: [0.1, 0.2, 0.3], density: 0.02, heightFalloff: 0.4, maxOpacity: 0.8 },
+      })
+      .unwrap();
+
+    const cameraQuery = vi.spyOn(cameraWorld, 'query');
+    const resourceQuery = vi.spyOn(resourceWorld, 'query');
+    extractFrames([cameraWorld, resourceWorld], { cameraOwner: 0, resourceOwner: 1 });
+
+    const readsFog = (calls: readonly unknown[][]) =>
+      calls.filter(([spec]) => {
+        if (typeof spec !== 'object' || spec === null || !('read' in spec)) return false;
+        const read = (spec as { readonly read?: readonly unknown[] }).read;
+        return read?.includes(Fog) ?? false;
+      });
+
+    expect(readsFog(cameraQuery.mock.calls)).toHaveLength(0);
+    expect(readsFog(resourceQuery.mock.calls)).toHaveLength(1);
+  });
+
   it('refreshes hierarchy and visibility from the final World state', () => {
     const { world, parent, child } = makeWorld();
     world.set(parent, Visibility, { state: VisibilityStateValue.visible }).unwrap();

package/src/__tests__/visibility-producer-matrix.integration.test.ts

@@ -12,6 +12,7 @@ import { TileLayer } from '../components/tile-layer';
 import { Tilemap } from '../components/tilemap';
 import { Visibility, VisibilityStateValue } from '../components/visibility';
 import { extractFrames } from '../render-system-extract';
+import { classifySceneDataCoverage } from '../temporal/coverage';
 import { tilemapChunkExtractSystem } from '../tilemap-chunk-extract-system';
 
 const IDENTITY = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
@@ -120,6 +121,15 @@ const PRODUCERS: readonly ProducerCase[] = [
 ];
 
 describe('visibility built-in producer matrix', () => {
+  it('records visibility reentry as a bounded reactive contributor', () => {
+    const coverage = classifySceneDataCoverage({
+      contributors: [{ id: 'visibility-reentry', kind: 'reactive' }],
+      requiredContributorIds: ['visibility-reentry'],
+    });
+    expect(coverage.complete).toBe(true);
+    expect(coverage.reactiveContributorIds).toEqual(['visibility-reentry']);
+  });
+
   it.each(PRODUCERS)('$name is hidden, visible, then restorable', ({ setup }) => {
     const world = new World();
     const entity = setup(world);

package/src/assembly/backend-contract.ts

@@ -25,6 +25,18 @@ export interface RhiBackendPack {
     device: RhiDevice,
     desc: { code: string; label?: string | undefined },
   ) => Promise<Result<ShaderModule, RhiError>>;
+  /**
+   * Internal render-path fast path. WebGPU creates a shader module
+   * synchronously and reports WGSL diagnostics through the async
+   * `createShaderModule` entry; waiting for `getCompilationInfo()` here would
+   * serialize every first-use material behind a slow software adapter. The
+   * render assembly still validates the module when it builds the pipeline,
+   * while public callers retain the diagnostic-rich async entry above.
+   */
+  readonly createShaderModuleImmediate?: (
+    device: RhiDevice,
+    desc: { code: string; label?: string | undefined },
+  ) => Result<ShaderModule, RhiError>;
   readonly translateErrorEventToRhiError?: (event: unknown) => {
     readonly ok: false;
     readonly error: RhiError;
@@ -40,6 +52,37 @@ export interface EngineEnvironmentErrorDetail {
   readonly wgpuError?: RhiError | Error | undefined;
 }
 
+function describeEnvironmentCause(cause: RhiError | Error | undefined): string | undefined {
+  if (cause === undefined) return undefined;
+  const candidate = cause as unknown as {
+    readonly code?: unknown;
+    readonly expected?: unknown;
+    readonly hint?: unknown;
+    readonly detail?: unknown;
+  };
+  const code = typeof candidate.code === 'string' ? candidate.code : undefined;
+  const expected = typeof candidate.expected === 'string' ? candidate.expected : undefined;
+  const hint = typeof candidate.hint === 'string' ? candidate.hint : undefined;
+  const detail = candidate.detail;
+  if (typeof detail === 'object' && detail !== null && 'compilerMessages' in detail) {
+    const messages = (detail as { readonly compilerMessages?: unknown }).compilerMessages;
+    if (Array.isArray(messages)) {
+      const text = messages
+        .map((message) => {
+          const value = message as { readonly message?: unknown };
+          return typeof value.message === 'string' ? value.message : undefined;
+        })
+        .filter((message): message is string => message !== undefined)
+        .join(' | ');
+      if (text.length > 0) {
+        return `${code ?? cause.name}: ${expected ?? cause.message}; ${hint ?? ''} compilerMessages=${text}`;
+      }
+    }
+  }
+  if (code === undefined) return cause.message;
+  return `${code}: ${expected ?? cause.message}; ${hint ?? ''}`.trimEnd();
+}
+
 export class EngineEnvironmentError extends Error {
   readonly reason: string;
   readonly webgpuError?: RhiError | Error | undefined;
@@ -47,7 +90,10 @@ export class EngineEnvironmentError extends Error {
   readonly detail: EngineEnvironmentErrorDetail;
 
   constructor(reason: string, detail: EngineEnvironmentErrorDetail = {}) {
-    super(`forgeax-engine: no usable backend (${reason})`);
+    const cause = describeEnvironmentCause(detail.webgpuError ?? detail.wgpuError);
+    super(
+      `forgeax-engine: no usable backend (${reason}${cause === undefined ? '' : `; cause=${cause}`})`,
+    );
     this.name = 'EngineEnvironmentError';
     this.reason = reason;
     this.webgpuError = detail.webgpuError;