@forgeax/engine-render 0.1.4 → 0.1.6

package/src/environment/__tests__/resize-dispose.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  beginEnvironmentGeneration,
-  createEnvironmentGenerationState,
-  publishEnvironmentGeneration,
-} from '../generation';
-import { disposeEnvironmentGeneration, resizeEnvironmentGeneration } from '../lifecycle';
-
-describe('analytic environment resize and dispose boundaries', () => {
-  it('never reuses a disposed or resized generation handle', () => {
-    const state = createEnvironmentGenerationState(1);
-    const attempt = beginEnvironmentGeneration(state, { signature: 'one', bytes: 2 });
-    publishEnvironmentGeneration(state, attempt.complete('handle-one'));
-    resizeEnvironmentGeneration(state, 1);
-    expect(state.active).toBeUndefined();
-
-    const next = beginEnvironmentGeneration(state, { signature: 'two', bytes: 3 });
-    publishEnvironmentGeneration(state, next.complete('handle-two'));
-    expect(state.active?.handle).toBe('handle-two');
-    expect(state.active?.generation).not.toBe(1);
-
-    disposeEnvironmentGeneration(state);
-    expect(state.status).toBe('disposed');
-    expect(state.active).toBeUndefined();
-    expect(state.candidate).toBeUndefined();
-    expect(() => beginEnvironmentGeneration(state, { signature: 'three', bytes: 1 })).toThrow(
-      'disposed',
-    );
-  });
-});

package/src/environment/__tests__/signature-red.test.ts

@@ -1,45 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { deriveEnvironmentBundleDescriptors } from '../descriptors.js';
-import {
-  type EnvironmentSignatureInput,
-  environmentBundleBytes,
-  environmentSignature,
-} from '../signature.js';
-
-const input = (): EnvironmentSignatureInput => ({
-  atmosphere: {
-    turbidity: 2,
-    rayleigh: 1,
-    mieCoefficient: 0.005,
-    mieDirectionalG: 0.8,
-    sunAngularRadius: 0.004675,
-  },
-  sun: { direction: [0, 1, 0], color: [1, 0.9, 0.8], illuminance: 100000 },
-  quality: { skySize: 128, irradianceSize: 32, prefilterMips: 5 },
-  algorithmRevision: 'preetham-perez-1999-r1',
-  worldId: 7,
-  entity: 11,
-  deviceGeneration: 3,
-  outputFormat: 'rgba16float',
-});
-
-describe('analytic environment signature and descriptor red gate', () => {
-  it('is sensitive to one output fact at a time and ignores shadow-only facts', () => {
-    const base = environmentSignature(input());
-    expect(
-      environmentSignature({ ...input(), sun: { ...input().sun, illuminance: 100001 } }),
-    ).not.toBe(base);
-    expect(environmentSignature({ ...input(), deviceGeneration: 4 })).not.toBe(base);
-    expect(
-      environmentSignature({ ...input(), algorithmRevision: 'preetham-perez-1999-r2' }),
-    ).not.toBe(base);
-  });
-
-  it('publishes a recomputable mip/face roster and byte equation', () => {
-    const descriptors = deriveEnvironmentBundleDescriptors(input().quality, input().outputFormat);
-    expect(descriptors.faces).toHaveLength(42);
-    expect(descriptors.mips).toHaveLength(5);
-    expect(environmentBundleBytes(descriptors)).toBeGreaterThan(0);
-    expect(environmentBundleBytes(descriptors)).toBe(descriptors.logicalBytes);
-  });
-});

package/src/environment/__tests__/signature.test.ts

