@forgeax/engine-runtime 0.1.4 → 0.1.6

package/src/__tests__/fog-producer-real-fixture.ts

@@ -1,805 +0,0 @@
-import {
-  type AssetRegistry,
-  createAssetRegistry,
-  createCatalogSource,
-} from '@forgeax/engine-assets-runtime';
-import { createWorldContext, World } from '@forgeax/engine-ecs';
-import { createPlaneGeometry, meshAssetContribution } from '@forgeax/engine-geometry';
-import { mat4 } from '@forgeax/engine-math';
-import {
-  Camera,
-  Fog,
-  Materials,
-  MeshFilter,
-  MeshRenderer,
-  materialContribution,
-  materialTextureValue,
-  renderComponentsPlugin,
-  SkyboxBackground,
-  Skylight,
-  TONEMAP_NONE,
-  TONEMAP_REINHARD_EXTENDED,
-} from '@forgeax/engine-render';
-import { ok as rhiOk } from '@forgeax/engine-rhi';
-import { scenePlugin, Transform } from '@forgeax/engine-scene';
-import { Skin, skinningPlugin } from '@forgeax/engine-skinning';
-import type {
-  CatalogEntry,
-  DecodedImage,
-  EquirectAsset,
-  Handle,
-  MaterialAsset,
-  MeshAsset,
-  SkeletonAsset,
-  TextureAsset,
-} from '@forgeax/engine-types';
-import { ParticleEffectPlayer } from '@forgeax/engine-vfx';
-import {
-  createCameraProvider,
-  createSceneDepthProvider,
-  createVfxRuntimeHost,
-} from '@forgeax/engine-vfx-render';
-import { readbackTexturePixels } from '../../../rhi-debug/src/readback';
-import { createRenderer } from '../createRenderer';
-import type { FogProducerCase } from './fog-producer-manifest';
-import type {
-  FogPixel,
-  FogProbeManifest,
-  FogProducerPixelCapture,
-  FogRaySample,
-} from './fog-producer-pixel-probe';
-import { FOG_VFX_EFFECT } from './fog-producer-vfx-effect';
-
-const BASE_COLOR = [0.75, 0.25, 0.1, 0.63] as const;
-const FOG_COLOR = [0.6, 0.45, 0.8] as const;
-const MATERIAL_GUID = '00000000-0000-7000-8000-00000000f001';
-const MESH_GUID = '00000000-0000-7000-8000-00000000f002';
-const TOPOLOGY_VFX_MODULE = 'fog-producer.vfx.wgsl';
-const FOG_RAY: FogRaySample = {
-  origin: [0, 0, 0],
-  direction: [0, 0, -1],
-  distance: 6,
-};
-const TOPOLOGY_VFX_SOURCE = `#import forgeax_vfx::prelude::{VfxParticle, VfxSpawnContext, VfxUpdateContext, vfx_integrate}
-fn vfx_spawn(ctx: VfxSpawnContext, particle: ptr<function, VfxParticle>) {
-  let lane = f32(ctx.particleId & 3u);
-  (*particle).position = vec4<f32>((lane - 1.5) * 0.12, 0.0, 0.0, 1.0);
-  (*particle).velocity = vec4<f32>(0.8, 0.0, 0.0, 0.0);
-  (*particle).color = vec4<f32>(0.2, 0.6, 1.0, 1.0);
-  (*particle).size_rotation = vec4<f32>(0.22, 0.22, 0.0, 0.0);
-  (*particle).lifetime = 100.0;
-}
-fn vfx_update(ctx: VfxUpdateContext, particle: ptr<function, VfxParticle>) {
-  (*particle).velocity = vec4<f32>((*particle).velocity.xyz, 0.0);
-  vfx_integrate(ctx, particle);
-  (*particle).color = vec4<f32>(0.2, 0.6, 1.0, 1.0);
-}
-`;
-
-function serializedFogVfxMesh(mesh: MeshAsset): Record<string, unknown> {
-  return {
-    kind: 'mesh',
-    vertices: Array.from(mesh.vertices),
-    attributes: Object.fromEntries(
-      Object.entries(mesh.attributes).map(([key, value]) => [key, Array.from(value)]),
-    ),
-    ...(mesh.indices === undefined ? {} : { indices: Array.from(mesh.indices) }),
-    ...(mesh.aabb === undefined ? {} : { aabb: Array.from(mesh.aabb) }),
-    submeshes: mesh.submeshes,
-    materialSlots: mesh.materialSlots,
-  };
-}
-
-function createFogVfxAssetRegistry(material: MaterialAsset, mesh: MeshAsset): AssetRegistry {
-  const scopeId = 'fog-producer-fixture';
-  const generation = 0;
-  const digest = 'fog-producer-fixture-digest';
-  const outputSetDigest = 'fog-producer-fixture-output-set';
-  const packageUrl = `data:application/json,${encodeURIComponent(
-    JSON.stringify({
-      schemaVersion: '2.0.0',
-      kind: 'internal-text-package',
-      scopeId,
-      generation,
-      digest,
-      outputSetDigest,
-      assets: [
-        { guid: MATERIAL_GUID, kind: 'material', payload: material, refs: [], artifacts: {} },
-        {
-          guid: MESH_GUID,
-          kind: 'mesh',
-          payload: serializedFogVfxMesh(mesh),
-          refs: [],
-          artifacts: {},
-        },
-      ],
-    }),
-  )}`;
-  const publication: NonNullable<CatalogEntry['publication']> = {
-    schemaVersion: 'asset-publication/1',
-    sourcePath: 'fog-producer-fixture',
-    sourceRevision: 'fixture',
-    generation,
-    digest,
-    outputSetDigest,
-    outputs: [
-      { guid: MATERIAL_GUID, sourceKey: MATERIAL_GUID, kind: 'material', digest, refs: [] },
-      { guid: MESH_GUID, sourceKey: MESH_GUID, kind: 'mesh', digest, refs: [] },
-    ],
-    receipt: {
-      schemaVersion: 'asset-publication-receipt/1',
-      sourcePath: 'fog-producer-fixture',
-      sourceRevision: 'fixture',
-      inputFingerprint: 'fog-producer-fixture',
-      outputDigest: digest,
-      outputSetDigest,
-      externalEvidence: [],
-    },
-    externalEvidence: [],
-  };
-  const entries: readonly CatalogEntry[] = [MATERIAL_GUID, MESH_GUID].map((guid, index) => ({
-    guid,
-    packageUrl,
-    kind: index === 0 ? 'material' : 'mesh',
-    sourcePath: 'fog-producer-fixture',
-    publication,
-  }));
-  const registry = createAssetRegistry({
-    catalog: createCatalogSource({ entries }),
-    scopeId,
-    generation,
-  });
-  registry.installDecoder(materialContribution.kind, materialContribution.decoder);
-  registry.installDecoder(meshAssetContribution.kind, meshAssetContribution.decoder);
-  return registry;
-}
-
-type Surface = {
-  readonly canvas: HTMLCanvasElement;
-  readonly width: number;
-  readonly height: number;
-};
-
-function waitForFrameBoundary(): Promise<void> {
-  return new Promise((resolve) => {
-    if (typeof requestAnimationFrame === 'function') {
-      requestAnimationFrame(() => resolve());
-      return;
-    }
-    setTimeout(resolve, 0);
-  });
-}
-
-function surface(): Surface {
-  if (typeof document !== 'undefined') {
-    const canvas = document.createElement('canvas');
-    canvas.width = 1;
-    canvas.height = 1;
-    return { canvas, width: 1, height: 1 };
-  }
-  let target: GPUTexture | undefined;
-  const canvas = {
-    width: 1,
-    height: 1,
-    getContext(kind: string) {
-      if (kind !== 'webgpu') return null;
-      return {
-        configure(desc: { readonly device: GPUDevice; readonly format?: GPUTextureFormat }) {
-          target = desc.device.createTexture({
-            size: { width: 1, height: 1, depthOrArrayLayers: 1 },
-            format: desc.format ?? 'rgba8unorm',
-            usage: 0x10 | 0x01,
-            viewFormats: ['rgba8unorm-srgb'],
-          });
-        },
-        unconfigure() {},
-        getCurrentTexture() {
-          if (target === undefined) throw new Error('fog fixture surface is not configured');
-          return target;
-        },
-      };
-    },
-    addEventListener() {},
-    removeEventListener() {},
-  } as unknown as HTMLCanvasElement;
-  return { canvas, width: 1, height: 1 };
-}
-
-function materialPass(
-  module: string,
-  name = 'forward',
-): NonNullable<MaterialAsset['passes']>[number] {
-  return {
-    name,
-    program: { module },
-    renderState: {
-      cullMode: 'none',
-      tags: { LightMode: 'Forward' },
-      queue: 2000,
-    },
-  };
-}
-
-function spriteMaterial(): MaterialAsset {
-  return {
-    kind: 'material',
-    passes: [
-      {
-        ...materialPass('forgeax::sprite'),
-        renderState: {
-          ...materialPass('forgeax::sprite').renderState,
-          blend: {
-            color: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-            alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-          },
-        },
-      },
-    ],
-    values: {
-      colorTint: BASE_COLOR,
-      region: [0, 0, 1, 1],
-      pivotAndSize: [0.5, 0.5, 1, 1],
-      slicesAndMode: [0, 0, 0, 0],
-    },
-    parameters: [
-      { name: 'colorTint', type: 'vec4', default: [1, 1, 1, 1] },
-      { name: 'region', type: 'vec4', default: [0, 0, 1, 1] },
-      { name: 'pivotAndSize', type: 'vec4', default: [0.5, 0.5, 1, 1] },
-      { name: 'slicesAndMode', type: 'vec4', default: [0, 0, 0, 0] },
-    ],
-  };
-}
-
-function textMaterial(texture: Handle<'TextureAsset', 'shared'>): MaterialAsset {
-  return {
-    kind: 'material',
-    passes: [
-      {
-        ...materialPass('forgeax::msdf-text', 'text'),
-        renderState: {
-          ...materialPass('forgeax::msdf-text', 'text').renderState,
-          blend: {
-            color: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-            alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-          },
-          depthWriteEnabled: false,
-          queue: 3000,
-        },
-      },
-    ],
-    values: {
-      tintColor: BASE_COLOR,
-      distanceRange: [4, 1, 1, 0],
-      baseColorTexture: materialTextureValue(texture),
-    },
-    parameters: [
-      { name: 'tintColor', type: 'color', default: [1, 1, 1, 1] },
-      { name: 'distanceRange', type: 'vec4', default: [4, 512, 512, 0] },
-      { name: 'baseColorTexture', type: 'texture' },
-    ],
-  };
-}
-
-function textAtlas(): TextureAsset {
-  return {
-    kind: 'texture',
-    width: 1,
-    height: 1,
-    format: 'rgba8unorm',
-    data: new Uint8Array([255, 255, 255, 255]),
-    colorSpace: 'linear',
-    mipmap: false,
-  };
-}
-
-function decodedTexture(texture: TextureAsset): DecodedImage {
-  return {
-    bytes: new Uint8Array(texture.data),
-    width: texture.width,
-    height: texture.height,
-    mime: 'image/png',
-    colorSpace: texture.colorSpace,
-    mipmap: texture.mipmap,
-  };
-}
-
-function vfxMaterial(kind: 'billboard' | 'mesh' | 'ribbon' | 'trail' | 'beam'): MaterialAsset {
-  return {
-    kind: 'material',
-    passes: [
-      {
-        ...materialPass(`forgeax::vfx-render.particles.${kind}`, `particle-${kind}`),
-        renderState: {
-          ...materialPass(`forgeax::vfx-render.particles.${kind}`, `particle-${kind}`).renderState,
-          depthWriteEnabled: false,
-          blend: {
-            color: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-            alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-          },
-          queue: 3000,
-        },
-      },
-    ],
-  };
-}
-
-function equirect(): EquirectAsset {
-  return {
-    kind: 'equirect',
-    width: 2,
-    height: 1,
-    format: 'rgba16float',
-    data: new Uint8Array(16),
-    colorSpace: 'linear',
-  };
-}
-
-function halfToFloat(bits: number): number {
-  const sign = (bits & 0x8000) === 0 ? 1 : -1;
-  const exponent = (bits >>> 10) & 0x1f;
-  const fraction = bits & 0x03ff;
-  if (exponent === 0) return sign * 2 ** -14 * (fraction / 1024);
-  if (exponent === 0x1f) return fraction === 0 ? sign * Infinity : Number.NaN;
-  return sign * 2 ** (exponent - 15) * (1 + fraction / 1024);
-}
-
-function decodePixel(bytes: Uint8Array): FogPixel {
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  return [
-    halfToFloat(view.getUint16(0, true)),
-    halfToFloat(view.getUint16(2, true)),
-    halfToFloat(view.getUint16(4, true)),
-    halfToFloat(view.getUint16(6, true)),
-  ];
-}
-
-function spawnCamera(world: World, tonemap: number): void {
-  world
-    .spawn(
-      { component: Transform, data: { pos: [0, 0, 0], quat: [0, 0, 0, 1], scale: [1, 1, 1] } },
-      {
-        component: Camera,
-        data: {
-          fov: Math.PI / 4,
-          aspect: 1,
-          near: 0.1,
-          far: 20,
-          tonemap,
-          exposure: 1,
-          whitePoint: 4,
-        },
-      },
-    )
-    .unwrap();
-}
-
-function weightedMesh(mesh: MeshAsset): MeshAsset {
-  const position = mesh.attributes.position;
-  if (position === undefined) throw new Error('Fog skin fixture mesh has no position attribute');
-  const vertexCount = position.byteLength / Float32Array.BYTES_PER_ELEMENT / 3;
-  const vertices = new Float32Array(vertexCount * 18);
-  const packedIndices = new Uint16Array(vertices.buffer);
-  for (let vertex = 0; vertex < vertexCount; vertex += 1) {
-    vertices.set(mesh.vertices.subarray(vertex * 12, vertex * 12 + 12), vertex * 18);
-    const packedOffset = vertex * 36 + 24;
-    for (let lane = 0; lane < 4; lane += 1) packedIndices[packedOffset + lane] = 0;
-    vertices[vertex * 18 + 14] = 1;
-  }
-  const skinIndex = new Uint16Array(vertexCount * 4);
-  const skinWeight = new Float32Array(vertexCount * 4);
-  for (let vertex = 0; vertex < vertexCount; vertex += 1) {
-    skinWeight[vertex * 4] = 1;
-  }
-  return {
-    ...mesh,
-    vertices,
-    attributes: { ...mesh.attributes, skinIndex, skinWeight },
-  };
-}
-
-function spawnSkinnedRenderable(
-  world: World,
-  mesh: Handle<'MeshAsset', 'shared'>,
-  material: Handle<'MaterialAsset', 'shared'>,
-): void {
-  const skeleton: SkeletonAsset = {
-    kind: 'skeleton',
-    jointCount: 1,
-    inverseBindMatrices: new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]),
-  };
-  const skeletonHandle = world.allocSharedRef('SkeletonAsset', skeleton);
-  const joint = world
-    .spawn({
-      component: Transform,
-      data: { pos: [0, 0, -6], quat: [0, 0, 0, 1], scale: [1, 1, 1] },
-    })
-    .unwrap();
-  world
-    .spawn(
-      { component: Transform, data: { pos: [0, 0, -6], quat: [0, 0, 0, 1], scale: [1, 1, 1] } },
-      { component: MeshFilter, data: { assetHandle: mesh } },
-      { component: MeshRenderer, data: { materials: [material] } },
-      { component: Skin, data: { skeleton: skeletonHandle, joints: [joint] } },
-    )
-    .unwrap();
-}
-
-function spawnSceneRenderable(
-  world: World,
-  producer: FogProducerCase,
-  mesh: Handle<'MeshAsset', 'shared'>,
-  textTexture?: Handle<'TextureAsset', 'shared'>,
-): void {
-  const material = world.allocSharedRef(
-    'MaterialAsset',
-    producer.domain === 'sprite'
-      ? spriteMaterial()
-      : producer.domain === 'text'
-        ? textTexture === undefined
-          ? (() => {
-              throw new Error('Fog text fixture has no MSDF atlas texture');
-            })()
-          : textMaterial(textTexture)
-        : producer.id === 'urp-pbr-skin'
-          ? {
-              kind: 'material',
-              passes: [materialPass('forgeax::pbr-skin')],
-              values: { baseColor: BASE_COLOR, metallic: 0, roughness: 1 },
-            }
-          : Materials.standard({
-              baseColor: BASE_COLOR,
-              colorSpace: 'linear',
-              metallic: 0,
-              roughness: 1,
-              castShadow: false,
-              renderState: { cullMode: 'none' },
-            }),
-  );
-  if (producer.id === 'urp-pbr-skin') {
-    spawnSkinnedRenderable(world, mesh, material);
-    return;
-  }
-  world
-    .spawn(
-      { component: Transform, data: { pos: [0, 0, -6], quat: [0, 0, 0, 1], scale: [1, 1, 1] } },
-      { component: MeshFilter, data: { assetHandle: mesh } },
-      { component: MeshRenderer, data: { materials: [material] } },
-    )
-    .unwrap();
-}
-
-async function cookVfx(producer: FogProducerCase) {
-  const rendererKind = producer.id.slice(4) as 'billboard' | 'mesh' | 'ribbon' | 'trail' | 'beam';
-  if (typeof window !== 'undefined') {
-    const emitter = FOG_VFX_EFFECT.program.emitters[0];
-    if (emitter === undefined) throw new Error('Fog Browser VFX fixture has no emitter');
-    const index = emitter.renderers.findIndex(
-      (renderer) => (renderer as { readonly kind?: unknown }).kind === rendererKind,
-    );
-    const reflection = emitter.reflection as {
-      readonly renderers: readonly object[];
-    };
-    const reflectionRenderer = reflection.renderers[index];
-    const renderer = emitter.renderers[index];
-    if (renderer === undefined || reflectionRenderer === undefined) {
-      throw new Error(`Fog Browser VFX fixture has no ${rendererKind} renderer`);
-    }
-    return {
-      ...FOG_VFX_EFFECT,
-      program: {
-        ...FOG_VFX_EFFECT.program,
-        emitters: [
-          {
-            ...emitter,
-            renderers: [renderer],
-            reflection: { ...reflection, renderers: [reflectionRenderer] },
-          },
-        ],
-      },
-    };
-  }
-  const { cookParticleCodeEffect } = await import('@forgeax/engine-vfx-compiler');
-  const renderer =
-    rendererKind === 'billboard'
-      ? {
-          kind: 'billboard' as const,
-          material: MATERIAL_GUID,
-          capacity: 4,
-          blend: 'alpha' as const,
-        }
-      : rendererKind === 'mesh'
-        ? { kind: 'mesh' as const, material: MATERIAL_GUID, mesh: MESH_GUID }
-        : rendererKind === 'ribbon'
-          ? {
-              kind: 'ribbon' as const,
-              material: MATERIAL_GUID,
-              capacity: 4,
-              stripKey: 'alive-index' as const,
-            }
-          : rendererKind === 'trail'
-            ? { kind: 'trail' as const, material: MATERIAL_GUID, capacity: 4, historyLength: 4 }
-            : {
-                kind: 'beam' as const,
-                material: MATERIAL_GUID,
-                capacity: 4,
-                endpointField: 'velocity' as const,
-              };
-  const cooked = await cookParticleCodeEffect(
-    {
-      schemaVersion: 2,
-      emitters: [
-        {
-          id: 'fog-producer',
-          capacity: 4,
-          backend: { required: 'gpu' },
-          space: 'local',
-          bounds: { kind: 'sphere', center: [0, 0, 0], radius: 2 },
-          schedule: { rate: 0, bursts: [{ time: 0, count: 4 }] },
-          program: { module: TOPOLOGY_VFX_MODULE },
-          renderers: [renderer],
-          simulationWhenCulled: 'continue',
-        },
-      ],
-    },
-    { [TOPOLOGY_VFX_MODULE]: { entry: TOPOLOGY_VFX_SOURCE } },
-  );
-  if (!cooked.ok) throw new Error(`Fog VFX fixture cook failed: ${cooked.error.hint}`);
-  return cooked.value.asset;
-}
-
-export function createFogProducerPixelCapture(manifest: FogProbeManifest): FogProducerPixelCapture {
-  const manifestUrl = `data:application/json,${encodeURIComponent(JSON.stringify(manifest))}`;
-  return async (producer) => {
-    const s = surface();
-    const vfxHost =
-      producer.domain === 'vfx'
-        ? createVfxRuntimeHost({
-            camera: {
-              read: () => ({
-                position: new Float32Array([0, 0, 0]),
-                right: new Float32Array([1, 0, 0]),
-                up: new Float32Array([0, 1, 0]),
-                viewProjection: mat4.perspective(mat4.create(), Math.PI / 4, 1, 0.1, 20),
-              }),
-            },
-            providers: [
-              createCameraProvider({ available: () => true }),
-              createSceneDepthProvider({ available: () => true }),
-            ],
-          })
-        : undefined;
-    const renderer = await createRenderer(
-      s.canvas,
-      vfxHost === undefined ? {} : { features: [vfxHost.feature] },
-      typeof window === 'undefined' ? { shaderManifestUrl: manifestUrl } : undefined,
-    );
-    const rendererErrors: string[] = [];
-    renderer.onError((error) => {
-      rendererErrors.push(
-        JSON.stringify({
-          code: error.code,
-          hint: error.hint,
-          detail: 'detail' in error ? error.detail : undefined,
-        }),
-      );
-    });
-    try {
-      const ready = await renderer.ready;
-      if (!ready.ok) throw new Error(`Fog producer renderer not ready: ${ready.error.hint}`);
-      if (producer.domain === 'hdrp-deferred' || producer.domain === 'hdrp-forward') {
-        const installed = renderer.installPipeline({
-          kind: 'render-pipeline',
-          pipelineId: 'forgeax::hdrp',
-          config: { clusterGrid: { x: 16, y: 9, z: 24 } },
-        });
-        if (!installed.ok)
-          throw new Error(`Fog HDRP fixture install failed: ${installed.error.hint}`);
-      }
-      const captureState = async (fogEnabled: boolean): Promise<FogPixel> => {
-        let worldContext: { readonly fiber: { dispose(): Promise<void> } } | undefined;
-        let fixtureWorld: World | undefined;
-        let vfxWorldAttached = false;
-        let vfxAssets: AssetRegistry | undefined;
-        let removeFrameEndListener: (() => void) | undefined;
-        try {
-          const world = new World();
-          fixtureWorld = world;
-          worldContext = await createWorldContext(world, [
-            renderComponentsPlugin(),
-            scenePlugin(),
-            skinningPlugin(),
-          ]);
-          world
-            .spawn({
-              component: Fog,
-              data: {
-                color: FOG_COLOR,
-                density: fogEnabled ? 0.08 : 0,
-                heightFalloff: 0.1,
-                maxOpacity: fogEnabled ? 0.9 : 0,
-              },
-            })
-            .unwrap();
-          const meshAsset = createPlaneGeometry(2.8, 2.8).unwrap();
-          const mesh = world.allocSharedRef(
-            'MeshAsset',
-            producer.id === 'urp-pbr-skin' ? weightedMesh(meshAsset) : meshAsset,
-          );
-          spawnCamera(
-            world,
-            producer.domain === 'skybox' ? TONEMAP_REINHARD_EXTENDED : TONEMAP_NONE,
-          );
-          if (producer.domain === 'skybox') {
-            const environment = world.allocSharedRef('EquirectAsset', equirect());
-            world.spawn({ component: Skylight, data: { equirect: environment } }).unwrap();
-            world.spawn({ component: SkyboxBackground, data: { equirect: environment } }).unwrap();
-          } else if (producer.domain === 'vfx') {
-            vfxAssets = createFogVfxAssetRegistry(
-              vfxMaterial(producer.id.slice(4) as never),
-              meshAsset,
-            );
-            const materialProbe = await vfxAssets.load(MATERIAL_GUID, materialContribution.kind);
-            if (!materialProbe.ok) {
-              throw new Error(
-                `Fog VFX material asset load failed: ${JSON.stringify(materialProbe.error)}`,
-              );
-            }
-            const meshProbe = await vfxAssets.load(MESH_GUID, meshAssetContribution.kind);
-            if (!meshProbe.ok) {
-              throw new Error(`Fog VFX mesh asset load failed: ${JSON.stringify(meshProbe.error)}`);
-            }
-            const effect = await cookVfx(producer);
-            const effectHandle = world.allocSharedRef('ParticleEffectAsset', effect);
-            world
-              .spawn(
-                {
-                  component: Transform,
-                  data: { pos: [0, 0, -6], quat: [0, 0, 0, 1], scale: [1, 1, 1] },
-                },
-                {
-                  component: ParticleEffectPlayer,
-                  data: { effect: effectHandle, playing: true, seed: 7, timeScale: 1 },
-                },
-              )
-              .unwrap();
-            const attached = await vfxHost?.attachWorld({ world, assets: vfxAssets });
-            if (attached === undefined || !attached.ok) {
-              throw new Error(
-                `Fog VFX host attach failed: ${attached?.error.hint ?? 'host unavailable'}`,
-              );
-            }
-            vfxWorldAttached = true;
-          } else {
-            const atlas = producer.domain === 'text' ? textAtlas() : undefined;
-            const textTexture =
-              atlas === undefined ? undefined : world.allocSharedRef('TextureAsset', atlas);
-            if (atlas !== undefined && textTexture !== undefined) {
-              const uploaded = await renderer.store.uploadTexture(
-                textTexture,
-                atlas,
-                decodedTexture(atlas),
-              );
-              if (!uploaded.ok)
-                throw new Error(`Fog text atlas upload failed: ${uploaded.error.hint}`);
-            }
-            spawnSceneRenderable(world, producer, mesh, textTexture);
-          }
-          const attached = renderer.attachWorld(world);
-          if (!attached.ok)
-            throw new Error(`Fog producer world attach failed: ${attached.error.hint}`);
-          let drawError = 'unknown draw failure';
-          let submittedFrames = 0;
-          let simulationFrames = 0;
-          removeFrameEndListener = renderer.subscribeFrameEnd(() => {
-            submittedFrames += 1;
-          });
-          const minimumFrames =
-            producer.id === 'vfx-trail'
-              ? 6
-              : producer.domain === 'vfx' || producer.domain === 'text'
-                ? 3
-                : producer.domain === 'skybox'
-                  ? 3
-                  : producer.id === 'urp-pbr-skin'
-                    ? 4
-                    : producer.domain.startsWith('hdrp-')
-                      ? 4
-                      : 1;
-          const maxAttempts = minimumFrames + 64;
-          let vfxReady = producer.domain !== 'vfx';
-          for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-            if (simulationFrames === submittedFrames) {
-              if (!world.update(1 / 60).ok) throw new Error('Fog producer world update failed');
-              simulationFrames += 1;
-            }
-            const submittedBefore = submittedFrames;
-            const draw = renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-            if (!draw.ok) {
-              if (draw.error.code !== 'rhi-not-available') {
-                throw new Error(
-                  `Fog producer draw failed for ${producer.id} (fogEnabled=${fogEnabled}): ${draw.error.code}; expected=${draw.error.expected}; hint=${draw.error.hint}; health=${JSON.stringify(renderer.health())}; renderer=${rendererErrors.slice(-3).join(' | ') || 'none'}`,
-                );
-              }
-              drawError = draw.error.hint;
-            } else {
-              await renderer.device.queue.onSubmittedWorkDone();
-            }
-            const vfxObservation = vfxHost?.feature.inspect();
-            if (producer.domain === 'vfx') {
-              vfxReady =
-                (vfxObservation?.dispatches ?? 0) > 0 &&
-                (vfxObservation?.indirectDraws ?? 0) > 0 &&
-                (vfxObservation?.subjectOutputs ?? 0) > 0;
-            }
-            if (submittedFrames >= minimumFrames && (producer.domain !== 'vfx' || vfxReady)) break;
-            if (submittedFrames === submittedBefore) await waitForFrameBoundary();
-          }
-          if (submittedFrames < minimumFrames || !vfxReady) {
-            throw new Error(
-              `Fog producer draw did not reach readiness for ${producer.id} (fogEnabled=${fogEnabled}): ${drawError}; submittedFrames=${submittedFrames}/${minimumFrames}; vfxReady=${vfxReady}; health=${JSON.stringify(renderer.health())}; renderer=${rendererErrors.slice(-3).join(' | ') || 'none'}`,
-            );
-          }
-          const observe = async (): Promise<{
-            readonly bytes: Uint8Array;
-            readonly pixel: FogPixel;
-          }> => {
-            const frame = await renderer.observeCurrentFrame({
-              semantic: 'linear-hdr',
-              readback: async (lease) => {
-                const source = lease.beginReadback();
-                if (!source.ok) throw new Error(source.error.hint);
-                return rhiOk(
-                  await readbackTexturePixels(
-                    renderer.device,
-                    source.value.texture,
-                    lease.descriptor.size.width,
-                    lease.descriptor.size.height,
-                    { bytesPerTexel: 8 },
-                  ),
-                );
-              },
-            });
-            if (!frame.ok) throw new Error(`Fog producer observation failed: ${frame.error.hint}`);
-            return { bytes: frame.value.bytes, pixel: decodePixel(frame.value.bytes) };
-          };
-          const observation = await observe();
-          const energy = Math.max(...observation.pixel.map((value) => Math.abs(value)));
-          if (!Number.isFinite(energy) || energy <= 0.01) {
-            throw new Error(
-              `Fog producer geometry unavailable for ${producer.id} (fogEnabled=${fogEnabled}): pixel energy=${energy}; bytes=${observation.bytes.length}; submittedFrames=${submittedFrames}; simulationFrames=${simulationFrames}; vfx=${JSON.stringify(vfxHost?.feature.inspect() ?? null)}; health=${JSON.stringify(renderer.health())}; renderer=${rendererErrors.slice(-3).join(' | ') || 'none'}`,
-            );
-          }
-          return observation.pixel;
-        } finally {
-          if (vfxWorldAttached && fixtureWorld !== undefined && vfxHost !== undefined) {
-            try {
-              await vfxHost.detachWorld({ world: fixtureWorld });
-            } catch {
-              // Preserve the capture failure while completing VFX host teardown.
-            }
-          }
-          vfxAssets?.dispose();
-          if (fixtureWorld !== undefined) renderer.detachWorld(fixtureWorld);
-          removeFrameEndListener?.();
-          await worldContext?.fiber.dispose();
-        }
-      };
-      const disabled = await captureState(false);
-      const enabled = await captureState(true);
-      return {
-        disabled,
-        enabled,
-        ray: producer.domain === 'skybox' ? { ...FOG_RAY, distance: 20 } : FOG_RAY,
-      };
-    } finally {
-      renderer.dispose();
-      try {
-        await renderer.device.queue.onSubmittedWorkDone();
-      } catch {
-        // Preserve the capture failure while completing renderer teardown.
-      }
-    }
-  };
-}
-
-export { BASE_COLOR };