@forgeax/engine-render 0.1.33 → 0.1.35

package/src/publication/receiver.ts

@@ -0,0 +1,297 @@
+import type { AssetReader } from '@forgeax/engine-assets-runtime';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import { type Asset, AssetError, err, type Handle, ok, type Result } from '@forgeax/engine-types';
+import type { DispatchEntry, ExtractedFrame, RenderableSnapshot } from '../render-system-extract';
+import type { RenderSceneOperation } from '../scene/render-scene-types';
+import {
+  type RenderPublication,
+  RenderPublicationError,
+  type RenderPublicationIdentity,
+} from './contract';
+import { publicationDependencies, publicationFrameDependencies } from './dependencies';
+import type { PublishedRenderResources } from './resource-scope';
+
+export interface PreparedRenderPublication {
+  readonly resources: PublishedRenderResources;
+  readonly packet: RenderPublication;
+  readonly operations: readonly RenderSceneOperation[];
+  readonly frame: ExtractedFrame;
+  readonly onFeatureSourceSubmitted?: (identity: string, feedback: unknown) => void;
+}
+
+/** Assets live for this source session; the Renderer owns all retained scene/GPU state. */
+export class RenderPublicationReceiver {
+  private revision = 0;
+  private videoFrames = new Map<string, VideoFrame>();
+  private readonly entities = new Set<number>();
+  private readonly assets = new Map<Handle<string, 'shared'>, Asset>();
+  private readonly resources: PublishedRenderResources;
+  private readonly guidHandles = new Map<string, Handle<string, 'shared'>>();
+
+  constructor(private readonly identity: RenderPublicationIdentity) {
+    const resolveAsset: AssetReader['resolveAsset'] = <T extends Asset>(
+      handle: Handle<string, 'shared'>,
+    ) => {
+      const value = this.assets.get(handle);
+      return value === undefined
+        ? err(
+            new AssetError({
+              code: 'asset-not-found',
+              expected: 'the accepted publication contains the referenced asset generation',
+              hint: 'publish the asset closure before drawing its consumer',
+            }),
+          )
+        : ok(value as T);
+    };
+    this.resources = {
+      identity: `${identity.source}:${identity.epoch}`,
+      time: { delta: 0, elapsed: 0, maxDeltaSeconds: 0 },
+      transparentSort: { mode: 0, yzAlpha: 1 },
+      resolveAsset,
+      videoFrame: (entity, clip) => this.videoFrames.get(`${entity}:${clip}`),
+      handleForGuid: (guid) => this.guidHandles.get(guid.toLowerCase()),
+      lookupAsset: <T extends Asset>(guid: string): T | undefined => {
+        const handle = this.guidHandles.get(guid.toLowerCase());
+        return handle === undefined ? undefined : (this.assets.get(handle) as T | undefined);
+      },
+    };
+  }
+
+  accept(packet: RenderPublication): Result<PreparedRenderPublication, RenderPublicationError> {
+    const reject = (reason: RenderPublicationError['detail']['reason'], subject: string) =>
+      err(new RenderPublicationError({ reason, subject }));
+    if (packet.source !== this.identity.source || packet.epoch !== this.identity.epoch)
+      return reject('identity', 'source/epoch');
+    if (packet.base !== this.revision || packet.baseline !== (this.revision === 0))
+      return reject('base', 'accepted revision');
+    if (!Number.isSafeInteger(packet.revision) || packet.revision !== this.revision + 1)
+      return reject('revision', 'next revision');
+    if (
+      !(packet.upserts instanceof Uint32Array) ||
+      packet.upserts.length % 2 !== 0 ||
+      !(packet.removed instanceof Uint32Array) ||
+      !(packet.transformEntities instanceof Uint32Array) ||
+      !(packet.transforms instanceof Float32Array) ||
+      packet.transforms.length !== packet.transformEntities.length * 16 ||
+      !packet.transforms.every(Number.isFinite) ||
+      !Number.isFinite(packet.sampleTimeSeconds)
+    )
+      return reject('shape', 'numeric columns');
+    if (
+      !Array.isArray(packet.videoFrames) ||
+      !Array.isArray(packet.targets) ||
+      !Array.isArray(packet.targetSources) ||
+      !Array.isArray(packet.features) ||
+      !Array.isArray(packet.templates) ||
+      !Array.isArray(packet.programs) ||
+      !Array.isArray(packet.assets) ||
+      !Array.isArray(packet.retiredAssets) ||
+      !Array.isArray(packet.invalidatedAssets) ||
+      packet.metadata === null ||
+      typeof packet.metadata !== 'object' ||
+      !Array.isArray(packet.metadata.cameras) ||
+      !Number.isFinite(packet.time?.elapsed) ||
+      !Number.isFinite(packet.time?.delta)
+    )
+      return reject('shape', 'frame metadata');
+    const videoKeys = new Set<string>();
+    for (const row of packet.videoFrames) {
+      const key = `${row.entity}:${row.clip}`;
+      if (
+        !Number.isSafeInteger(row.entity) ||
+        !Number.isSafeInteger(row.clip) ||
+        typeof VideoFrame === 'undefined' ||
+        !(row.frame instanceof VideoFrame) ||
+        row.frame.displayWidth <= 0 ||
+        row.frame.displayHeight <= 0 ||
+        videoKeys.has(key)
+      )
+        return reject('shape', 'video frame');
+      videoKeys.add(key);
+    }
+    const targetIds = new Set<number>();
+    const targetTokens = new Set<object>();
+    for (const row of packet.targets) {
+      if (
+        !Number.isSafeInteger(row.id) ||
+        row.id <= 0 ||
+        targetIds.has(row.id) ||
+        typeof row.token !== 'object' ||
+        row.token === null ||
+        targetTokens.has(row.token) ||
+        typeof row.descriptor !== 'object' ||
+        row.descriptor === null
+      )
+        return reject('shape', 'target identity/descriptor');
+      targetIds.add(row.id);
+      targetTokens.add(row.token);
+    }
+    for (const camera of [
+      ...packet.metadata.cameras,
+      ...packet.metadata.auxiliaryCameras,
+      ...packet.metadata.cubeCameras,
+    ])
+      if (camera.target !== undefined && !targetTokens.has(camera.target))
+        return reject('shape', 'missing target descriptor');
+    const sourceTokens = new Set<object>();
+    for (const row of packet.targetSources) {
+      if (
+        !targetTokens.has(row.target) ||
+        typeof row.token !== 'object' ||
+        row.token === null ||
+        sourceTokens.has(row.token)
+      )
+        return reject('shape', 'target source');
+      sourceTokens.add(row.token);
+    }
+    const featureIdentities = new Set<string>();
+    for (const row of packet.features) {
+      if (typeof row.identity !== 'string' || featureIdentities.has(row.identity))
+        return reject('shape', 'feature identity');
+      featureIdentities.add(row.identity);
+    }
+    const matrices = new Map<number, Float32Array>();
+    for (let i = 0; i < packet.transformEntities.length; i++) {
+      const entity = packet.transformEntities[i] as number;
+      if (matrices.has(entity)) return reject('shape', 'duplicate transform identity');
+      matrices.set(entity, packet.transforms.slice(i * 16, i * 16 + 16));
+    }
+    const operations: RenderSceneOperation[] = [];
+    const renderables: RenderableSnapshot[] = [];
+    const dispatch: DispatchEntry[] = [];
+    const updated = new Set<number>();
+    for (let i = 0; i < packet.upserts.length; i += 2) {
+      const entityKey = packet.upserts[i] as number;
+      const template = packet.templates[packet.upserts[i + 1] as number];
+      const world = matrices.get(entityKey);
+      if (template === undefined || world === undefined || updated.has(entityKey))
+        return reject('shape', 'upsert template/transform');
+      if (!Array.isArray(template.snapshot?.materials) || !Array.isArray(template.dispatch))
+        return reject('shape', 'template');
+      for (const material of template.snapshot.materials)
+        for (const source of material.textureSources?.values() ?? [])
+          if (!sourceTokens.has(source)) return reject('shape', 'missing target source');
+      if (template.snapshot.skin !== undefined) return reject('shape', 'source GPU skin receipt');
+      const pose = template.snapshot.skinPose;
+      if (
+        pose !== undefined &&
+        (!Number.isInteger(pose.jointCount) ||
+          pose.jointCount <= 0 ||
+          pose.inverseBindMatrices.length !== pose.jointCount ||
+          pose.jointWorlds.length !== pose.jointCount ||
+          [...pose.inverseBindMatrices, ...pose.jointWorlds].some(
+            (matrix) =>
+              !(matrix instanceof Float32Array) ||
+              matrix.length !== 16 ||
+              !matrix.every(Number.isFinite),
+          ))
+      )
+        return reject('shape', 'skin pose');
+      updated.add(entityKey);
+      const snapshot: RenderableSnapshot = {
+        ...template.snapshot,
+        worldId: 0,
+        entityKey,
+        transform: { world },
+      };
+      for (const item of template.dispatch)
+        dispatch.push({ ...item, entityIndex: entityKey, renderableIndex: renderables.length });
+      renderables.push(snapshot);
+      operations.push({ kind: 'update', worldId: 0, entityKey, snapshot });
+    }
+    const removed = new Set<number>();
+    for (const entityKey of packet.removed) {
+      if (!this.entities.has(entityKey) || updated.has(entityKey) || removed.has(entityKey))
+        return reject('shape', 'duplicate removal');
+      removed.add(entityKey);
+      operations.push({ kind: 'remove', worldId: 0, entityKey });
+    }
+    for (const [entityKey, world] of matrices) {
+      if (removed.has(entityKey)) return reject('shape', 'removed transform');
+      if (!updated.has(entityKey) && !this.entities.has(entityKey))
+        return reject('shape', 'unknown transform identity');
+      if (!updated.has(entityKey))
+        operations.push({ kind: 'update', worldId: 0, entityKey, world });
+    }
+    // Validate the complete packet before changing the accepted asset namespace.
+    const assetHandles = new Set<number>();
+    for (const row of packet.assets) {
+      if (
+        row.value === null ||
+        typeof row.value !== 'object' ||
+        !Number.isSafeInteger(row.handle) ||
+        assetHandles.has(row.handle) ||
+        packet.retiredAssets.includes(row.handle)
+      )
+        return reject('shape', 'asset payload');
+      assetHandles.add(row.handle);
+    }
+    for (const handles of [
+      publicationFrameDependencies(packet.metadata),
+      ...renderables.map(publicationDependencies),
+    ]) {
+      if (
+        handles.some(
+          (handle) =>
+            !assetHandles.has(handle) &&
+            (!this.assets.has(handle as Handle<string, 'shared'>) ||
+              packet.retiredAssets.includes(handle as Handle<string, 'shared'>)),
+        )
+      )
+        return reject('shape', 'missing asset dependency');
+    }
+    const guidHandles = new Map(this.guidHandles);
+    for (const [guid, handle] of guidHandles)
+      if (packet.retiredAssets.includes(handle)) guidHandles.delete(guid);
+    for (const row of packet.assets)
+      if (row.guid !== undefined) guidHandles.set(row.guid.toLowerCase(), row.handle);
+    for (const row of renderables)
+      if (row.lods?.some((lod) => !guidHandles.has(AssetGuid.format(lod.mesh).toLowerCase())))
+        return reject('shape', 'missing LOD dependency');
+    for (const entity of removed) this.entities.delete(entity);
+    for (const entity of updated) this.entities.add(entity);
+    if (packet.baseline) this.assets.clear();
+    this.guidHandles.clear();
+    for (const [guid, handle] of guidHandles) this.guidHandles.set(guid, handle);
+    for (const handle of packet.retiredAssets) this.assets.delete(handle);
+    for (const row of packet.assets) this.assets.set(row.handle, row.value);
+    Object.assign(this.resources, { time: packet.time, transparentSort: packet.transparentSort });
+    this.releaseVideoFrames();
+    this.videoFrames = new Map(
+      packet.videoFrames.map((row) => [`${row.entity}:${row.clip}`, row.frame]),
+    );
+    this.revision = packet.revision;
+    return ok({
+      resources: this.resources,
+      packet,
+      operations,
+      frame: {
+        ...packet.metadata,
+        renderables,
+        dispatch,
+        visibilitySnapshots: [],
+        featureVisibilitySnapshots: [],
+        hiddenEntityReports: [],
+        shadowCasterEntityKeys: new Set(),
+        shadowCasterDrawKeys: new Set(),
+      },
+    });
+  }
+
+  /** copyExternalImageToTexture consumes native sources synchronously during draw. */
+  releaseVideoFrames(): void {
+    for (const frame of this.videoFrames.values()) frame.close();
+    this.videoFrames.clear();
+  }
+
+  dispose(): void {
+    this.releaseVideoFrames();
+    this.assets.clear();
+    this.guidHandles.clear();
+    this.entities.clear();
+  }
+
+  get acceptedRevision(): number {
+    return this.revision;
+  }
+}