@@ -1,60 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  deriveEnvironmentBundleDescriptors,
-  type EnvironmentSignatureInput,
-  environmentBundleBytes,
-  environmentSignature,
-} from '../signature.js';
-
-const baseInput = (): EnvironmentSignatureInput => ({
-  atmosphere: {
-    turbidity: 2,
-    rayleigh: 1,
-    mieCoefficient: 0.005,
-    mieDirectionalG: 0.8,
-    sunAngularRadius: 0.004675,
-  },
-  sun: { direction: [0, 1, 0], color: [1, 0.9, 0.8], illuminance: 100000 },
-  quality: { skySize: 128, irradianceSize: 32, prefilterMips: 5 },
-  algorithmRevision: 'preetham-perez-1999-r1',
-  worldId: 7,
-  entity: 11,
-  deviceGeneration: 3,
-  outputFormat: 'rgba16float',
-});
-
-describe('analytic environment signature', () => {
-  it('canonicalizes normalized direction while preserving float-bit sensitivity', () => {
-    const base = environmentSignature(baseInput());
-    expect(
-      environmentSignature({ ...baseInput(), sun: { ...baseInput().sun, direction: [0, 2, 0] } }),
-    ).toBe(base);
-    expect(
-      environmentSignature({
-        ...baseInput(),
-        atmosphere: { ...baseInput().atmosphere, turbidity: 2.0001 },
-      }),
-    ).not.toBe(base);
-  });
-
-  it('includes output facts', () => {
-    const base = environmentSignature(baseInput());
-    expect(environmentSignature({ ...baseInput(), deviceGeneration: 4 })).not.toBe(base);
-    expect(
-      environmentSignature({ ...baseInput(), algorithmRevision: 'preetham-perez-1999-r2' }),
-    ).not.toBe(base);
-  });
-});
-
-describe('analytic environment descriptors', () => {
-  it('derives all 42 face records and the independently recomputable byte total', () => {
-    const descriptors = deriveEnvironmentBundleDescriptors(
-      baseInput().quality,
-      baseInput().outputFormat,
-    );
-    expect(descriptors.faces).toHaveLength(42);
-    expect(descriptors.mips).toHaveLength(5);
-    expect(descriptors.logicalBytes).toBe(1_883_136);
-    expect(environmentBundleBytes(descriptors)).toBe(descriptors.logicalBytes);
-  });
-});

package/src/environment/descriptors.ts

@@ -1,7 +0,0 @@
-export {
-  deriveEnvironmentBundleDescriptors,
-  type EnvironmentBundleDescriptors,
-  type EnvironmentCubeDescriptor,
-  type EnvironmentCubeFace,
-  environmentBundleBytes,
-} from './signature.js';

package/src/environment/extracted-environment.ts