package/src/publication/resource-scope.ts

@@ -0,0 +1,31 @@
+import type { AssetReader, AssetRegistry } from '@forgeax/engine-assets-runtime';
+import { Time, type TimeResource, type World } from '@forgeax/engine-ecs';
+import { AssetGuid } from '@forgeax/engine-pack/guid';
+import type { Asset, Handle } from '@forgeax/engine-types';
+import type { TransparentSortConfig } from '../systems/transparent-sort-config';
+
+/** Owned data in a receiver, or a synchronously borrowed source World. */
+export interface PublishedRenderResources extends AssetReader {
+  readonly time: TimeResource;
+  readonly transparentSort: TransparentSortConfig;
+  lookupAsset<T extends Asset>(guid: string): T | undefined;
+  videoFrame(entity: number, clip: number): VideoFrame | undefined;
+  handleForGuid(guid: string): Handle<string, 'shared'> | undefined;
+}
+
+export type RenderResourceScope = World | PublishedRenderResources;
+
+export function renderTime(source: RenderResourceScope): TimeResource {
+  return 'resolveAsset' in source ? source.time : source.getResource(Time);
+}
+
+/** GUID consumers use the same accepted resource namespace as handle consumers. */
+export function renderAssetByGuid<T extends Asset>(
+  source: RenderResourceScope,
+  assets: AssetRegistry,
+  guid: string | Parameters<typeof AssetGuid.format>[0],
+): T | undefined {
+  return 'resolveAsset' in source
+    ? source.lookupAsset<T>(typeof guid === 'string' ? guid : AssetGuid.format(guid))
+    : assets.lookup<T>(guid);
+}

package/src/publication/targets.ts

@@ -0,0 +1,182 @@
+import { createRenderTargetHost, type RenderTargetHost } from '../assembly/render-target-host';
+import type {
+  RenderTarget,
+  RenderTargetDescriptor,
+  RenderTargetTextureSource,
+  RenderTargetTextureSourceOptions,
+} from '../targets/contracts';
+import { resolveRenderTargetMaterialSource } from '../targets/material-source';
+import type { RenderPublicationTemplate } from './contract';
+import { RenderPublicationError } from './contract';
+import type { PreparedRenderPublication } from './receiver';
+
+/** Author descriptions synchronously; the consuming Renderer owns physical resources. */
+export type RenderTargetAuthoring = Pick<
+  RenderTargetHost,
+  | 'createRenderTarget'
+  | 'resizeRenderTarget'
+  | 'createRenderTargetTextureSource'
+  | 'destroyRenderTarget'
+>;
+export interface PublishedRenderTarget {
+  readonly id: number;
+  readonly token: RenderTarget;
+  readonly descriptor: RenderTargetDescriptor;
+}
+export interface PublishedRenderTargetSource {
+  readonly token: RenderTargetTextureSource;
+  readonly target: RenderTarget;
+  readonly options: RenderTargetTextureSourceOptions;
+}
+export class RenderPublicationTargetOwner {
+  private readonly host = createRenderTargetHost();
+  private readonly ids = new WeakMap<object, number>();
+  private nextId = 0;
+  readonly authoring: RenderTargetAuthoring = this.host;
+  snapshot(): readonly PublishedRenderTarget[] {
+    return this.host.descriptions().map(({ target, descriptor }) => {
+      let id = this.ids.get(target);
+      if (id === undefined) {
+        id = ++this.nextId;
+        this.ids.set(target, id);
+      }
+      return { id, token: target, descriptor };
+    });
+  }
+  dispose(): void {
+    this.host.dispose();
+  }
+}
+
+export function publicationTargetSources(
+  templates: readonly RenderPublicationTemplate[],
+): readonly PublishedRenderTargetSource[] {
+  const sources = new Map<RenderTargetTextureSource, PublishedRenderTargetSource>();
+  for (const template of templates)
+    for (const material of template.snapshot.materials) {
+      for (const source of material.textureSources?.values() ?? []) {
+        if (sources.has(source)) continue;
+        const binding = resolveRenderTargetMaterialSource(source);
+        if (binding === undefined)
+          throw new RenderPublicationError({
+            reason: 'shape',
+            subject: 'unknown material target source',
+          });
+        sources.set(source, {
+          token: source,
+          target: binding.target,
+          options: {
+            aspect: 'color',
+            dimension: binding.view.dimension,
+            mipLevel: binding.view.mipLevel,
+          },
+        });
+      }
+    }
+  return [...sources.values()];
+}
+
+interface ReceivedTarget {
+  readonly target: RenderTarget;
+  descriptor: RenderTargetDescriptor;
+  readonly sources: Map<string, RenderTargetTextureSource>;
+}
+
+/** Translate logical references once at receive time; no source GPU handle crosses realms. */
+export class RenderPublicationTargetReceiver {
+  private readonly targets = new Map<number, ReceivedTarget>();
+  constructor(private readonly host: RenderTargetAuthoring) {}
+  apply(input: PreparedRenderPublication): PreparedRenderPublication {
+    const packet = input.packet;
+    if (packet.targets.length === 0 && packet.targetSources.length === 0 && this.targets.size === 0)
+      return input;
+    const tokens = new Map<RenderTarget, RenderTarget>();
+    const records = new Map<RenderTarget, ReceivedTarget>();
+    const active = new Set(packet.targets.map((row) => row.id));
+    for (const [id, record] of this.targets)
+      if (!active.has(id)) {
+        const destroyed = this.host.destroyRenderTarget(record.target);
+        if (!destroyed.ok) throw destroyed.error;
+        this.targets.delete(id);
+      }
+    for (const row of packet.targets) {
+      let record = this.targets.get(row.id);
+      if (record === undefined) {
+        const created = this.host.createRenderTarget(row.descriptor);
+        if (!created.ok) throw created.error;
+        record = { target: created.value, descriptor: row.descriptor, sources: new Map() };
+        this.targets.set(row.id, record);
+      } else if (JSON.stringify(record.descriptor) !== JSON.stringify(row.descriptor)) {
+        const resized = this.host.resizeRenderTarget(record.target, row.descriptor);
+        if (!resized.ok) throw resized.error;
+        record.descriptor = row.descriptor;
+        record.sources.clear();
+      }
+      tokens.set(row.token, record.target);
+      records.set(row.token, record);
+    }
+    const resolve = (token: RenderTarget): RenderTarget => {
+      const target = tokens.get(token);
+      if (target === undefined)
+        throw new RenderPublicationError({ reason: 'shape', subject: 'missing target descriptor' });
+      return target;
+    };
+    const sources = new Map<RenderTargetTextureSource, RenderTargetTextureSource>();
+    for (const row of packet.targetSources) {
+      const record = records.get(row.target);
+      if (record === undefined)
+        throw new RenderPublicationError({ reason: 'shape', subject: 'missing material target' });
+      const key = JSON.stringify(row.options);
+      let source = record.sources.get(key);
+      if (source === undefined) {
+        const created = this.host.createRenderTargetTextureSource(record.target, row.options);
+        if (!created.ok) throw created.error;
+        source = created.value;
+        record.sources.set(key, source);
+      }
+      sources.set(row.token, source);
+    }
+    const camera = <T extends { readonly target?: RenderTarget }>(row: T): T =>
+      row.target === undefined ? row : { ...row, target: resolve(row.target) };
+    const renderables = input.frame.renderables.map((row) => {
+      const materials = row.materials.map((material) => {
+        if (material.textureSources === undefined) return material;
+        const textureSources = new Map(
+          [...material.textureSources].map(([name, token]) => {
+            const source = sources.get(token);
+            if (source === undefined)
+              throw new RenderPublicationError({
+                reason: 'shape',
+                subject: 'missing material target source',
+              });
+            return [name, source] as const;
+          }),
+        );
+        return { ...material, textureSources };
+      });
+      const first = row.materials.indexOf(row.material);
+      return { ...row, materials, material: materials[Math.max(0, first)] ?? row.material };
+    });
+    const snapshots = new Map(renderables.map((row) => [row.entityKey, row]));
+    return {
+      ...input,
+      frame: {
+        ...input.frame,
+        renderables,
+        cameras: input.frame.cameras.map(camera),
+        auxiliaryCameras: input.frame.auxiliaryCameras.map(camera),
+        cubeCameras: input.frame.cubeCameras.map(camera),
+      },
+      operations: input.operations.map((operation) => {
+        if (operation.kind === 'remove' || operation.snapshot === undefined) return operation;
+        const snapshot = snapshots.get(operation.entityKey);
+        if (snapshot === undefined)
+          throw new RenderPublicationError({
+            reason: 'shape',
+            subject: 'missing remapped snapshot',
+          });
+        return { ...operation, snapshot };
+      }),
+    };
+  }
+}