@@ -1,239 +0,0 @@
-import type { EntityHandle, World } from '@forgeax/engine-ecs';
-import { type Vec3, vec3 } from '@forgeax/engine-math';
-import type { Result } from '@forgeax/engine-types';
-import { err, ok } from '@forgeax/engine-types';
-import { Atmosphere, DirectionalLight, SkyboxBackground, Skylight } from '../components';
-import { validateAtmosphereData } from '../components/atmosphere';
-import {
-  AtmosphereCardinalityInvalidError,
-  AtmosphereSunMissingError,
-  EnvironmentSourceConflictError,
-  type RenderError,
-} from '../errors/render';
-import type {
-  DirectionalLightSnapshot,
-  SkyboxSnapshot,
-  SkylightSnapshot,
-} from '../render-system-extract';
-
-export interface AtmosphereSnapshot {
-  readonly entity: number;
-  readonly worldId: number;
-  readonly turbidity: number;
-  readonly rayleigh: number;
-  readonly mieCoefficient: number;
-  readonly mieDirectionalG: number;
-  readonly sunAngularRadius: number;
-  readonly sun: {
-    readonly entity: number;
-    readonly direction: Vec3;
-    readonly color: Vec3;
-    readonly illuminance: number;
-  };
-}
-
-export type ExtractedEnvironment =
-  | {
-      readonly kind: 'none';
-      readonly worldId: number;
-      readonly skylight?: SkylightSnapshot | undefined;
-      readonly skylightCount: number;
-      readonly skyboxCount: number;
-    }
-  | {
-      readonly kind: 'image';
-      readonly worldId: number;
-      readonly skylight?: SkylightSnapshot | undefined;
-      readonly skybox?: SkyboxSnapshot | undefined;
-      readonly sourceEntity: number;
-      readonly skylightCount: number;
-      readonly skyboxCount: number;
-    }
-  | {
-      readonly kind: 'atmosphere';
-      readonly worldId: number;
-      readonly atmosphere: AtmosphereSnapshot;
-      readonly skylightCount: number;
-      readonly skyboxCount: number;
-    };
-
-export interface EnvironmentSelectionInput {
-  readonly resourceOwner: World;
-  readonly worldId?: number;
-  readonly skylight?: SkylightSnapshot | undefined;
-  readonly skylightCount?: number | undefined;
-  readonly skybox?: SkyboxSnapshot | undefined;
-  readonly skyboxCount?: number | undefined;
-}
-
-interface EnvironmentFacts {
-  readonly skylight: SkylightSnapshot | undefined;
-  readonly skylightCount: number;
-  readonly skybox: SkyboxSnapshot | undefined;
-  readonly skyboxCount: number;
-}
-
-function readEnvironmentFacts(world: World): EnvironmentFacts {
-  let skylight: SkylightSnapshot | undefined;
-  let skylightCount = 0;
-  for (const row of world.query({ read: [Skylight] }).unwrap()) {
-    const value = row.get(Skylight);
-    skylightCount += 1;
-    if (skylight !== undefined) continue;
-    skylight = {
-      equirectHandle: value.equirect === undefined ? 0 : Math.round(value.equirect),
-      color: [value.color[0] ?? 1, value.color[1] ?? 1, value.color[2] ?? 1],
-      intensity: value.intensity,
-      rotation: [
-        value.rotation[0] ?? 0,
-        value.rotation[1] ?? 0,
-        value.rotation[2] ?? 0,
-        value.rotation[3] ?? 1,
-      ],
-      entityHandle: row.entity,
-    };
-  }
-
-  let skybox: SkyboxSnapshot | undefined;
-  let skyboxCount = 0;
-  for (const row of world.query({ read: [SkyboxBackground] }).unwrap()) {
-    const value = row.get(SkyboxBackground);
-    skyboxCount += 1;
-    if (skybox !== undefined || value.equirect === undefined) continue;
-    skybox = {
-      equirectHandle: Math.round(value.equirect),
-      mode: value.mode,
-      rotation: [
-        value.rotation[0] ?? 0,
-        value.rotation[1] ?? 0,
-        value.rotation[2] ?? 0,
-        value.rotation[3] ?? 1,
-      ],
-      entityHandle: row.entity,
-    };
-  }
-  return { skylight, skylightCount, skybox, skyboxCount };
-}
-
-function readAtmosphere(world: World, worldId: number): Result<AtmosphereSnapshot, RenderError> {
-  const rows = [...world.query({ read: [Atmosphere] }).unwrap()];
-  if (rows.length > 1) {
-    return err(
-      new AtmosphereCardinalityInvalidError(
-        rows.length,
-        rows.map((row) => row.entity as number),
-      ),
-    );
-  }
-  const row = rows[0];
-  if (row === undefined) return err(new AtmosphereSunMissingError(-1));
-  const atmosphere = row.get(Atmosphere);
-  const validation = validateAtmosphereData(
-    atmosphere as unknown as Readonly<Record<string, unknown>>,
-  );
-  if (!validation.ok) return err(validation.error);
-  const sunRead = world.get(row.entity, DirectionalLight);
-  if (!sunRead.ok) return err(new AtmosphereSunMissingError(row.entity as number));
-  const light = sunRead.value;
-  const dx = light.direction[0] ?? 0;
-  const dy = light.direction[1] ?? 0;
-  const dz = light.direction[2] ?? 0;
-  const length = Math.hypot(dx, dy, dz);
-  if (!(length > 1e-6) || !Number.isFinite(length)) {
-    return err(new AtmosphereSunMissingError(row.entity as number));
-  }
-  const negate = (value: number): number => (value === 0 ? 0 : -value);
-  const direction = vec3.create(negate(dx / length), negate(dy / length), negate(dz / length));
-  const color = vec3.create(light.color[0] ?? 1, light.color[1] ?? 1, light.color[2] ?? 1);
-  return ok({
-    entity: row.entity as number,
-    worldId,
-    turbidity: atmosphere.turbidity,
-    rayleigh: atmosphere.rayleigh,
-    mieCoefficient: atmosphere.mieCoefficient,
-    mieDirectionalG: atmosphere.mieDirectionalG,
-    sunAngularRadius: atmosphere.sunAngularRadius,
-    sun: {
-      entity: row.entity as number,
-      direction,
-      color,
-      illuminance: light.intensity,
-    },
-  });
-}
-
-export function selectEnvironmentSource(
-  input: EnvironmentSelectionInput,
-): Result<ExtractedEnvironment, RenderError> {
-  const worldId = input.worldId ?? 0;
-  const queried =
-    input.skylightCount === undefined || input.skyboxCount === undefined
-      ? readEnvironmentFacts(input.resourceOwner)
-      : undefined;
-  const facts: EnvironmentFacts = {
-    skylight: input.skylight ?? queried?.skylight,
-    skylightCount: input.skylightCount ?? queried?.skylightCount ?? 0,
-    skybox: input.skybox ?? queried?.skybox,
-    skyboxCount: input.skyboxCount ?? queried?.skyboxCount ?? 0,
-  };
-  const atmosphereRows = [...input.resourceOwner.query({ read: [Atmosphere] }).unwrap()];
-  const atmosphereEntities = atmosphereRows.map((row) => row.entity as number);
-  const imageEntities = [
-    ...(facts.skylight !== undefined && facts.skylight.equirectHandle > 0
-      ? [facts.skylight.entityHandle]
-      : []),
-    ...(facts.skybox !== undefined && facts.skybox.equirectHandle > 0
-      ? [facts.skybox.entityHandle]
-      : []),
-  ];
-  if (atmosphereRows.length > 1) {
-    return err(new AtmosphereCardinalityInvalidError(atmosphereRows.length, atmosphereEntities));
-  }
-  if (atmosphereRows.length === 1 && imageEntities.length > 0) {
-    return err(new EnvironmentSourceConflictError(atmosphereEntities, imageEntities));
-  }
-  if (atmosphereRows.length === 1) {
-    const snapshot = readAtmosphere(input.resourceOwner, worldId);
-    return snapshot.ok
-      ? ok({
-          kind: 'atmosphere',
-          worldId,
-          atmosphere: snapshot.value,
-          skylightCount: facts.skylightCount,
-          skyboxCount: facts.skyboxCount,
-        })
-      : snapshot;
-  }
-  if (imageEntities.length > 0) {
-    return ok({
-      kind: 'image',
-      worldId,
-      ...(facts.skylight === undefined ? {} : { skylight: facts.skylight }),
-      ...(facts.skybox === undefined ? {} : { skybox: facts.skybox }),
-      sourceEntity: imageEntities[0] as number,
-      skylightCount: facts.skylightCount,
-      skyboxCount: facts.skyboxCount,
-    });
-  }
-  return ok({
-    kind: 'none',
-    worldId,
-    ...(facts.skylight === undefined ? {} : { skylight: facts.skylight }),
-    skylightCount: facts.skylightCount,
-    skyboxCount: facts.skyboxCount,
-  });
-}
-
-export function atmosphereSunSnapshot(
-  environment: ExtractedEnvironment,
-): DirectionalLightSnapshot | undefined {
-  if (environment.kind !== 'atmosphere') return undefined;
-  return {
-    kind: 'directional',
-    direction: environment.atmosphere.sun.direction,
-    color: environment.atmosphere.sun.color,
-    intensity: environment.atmosphere.sun.illuminance,
-  };
-}
-
-export type EnvironmentEntity = EntityHandle;