package/src/publication/video.ts

@@ -0,0 +1,33 @@
+import type { EntityHandle, World } from '@forgeax/engine-ecs';
+import {
+  VIDEO_SOURCE_PROVIDER_KEY,
+  type VideoSourceProvider,
+  videoSourceExtent,
+} from '@forgeax/engine-graphics-extras';
+import type { Handle } from '@forgeax/engine-types';
+import type { RenderPublication } from './contract';
+
+/** Native VideoFrame cloning shares decoded pixels; it never copies source ECS storage. */
+export function publicationVideoFrames(
+  world: World,
+  consumers: ReadonlyMap<number, readonly number[]>,
+): RenderPublication['videoFrames'] {
+  if (consumers.size === 0 || !world.hasResource(VIDEO_SOURCE_PROVIDER_KEY)) return [];
+  const provider = world.getResource<VideoSourceProvider>(VIDEO_SOURCE_PROVIDER_KEY);
+  const frames: RenderPublication['videoFrames'][number][] = [];
+  try {
+    for (const [entity, clips] of consumers)
+      for (const clip of clips) {
+        const source = provider.getSource(
+          entity as EntityHandle,
+          clip as Handle<'VideoAsset', 'shared'>,
+        );
+        if (source === undefined || videoSourceExtent(source) === undefined) continue;
+        frames.push({ entity, clip, frame: new VideoFrame(source) });
+      }
+    return frames;
+  } catch (cause) {
+    for (const row of frames) row.frame.close();
+    throw cause;
+  }
+}