package/src/environment/generation.ts

@@ -1,158 +0,0 @@
-import type { EnvironmentSunConsumerSnapshot } from '../record/frame-lighting';
-import type { EnvironmentGpuBundle } from './gpu-bundle';
-import type { EnvironmentSignature } from './signature';
-
-export type EnvironmentGenerationStatus = 'idle' | 'building' | 'ready' | 'failed' | 'disposed';
-
-export interface EnvironmentGenerationInput {
-  readonly signature: EnvironmentSignature | string;
-  readonly bytes: number;
-}
-
-export interface EnvironmentBundleRecord {
-  readonly generation: number;
-  readonly deviceGeneration: string | number;
-  readonly signature: EnvironmentSignature | string;
-  readonly bytes: number;
-  /** Physical bundle in production; string-shaped handles remain for pure state tests. */
-  readonly handle: EnvironmentGpuBundle | string | { readonly handle: string };
-  /** Immutable direct/CSM/atmosphere facts committed with this GPU bundle. */
-  readonly consumerSnapshot?: EnvironmentSunConsumerSnapshot | undefined;
-}
-
-export interface EnvironmentRetiredRecord {
-  readonly record: EnvironmentBundleRecord;
-  readonly queueCompletion: string | number | undefined;
-  retired: boolean;
-  destroyed: boolean;
-}
-
-export interface EnvironmentGenerationState {
-  deviceGeneration: string | number;
-  readonly retired: EnvironmentRetiredRecord[];
-  status: EnvironmentGenerationStatus;
-  generation: number;
-  desired: Readonly<EnvironmentGenerationInput> | undefined;
-  candidate: EnvironmentGenerationRecord | undefined;
-  active: EnvironmentBundleRecord | undefined;
-  lastKnownGood: EnvironmentBundleRecord | undefined;
-  failureStage: 'readiness' | 'build' | 'execute' | 'finish' | 'submit' | 'device-lost' | undefined;
-  /** Renderer-owned lifecycle facts used by the bounded inspection projection. */
-  bytes: number;
-  peakBytes: number;
-  rebuildCost: number;
-  publishCount: number;
-}
-
-export interface EnvironmentGenerationRecord extends EnvironmentBundleRecord {}
-
-export interface EnvironmentGenerationAttempt {
-  readonly generation: number;
-  readonly desired: Readonly<EnvironmentGenerationInput>;
-  complete(
-    handle: EnvironmentGpuBundle | string | { readonly handle: string },
-    consumerSnapshot?: EnvironmentSunConsumerSnapshot,
-  ): EnvironmentGenerationRecord;
-  fail(stage: 'readiness' | 'build' | 'execute' | 'finish' | 'submit'): void;
-}
-
-export function createEnvironmentGenerationState(
-  deviceGeneration: string | number,
-): EnvironmentGenerationState {
-  return {
-    deviceGeneration,
-    retired: [],
-    status: 'idle',
-    generation: 0,
-    desired: undefined,
-    candidate: undefined,
-    active: undefined,
-    lastKnownGood: undefined,
-    failureStage: undefined,
-    bytes: 0,
-    peakBytes: 0,
-    rebuildCost: 0,
-    publishCount: 0,
-  };
-}
-
-export function beginEnvironmentGeneration(
-  state: EnvironmentGenerationState,
-  input: EnvironmentGenerationInput,
-): EnvironmentGenerationAttempt {
-  if (state.status === 'disposed') throw new Error('environment generation is disposed');
-  const desired = Object.freeze({ signature: input.signature, bytes: input.bytes });
-  state.desired = desired;
-  state.generation += 1;
-  state.status = 'building';
-  state.failureStage = undefined;
-  const generation = state.generation;
-  const record = (
-    handle: EnvironmentGpuBundle | string | { readonly handle: string },
-    consumerSnapshot?: EnvironmentSunConsumerSnapshot,
-  ): EnvironmentGenerationRecord => ({
-    generation,
-    deviceGeneration: state.deviceGeneration,
-    signature: desired.signature,
-    bytes: desired.bytes,
-    handle,
-    ...(consumerSnapshot === undefined ? {} : { consumerSnapshot }),
-  });
-  return {
-    generation,
-    desired,
-    complete: (handle, consumerSnapshot) => {
-      if (state.status === 'disposed') throw new Error('environment generation is disposed');
-      const candidate = record(handle, consumerSnapshot);
-      state.candidate = candidate;
-      state.bytes = (state.active?.bytes ?? 0) + candidate.bytes;
-      state.peakBytes = Math.max(state.peakBytes, state.bytes);
-      return candidate;
-    },
-    fail: (stage) => {
-      if (state.status === 'disposed') return;
-      if (state.candidate?.generation === generation) state.candidate = undefined;
-      state.failureStage = stage;
-      state.bytes = state.active?.bytes ?? 0;
-      state.status = state.active === undefined ? 'failed' : 'ready';
-    },
-  };
-}
-
-/**
- * One consumer projection for every environment user in the current frame.
- * Candidate wins only while the candidate frame is being encoded; aborting
- * removes it and therefore restores the active/LKG snapshot everywhere.
- */
-export function environmentConsumerSnapshot(
-  state: Pick<EnvironmentGenerationState, 'candidate' | 'active'>,
-): EnvironmentSunConsumerSnapshot | undefined {
-  return (state.candidate ?? state.active)?.consumerSnapshot;
-}
-
-export function publishEnvironmentGeneration(
-  state: EnvironmentGenerationState,
-  candidate: EnvironmentGenerationRecord,
-  queueCompletion?: string | number,
-): void {
-  if (state.status === 'disposed') throw new Error('environment generation is disposed');
-  if (candidate.deviceGeneration !== state.deviceGeneration) {
-    throw new Error('environment generation belongs to another device');
-  }
-  if (state.candidate?.generation !== candidate.generation) {
-    throw new Error('environment generation candidate is not current');
-  }
-  const previous = state.active;
-  state.active = candidate;
-  state.lastKnownGood = candidate;
-  state.candidate = undefined;
-  state.status = 'ready';
-  state.failureStage = undefined;
-  state.bytes = candidate.bytes;
-  state.peakBytes = Math.max(state.peakBytes, candidate.bytes);
-  state.rebuildCost = candidate.bytes;
-  state.publishCount += 1;
-  if (previous !== undefined && previous.generation !== candidate.generation) {
-    state.retired.push({ record: previous, queueCompletion, retired: false, destroyed: false });
-  }
-}

package/src/environment/gpu-bundle.ts

@@ -1,144 +0,0 @@
-import { type RhiDevice, RhiError, type Texture, type TextureView } from '@forgeax/engine-rhi';
-import { err, ok, type Result } from '@forgeax/engine-types';
-import {
-  GPU_TEXTURE_USAGE_COPY_SRC,
-  GPU_TEXTURE_USAGE_RENDER_ATTACHMENT,
-  GPU_TEXTURE_USAGE_TEXTURE_BINDING,
-} from '../gpu-texture-usage';
-import type { EnvironmentBundleDescriptors } from './signature';
-
-/** The renderer-owned physical result of one analytic environment generation. */
-export interface EnvironmentGpuBundle {
-  readonly kind: 'analytic-sky-bundle';
-  readonly descriptors: EnvironmentBundleDescriptors;
-  readonly sky: Texture;
-  readonly irradiance: Texture;
-  readonly prefilter: Texture;
-  readonly skyView: TextureView;
-  readonly irradianceView: TextureView;
-  readonly prefilterView: TextureView;
-  readonly destroy: (device: RhiDevice) => Result<void, RhiError>;
-}
-
-function destroyTextures(device: RhiDevice, textures: readonly Texture[]): Result<void, RhiError> {
-  for (const texture of textures) {
-    const destroyed = device.destroyTexture(texture);
-    if (!destroyed.ok) return destroyed;
-  }
-  return ok(undefined);
-}
-
-/**
- * Allocate the three HDR cube resources before graph execution. The graph
- * imports these exact handles, so a candidate cannot be published as a POD
- * token while its device resources are missing.
- */
-export function createEnvironmentGpuBundle(
-  device: RhiDevice,
-  descriptors: EnvironmentBundleDescriptors,
-): Result<EnvironmentGpuBundle, RhiError> {
-  if (!device.caps.rgba16floatRenderable) {
-    return err(
-      new RhiError({
-        code: 'rhi-not-available',
-        expected: 'device.caps.rgba16floatRenderable is true',
-        hint: 'analytic sky requires an HDR rgba16float renderable texture',
-      }),
-    );
-  }
-  const usage =
-    GPU_TEXTURE_USAGE_RENDER_ATTACHMENT |
-    GPU_TEXTURE_USAGE_TEXTURE_BINDING |
-    GPU_TEXTURE_USAGE_COPY_SRC;
-  const create = (
-    label: string,
-    descriptor: {
-      readonly width: number;
-      readonly height: number;
-      readonly mipLevelCount?: number;
-    },
-  ): Result<Texture, RhiError> =>
-    device.createTexture({
-      label,
-      size: { width: descriptor.width, height: descriptor.height, depthOrArrayLayers: 6 },
-      mipLevelCount: descriptor.mipLevelCount ?? 1,
-      sampleCount: 1,
-      dimension: '2d',
-      format: 'rgba16float',
-      usage,
-      viewFormats: [],
-      textureBindingViewDimension: 'cube',
-    });
-
-  const sky = create('analytic-sky.sky', descriptors.sky);
-  if (!sky.ok) return sky;
-  const irradiance = create('analytic-sky.irradiance', descriptors.irradiance);
-  if (!irradiance.ok) {
-    destroyTextures(device, [sky.value]);
-    return irradiance;
-  }
-  const prefilter = create('analytic-sky.prefilter', {
-    width: descriptors.prefilter.width,
-    height: descriptors.prefilter.height,
-    mipLevelCount: descriptors.mips.length,
-  });
-  if (!prefilter.ok) {
-    destroyTextures(device, [irradiance.value, sky.value]);
-    return prefilter;
-  }
-
-  const createCubeView = (texture: Texture, label: string, mipCount: number) =>
-    device.createTextureView(texture, {
-      label,
-      dimension: 'cube',
-      baseMipLevel: 0,
-      mipLevelCount: mipCount,
-      baseArrayLayer: 0,
-      arrayLayerCount: 6,
-    });
-  const skyView = createCubeView(sky.value, 'analytic-sky.sky-view', 1);
-  if (!skyView.ok) {
-    destroyTextures(device, [prefilter.value, irradiance.value, sky.value]);
-    return skyView;
-  }
-  const irradianceView = createCubeView(irradiance.value, 'analytic-sky.irradiance-view', 1);
-  if (!irradianceView.ok) {
-    destroyTextures(device, [prefilter.value, irradiance.value, sky.value]);
-    return irradianceView;
-  }
-  const prefilterView = createCubeView(
-    prefilter.value,
-    'analytic-sky.prefilter-view',
-    descriptors.mips.length,
-  );
-  if (!prefilterView.ok) {
-    destroyTextures(device, [prefilter.value, irradiance.value, sky.value]);
-    return prefilterView;
-  }
-
-  let destroyed = false;
-  const bundle: EnvironmentGpuBundle = {
-    kind: 'analytic-sky-bundle',
-    descriptors,
-    sky: sky.value,
-    irradiance: irradiance.value,
-    prefilter: prefilter.value,
-    skyView: skyView.value,
-    irradianceView: irradianceView.value,
-    prefilterView: prefilterView.value,
-    destroy: (owner) => {
-      if (destroyed) return ok(undefined);
-      destroyed = true;
-      return destroyTextures(owner, [prefilter.value, irradiance.value, sky.value]);
-    },
-  };
-  return ok(bundle);
-}
-
-export function isEnvironmentGpuBundle(value: unknown): value is EnvironmentGpuBundle {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    (value as { readonly kind?: unknown }).kind === 'analytic-sky-bundle'
-  );
-}