package/src/record/__tests__/main-pass-geometry.unit.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import type { DispatchEntry } from '../../render-system-extract';
 import {
+  authoredTransparentDepthWrite,
   geometryRenderStateForPass,
   requestsStandardTransmissionVariant,
   sameOpaqueTemporalDraw,
@@ -21,6 +22,35 @@ describe('geometry pass render state', () => {
     });
   });
 
+  it('does not force depth writes for alpha smoke while allowing authored water depth', () => {
+    expect(
+      authoredTransparentDepthWrite(true, {
+        blend: {
+          color: {
+            srcFactor: 'src-alpha',
+            dstFactor: 'one-minus-src-alpha',
+            operation: 'add',
+          },
+          alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+        },
+      }),
+    ).toBe(false);
+    expect(
+      authoredTransparentDepthWrite(true, {
+        depthWriteEnabled: true,
+        depthCompare: 'less-equal',
+        blend: {
+          color: {
+            srcFactor: 'src-alpha',
+            dstFactor: 'one-minus-src-alpha',
+            operation: 'add',
+          },
+          alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+        },
+      }),
+    ).toBe(true);
+  });
+
   it('does not rewrite the base state for colour passes', () => {
     const base = {
       cullMode: 'none' as const,

package/src/record/__tests__/material-bg-cache.unit.test.ts

@@ -1,6 +1,7 @@
 import type { BindGroup, BindGroupLayout, Buffer, TextureView } from '@forgeax/engine-rhi';
 import { describe, expect, it } from 'vitest';
 import type { MaterialSnapshot } from '../../render-system-extract';
+import type { RenderTargetTextureSource } from '../../targets/contracts';
 import type { MaterialBgAssemblyCacheEntry } from '../frame-snapshot';
 import { isMaterialBgAssemblyCacheHit } from '../main-pass-material';
 
@@ -16,7 +17,6 @@ describe('material bind-group assembly cache', () => {
       prefilterView: {},
       prefilterSampler: {},
       brdfLutView: {},
-      brdfLutSampler: {},
       intensityBuffer: {},
     } as MaterialBgAssemblyCacheEntry['skylightResources'];
     const cached: MaterialBgAssemblyCacheEntry = {
@@ -44,6 +44,20 @@ describe('material bind-group assembly cache', () => {
         7,
       ),
     ).toBe(false);
+    const targetMaterial = {
+      ...material,
+      textureSources: new Map([['baseColorTexture', {} as RenderTargetTextureSource]]),
+    };
+    expect(
+      isMaterialBgAssemblyCacheHit(
+        { ...cached, material: targetMaterial },
+        targetMaterial,
+        materialBgl,
+        oldBuffer,
+        skylightResources,
+        7,
+      ),
+    ).toBe(false);
     const sceneCached = { ...cached, sceneMaterialBuffer: oldBuffer };
     expect(
       isMaterialBgAssemblyCacheHit(

package/src/record/__tests__/sprite-material-abi.unit.test.ts

@@ -38,7 +38,7 @@ describe('sprite Standard material ABI', () => {
 
     // Sprite no longer owns a parallel material-entry builder. Preserve the
     // shared user-region/IBL layout gate; actual sampler selection is covered
-    // by the source-derived 300-frame Sprite raster smoke in both tone lanes.
+    // by the source-derived 60-frame Sprite raster smoke in both tone lanes.
     const entries: BindGroupEntry[] = [
       { binding: 0, resource: { kind: 'buffer', value: { buffer: {} as Buffer } } },
     ];
@@ -72,22 +72,21 @@ describe('sprite Standard material ABI', () => {
       prefilterView: {} as TextureView,
       prefilterSampler: sampler,
       brdfLutView: {} as TextureView,
-      brdfLutSampler: sampler,
       intensityBuffer: {} as Buffer,
     });
     expect(merged[15]).toMatchObject({
       binding: 15,
       resource: { kind: 'textureView' },
     });
-    expect(merged[22]).toMatchObject({
-      binding: 22,
+    expect(merged[21]).toMatchObject({
+      binding: 21,
       resource: { kind: 'sampler', value: sampler },
     });
-    expect(merged[23]).toMatchObject({
-      binding: 23,
+    expect(merged[22]).toMatchObject({
+      binding: 22,
       resource: { kind: 'textureView' },
     });
-    expect(merged).toHaveLength(25);
+    expect(merged).toHaveLength(24);
     expect(merged.find((entry) => entry.binding === 47)?.resource.kind).toBe('textureView');
 
     const complete = [
@@ -97,7 +96,7 @@ describe('sprite Standard material ABI', () => {
         resource: { kind: 'buffer' as const, value: { buffer: {} as Buffer } },
       },
     ];
-    expect(complete).toHaveLength(26);
+    expect(complete).toHaveLength(25);
     expect(complete.find((entry) => entry.binding === 46)).toMatchObject({
       binding: 46,
       resource: { kind: 'buffer' },
@@ -112,13 +111,12 @@ describe('sprite Standard material ABI', () => {
         prefilterView: {} as TextureView,
         prefilterSampler: sampler,
         brdfLutView: {} as TextureView,
-        brdfLutSampler: sampler,
         intensityBuffer: {} as Buffer,
       },
       { sampler, backdropView: backdrop },
     );
-    expect(active[23]).toMatchObject({
-      binding: 23,
+    expect(active[22]).toMatchObject({
+      binding: 22,
       resource: { kind: 'textureView', value: backdrop },
     });
   });