@downdraft/engine 0.0.0 → 0.1.1

package/core/src/render/ibl-bind-group.ts

@@ -0,0 +1,266 @@
+import type { EnvironmentMap } from "../assets/environment-manager";
+
+export interface IBLBindGroupOptions {
+  includeBRDFLUT?: boolean;
+}
+
+export class IBLBindGroup {
+  private device: GPUDevice;
+  private includeBRDFLUT: boolean;
+  private bindGroup: GPUBindGroup | null = null;
+  private bindGroupLayout: GPUBindGroupLayout | null = null;
+  private uniformBuffer: GPUBuffer | null = null;
+  private irradianceSampler: GPUSampler;
+  private prefilterSampler: GPUSampler;
+  private brdfSampler: GPUSampler;
+  private defaultLUTTexture: GPUTexture | null = null;
+  private defaultIrradianceTex: GPUTexture | null = null;
+  private defaultPrefilterTex: GPUTexture | null = null;
+
+  constructor(device: GPUDevice, options: IBLBindGroupOptions = {}) {
+    this.device = device;
+    this.includeBRDFLUT = options.includeBRDFLUT ?? true;
+    this.irradianceSampler = device.createSampler({
+      magFilter: "linear",
+      minFilter: "linear",
+      mipmapFilter: "linear",
+      addressModeU: "clamp-to-edge",
+      addressModeV: "clamp-to-edge",
+    });
+    this.prefilterSampler = device.createSampler({
+      magFilter: "linear",
+      minFilter: "linear",
+      mipmapFilter: "linear",
+      addressModeU: "clamp-to-edge",
+      addressModeV: "clamp-to-edge",
+    });
+    this.brdfSampler = device.createSampler({
+      magFilter: "linear",
+      minFilter: "linear",
+      addressModeU: "clamp-to-edge",
+      addressModeV: "clamp-to-edge",
+    });
+
+    // Eagerly create the bind group layout so pipelines can reference @group(2)
+    // before any environment map has been captured.
+    const entries: GPUBindGroupLayoutEntry[] = this.includeBRDFLUT
+      ? [
+          { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "cube" } },
+          { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "cube" } },
+          { binding: 2, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float" } },
+          { binding: 3, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } },
+          { binding: 4, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } },
+          { binding: 5, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } },
+          { binding: 6, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
+        ]
+      : [
+          { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "cube" } },
+          { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "cube" } },
+          { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } },
+          { binding: 3, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } },
+          { binding: 4, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
+        ];
+    this.bindGroupLayout = device.createBindGroupLayout({ entries });
+
+    // Create a default bind group with placeholder textures so pipelines
+    // can render before any environment map has been captured.
+    this.createDefaultBindGroup();
+  }
+
+  getBindGroupLayout(): GPUBindGroupLayout | null {
+    return this.bindGroupLayout;
+  }
+
+  createBindGroup(envMap: EnvironmentMap): GPUBindGroup {
+    if (!this.uniformBuffer) {
+      this.uniformBuffer = this.device.createBuffer({
+        size: 16,
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+      });
+    }
+
+    const mipData = new Float32Array(4);
+    mipData[0] = envMap.prefilteredMaxMip;
+    this.device.queue.writeBuffer(this.uniformBuffer, 0, mipData);
+
+    const prefilteredView = envMap.prefilteredSpecular[0]?.createView({
+      dimension: "cube",
+    }) ?? envMap.cubemap.createView({ dimension: "cube" });
+
+    const entries: GPUBindGroupEntry[] = [
+      { binding: 0, resource: envMap.irradiance.createView({ dimension: "cube" }) },
+      { binding: 1, resource: prefilteredView },
+    ];
+
+    if (this.includeBRDFLUT) {
+      const brdfLUTView = envMap.brdfLUT?.createView() ?? this.createDefaultLUTView();
+      entries.push({ binding: 2, resource: brdfLUTView });
+      entries.push({ binding: 3, resource: this.irradianceSampler });
+      entries.push({ binding: 4, resource: this.prefilterSampler });
+      entries.push({ binding: 5, resource: this.brdfSampler });
+      entries.push({ binding: 6, resource: { buffer: this.uniformBuffer } });
+    } else {
+      entries.push({ binding: 2, resource: this.irradianceSampler });
+      entries.push({ binding: 3, resource: this.prefilterSampler });
+      entries.push({ binding: 4, resource: { buffer: this.uniformBuffer } });
+    }
+
+    this.bindGroup = this.device.createBindGroup({
+      layout: this.bindGroupLayout!,
+      entries,
+    });
+
+    return this.bindGroup;
+  }
+
+  getBindGroup(): GPUBindGroup | null {
+    return this.bindGroup;
+  }
+
+  private createDefaultLUTView(): GPUTextureView {
+    if (!this.defaultLUTTexture) {
+      this.defaultLUTTexture = this.device.createTexture({
+        size: [1, 1],
+        format: "rgba16float",
+        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+      });
+      const data = new Uint16Array([0x3C00, 0x3C00, 0, 0x3C00]);
+      this.device.queue.writeTexture(
+        { texture: this.defaultLUTTexture },
+        data,
+        { bytesPerRow: 8 },
+        { width: 1, height: 1 },
+      );
+    }
+    return this.defaultLUTTexture.createView();
+  }
+
+  private createDefaultCubemapView(tex: GPUTexture | null, label: string): GPUTextureView {
+    if (!tex) {
+      tex = this.device.createTexture({
+        size: [1, 1, 6],
+        format: "rgba16float",
+        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+        label,
+      });
+      const faceData = new Uint16Array(6 * 4);
+      for (let i = 0; i < 6; i++) {
+        faceData[i * 4 + 0] = 0x3C00;
+        faceData[i * 4 + 1] = 0x3C00;
+        faceData[i * 4 + 2] = 0x3C00;
+        faceData[i * 4 + 3] = 0x3C00;
+      }
+      this.device.queue.writeTexture(
+        { texture: tex },
+        faceData,
+        { bytesPerRow: 8, rowsPerImage: 1 },
+        { width: 1, height: 1, depthOrArrayLayers: 6 },
+      );
+      if (label === "default_irradiance") this.defaultIrradianceTex = tex;
+      else this.defaultPrefilterTex = tex;
+    }
+    return tex.createView({ dimension: "cube" });
+  }
+
+  private createDefaultBindGroup(): void {
+    if (!this.uniformBuffer) {
+      this.uniformBuffer = this.device.createBuffer({
+        size: 16,
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+      });
+    }
+    const mipData = new Float32Array(4);
+    this.device.queue.writeBuffer(this.uniformBuffer, 0, mipData);
+
+    const irradianceView = this.createDefaultCubemapView(this.defaultIrradianceTex, "default_irradiance");
+    const prefilterView = this.createDefaultCubemapView(this.defaultPrefilterTex, "default_prefilter");
+
+    const entries: GPUBindGroupEntry[] = [
+      { binding: 0, resource: irradianceView },
+      { binding: 1, resource: prefilterView },
+    ];
+
+    if (this.includeBRDFLUT) {
+      entries.push({ binding: 2, resource: this.createDefaultLUTView() });
+      entries.push({ binding: 3, resource: this.irradianceSampler });
+      entries.push({ binding: 4, resource: this.prefilterSampler });
+      entries.push({ binding: 5, resource: this.brdfSampler });
+      entries.push({ binding: 6, resource: { buffer: this.uniformBuffer } });
+    } else {
+      entries.push({ binding: 2, resource: this.irradianceSampler });
+      entries.push({ binding: 3, resource: this.prefilterSampler });
+      entries.push({ binding: 4, resource: { buffer: this.uniformBuffer } });
+    }
+
+    this.bindGroup = this.device.createBindGroup({
+      layout: this.bindGroupLayout!,
+      entries,
+    });
+  }
+
+  destroy(): void {
+    this.uniformBuffer?.destroy();
+    this.defaultLUTTexture?.destroy();
+    this.defaultIrradianceTex?.destroy();
+    this.defaultPrefilterTex?.destroy();
+  }
+}
+
+export function createIBLShaderChunk(groupIndex: number, includeBRDFLUT: boolean): string {
+  const g = groupIndex;
+  if (includeBRDFLUT) {
+    return /* wgsl */ `
+struct IBLUniforms {
+  maxMipLevel: f32,
+  _pad0: f32,
+  _pad1: f32,
+  _pad2: f32,
+};
+
+@group(${g}) @binding(0) var irradianceMap: texture_cube<f32>;
+@group(${g}) @binding(1) var prefilterMap: texture_cube<f32>;
+@group(${g}) @binding(2) var brdfLUT: texture_2d<f32>;
+@group(${g}) @binding(3) var irradianceSampler: sampler;
+@group(${g}) @binding(4) var prefilterSampler: sampler;
+@group(${g}) @binding(5) var brdfSampler: sampler;
+@group(${g}) @binding(6) var<uniform> iblUniforms: IBLUniforms;
+
+fn getIBLDiffuse(N: vec3<f32>) -> vec3<f32> {
+  return textureSample(irradianceMap, irradianceSampler, N).rgb;
+}
+
+fn getIBLSpecular(N: vec3<f32>, R: vec3<f32>, roughness: f32) -> vec3<f32> {
+  let lod = roughness * iblUniforms.maxMipLevel;
+  let prefilteredColor = textureSampleLevel(prefilterMap, prefilterSampler, R, lod);
+  let brdf = textureSample(brdfLUT, brdfSampler, vec2<f32>(max(dot(N, vec3<f32>(0.0, 0.0, 1.0)), 0.0), roughness)).rg;
+  return prefilteredColor.rgb * (brdf.x + brdf.y);
+}
+`;
+  }
+  return /* wgsl */ `
+struct IBLUniforms {
+  maxMipLevel: f32,
+  _pad0: f32,
+  _pad1: f32,
+  _pad2: f32,
+};
+
+@group(${g}) @binding(0) var irradianceMap: texture_cube<f32>;
+@group(${g}) @binding(1) var prefilterMap: texture_cube<f32>;
+@group(${g}) @binding(2) var irradianceSampler: sampler;
+@group(${g}) @binding(3) var prefilterSampler: sampler;
+@group(${g}) @binding(4) var<uniform> iblUniforms: IBLUniforms;
+
+fn getIBLDiffuse(N: vec3<f32>) -> vec3<f32> {
+  return textureSample(irradianceMap, irradianceSampler, N).rgb;
+}
+
+fn getIBLSpecular(N: vec3<f32>, R: vec3<f32>, roughness: f32) -> vec3<f32> {
+  let lod = roughness * iblUniforms.maxMipLevel;
+  let prefilteredColor = textureSampleLevel(prefilterMap, prefilterSampler, R, lod);
+  return prefilteredColor.rgb;
+}
+`;
+}
+
+export const IBL_SHADER_CHUNK = createIBLShaderChunk(2, true);

package/core/src/render/ibl.ts

@@ -0,0 +1,180 @@
+import type { EnvironmentMap } from "../assets/environment-manager";
+import { EnvironmentManager } from "../assets/environment-manager";
+import { IrradianceGenerator } from "../assets/irradiance-generator";
+import { PrefilteredSpecularGenerator } from "../assets/prefilter-generator";
+import { IBLBindGroup } from "./ibl-bind-group";
+import { CubemapCapturePass } from "./passes/cubemap-capture";
+import type { SkyDomeUniforms } from "./passes/sky-dome";
+
+export interface IBLSystemOptions {
+  faceSize?: number;
+  prefilterLevels?: number;
+  prefilterSamples?: number;
+  recaptureInterval?: number;
+  includeBRDFLUT?: boolean;
+}
+
+export class IBLSystem {
+  private device: GPUDevice;
+  private faceSize: number;
+  private prefilterLevels: number;
+  private prefilterSamples: number;
+  private recaptureInterval: number;
+  private includeBRDFLUT: boolean;
+
+  private cubemapCapture: CubemapCapturePass;
+  private irradianceGen: IrradianceGenerator;
+  private prefilterGen: PrefilteredSpecularGenerator;
+  private envManager: EnvironmentManager;
+  private iblBindGroup: IBLBindGroup;
+
+  private currentEnv: EnvironmentMap | null = null;
+  private brdfLUTTexture: GPUTexture | null = null;
+  private frameCounter: number = 0;
+  private lastTimeOfDay: number = -1;
+  private initialized: boolean = false;
+  private pendingDestroy: GPUTexture[] = [];
+
+  constructor(device: GPUDevice, options: IBLSystemOptions = {}) {
+    this.device = device;
+    this.faceSize = options.faceSize ?? 256;
+    this.prefilterLevels = options.prefilterLevels ?? 5;
+    this.prefilterSamples = options.prefilterSamples ?? 512;
+    this.recaptureInterval = options.recaptureInterval ?? 60;
+    this.includeBRDFLUT = options.includeBRDFLUT ?? true;
+
+    this.cubemapCapture = new CubemapCapturePass(device, { faceSize: this.faceSize });
+    this.irradianceGen = new IrradianceGenerator(device);
+    this.prefilterGen = new PrefilteredSpecularGenerator(device);
+    this.envManager = new EnvironmentManager({
+      device, faceSize: this.faceSize,
+      prefilterLevels: this.prefilterLevels, prefilterSamples: this.prefilterSamples,
+    });
+    this.iblBindGroup = new IBLBindGroup(device, { includeBRDFLUT: this.includeBRDFLUT });
+  }
+
+  init(): void {
+    if (this.initialized) return;
+    this.initialized = true;
+  }
+
+  setBRDFLUT(lut: GPUTexture): void {
+    this.brdfLUTTexture = lut;
+  }
+
+  captureFromSkyDome(uniforms: Omit<SkyDomeUniforms, "viewProj" | "cameraPos">): void {
+    const cubemap = this.cubemapCapture.capture(uniforms);
+
+    const irradiance = this.irradianceGen.generate(cubemap, { faceSize: 32 });
+    const prefilteredSpecular = this.prefilterGen.generateMipmapChain(
+      cubemap,
+      this.faceSize,
+      this.prefilterLevels,
+      this.prefilterSamples,
+    );
+
+    if (this.currentEnv) {
+      // Defer destruction — the old env textures may still be referenced by
+      // in-flight command buffers from the current frame's render passes.
+      // They will be destroyed after the frame completes via endFrame().
+      this.pendingDestroy.push(this.currentEnv.irradiance);
+      this.currentEnv.prefilteredSpecular.forEach((tex) => {
+        this.pendingDestroy.push(tex);
+      });
+      // The cubemap is also deferred (not destroyed immediately) because it
+      // may still be referenced by a previously submitted command buffer, and
+      // CubemapCapturePass now creates a fresh texture each capture so the
+      // old one is safe to release after the frame completes.
+      if (this.currentEnv.cubemap) {
+        this.pendingDestroy.push(this.currentEnv.cubemap);
+      }
+    }
+
+    this.currentEnv = {
+      cubemap,
+      irradiance,
+      prefilteredSpecular,
+      prefilteredMaxMip: this.prefilterLevels - 1,
+      brdfLUT: this.brdfLUTTexture,
+      faceSize: this.faceSize,
+    };
+
+    if (this.currentEnv) {
+      this.iblBindGroup.createBindGroup(this.currentEnv);
+    }
+  }
+
+  async loadFromEquirectangular(uri: string): Promise<void> {
+    const envMap = await this.envManager.loadFromEquirectangular(uri);
+    if (this.brdfLUTTexture) {
+      envMap.brdfLUT = this.brdfLUTTexture;
+    }
+    this.currentEnv = envMap;
+    this.iblBindGroup.createBindGroup(envMap);
+  }
+
+  async loadFromCubemapFiles(
+    faceUris: [string, string, string, string, string, string],
+  ): Promise<void> {
+    const envMap = await this.envManager.loadFromCubemapFiles(faceUris);
+    if (this.brdfLUTTexture) {
+      envMap.brdfLUT = this.brdfLUTTexture;
+    }
+    this.currentEnv = envMap;
+    this.iblBindGroup.createBindGroup(envMap);
+  }
+
+  shouldRecapture(timeOfDay: number): boolean {
+    this.frameCounter++;
+    if (this.frameCounter < this.recaptureInterval) return false;
+    const timeDelta = Math.abs(timeOfDay - this.lastTimeOfDay);
+    if (this.lastTimeOfDay >= 0 && timeDelta < 0.02 && this.currentEnv) return false;
+    return true;
+  }
+
+  updateFromSkyDome(
+    uniforms: Omit<SkyDomeUniforms, "viewProj" | "cameraPos">,
+    timeOfDay: number,
+  ): void {
+    if (!this.shouldRecapture(timeOfDay)) return;
+    this.captureFromSkyDome(uniforms);
+    this.lastTimeOfDay = timeOfDay;
+    this.frameCounter = 0;
+  }
+
+  getBindGroup(): GPUBindGroup | null {
+    return this.iblBindGroup?.getBindGroup() ?? null;
+  }
+
+  getBindGroupLayout(): GPUBindGroupLayout | null {
+    return this.iblBindGroup?.getBindGroupLayout() ?? null;
+  }
+
+  getCurrentEnvironment(): EnvironmentMap | null {
+    return this.currentEnv;
+  }
+
+  isReady(): boolean {
+    return this.currentEnv !== null && (this.iblBindGroup?.getBindGroup() ?? null) !== null;
+  }
+
+  /** Destroy textures deferred from a mid-frame recapture. Call after the frame's command buffers have been submitted. */
+  endFrame(): void {
+    this.pendingDestroy.forEach((tex) => {
+      try { tex.destroy(); } catch {}
+    });
+    this.pendingDestroy = [];
+  }
+
+  destroy(): void {
+    this.cubemapCapture?.destroy();
+    this.iblBindGroup?.destroy();
+    this.envManager?.destroy();
+    this.pendingDestroy.forEach((tex) => {
+      try { tex.destroy(); } catch {}
+    });
+    this.pendingDestroy = [];
+    this.currentEnv = null;
+    this.initialized = false;
+  }
+}

package/core/src/render/index.ts

@@ -0,0 +1,163 @@
+/// <reference path="../webgpu-destroy-augmentation.d.ts" />
+// Render sub-barrel — re-exports all render-related items.
+export { BindGroupCache } from "./bind-group";
+export {
+    BINDLESS_MATERIAL_CHUNK,
+    BindlessFrameBindings,
+    BindlessMaterialManager,
+    BindlessTextureRegistry, computeBucketKey, DEFAULT_FORMAT_SLOTS,
+    MATERIAL_STRUCT_SIZE, materialIndexAttribute,
+    packHandle16
+} from "./bindless";
+export type {
+    BindlessFormatSlot,
+    BindlessFrameBindingsOptions,
+    MaterialManagerOptions,
+    MaterialParams,
+    RegisteredTexture,
+    TextureBucketKey,
+    TextureRegistryOptions
+} from "./bindless";
+export { ArenaBuffer, RingBuffer } from "./buffer";
+export { calculateViewProj, calculateViewProjInto, CameraMode, CameraSystem, dot3, normalize3, transformVec4 } from "./camera";
+export type { CameraConfig, CameraState } from "./camera";
+export { cameraMatrix, makeCamera2D, PanZoomCamera2D, screenToWorld, updateCamera, worldToScreen, type Camera2D, type Camera2DOptions, type PanZoomCamera2DOptions } from "./camera-2d";
+export { CameraController } from "./camera-controller";
+export type { CameraControllerOptions, OrbitInputOptions } from "./camera-controller";
+export { CanvasResizeWatcher } from "./canvas-resize-watcher";
+export type { CanvasResizeHandler } from "./canvas-resize-watcher";
+export { DEPTH_FORMAT, MSAA_SAMPLE_COUNT } from "./constants";
+export { GPUDeviceManager } from "./device";
+export { FrameGraph, PassType, SlotRegistry, TextureHandle } from "./frame-graph";
+export type { ColorAttachmentDesc, DepthAttachmentDesc, FrameContext, GraphRenderContext, RenderContext, TextureDesc } from "./frame-graph";
+export { computeAABB, cullItems, Frustum, transformAABB } from "./frustum";
+export type { AABB, CullableItem, FrustumPlane } from "./frustum";
+export { FULLSCREEN_VS } from "./fullscreen-vs";
+export { G_BUFFER_FORMATS, GBuffer } from "./g-buffer";
+export type { GBufferTextures, GBufferViews } from "./g-buffer";
+export { GameRenderer } from "./game-renderer";
+export type { CameraViewportInfo, CancelRAF, FrameCallbacks, GameRendererConfig, GameRendererLike, OffscreenMode, RAFSource, RenderTargetProvider } from "./game-renderer";
+export { computeHzbSize, GpuCullPass, GpuMeshTable, HzbBuilder, HzbBuildPass, IndirectDrawPass, INSTANCE_RECORD_BYTES, INSTANCE_RECORD_FLOATS, InstanceBuffer, nextPowerOf2 } from "./gpu-driven";
+export type { CullBatchRecord, HzbSize, InstanceRecord, MeshBatch, MeshTableGroup } from "./gpu-driven";
+export {
+    createBlackTextureView, createDefaultTextureView, createDepthTexture, createStorageBuffer, createUniformBuffer
+} from "./gpu-utils";
+export { HDRSupport } from "./hdr";
+export type { HDRConfig as RenderHDRConfig } from "./hdr";
+export { MaterialHotReloader } from "./hot-reload";
+export type { HotReloadCallback, WatchedMesh, WatchedShader, WatchedTexture } from "./hot-reload";
+export { IBLSystem } from "./ibl";
+export type { IBLSystemOptions } from "./ibl";
+export { createIBLShaderChunk, IBL_SHADER_CHUNK, IBLBindGroup } from "./ibl-bind-group";
+export type { IBLBindGroupOptions } from "./ibl-bind-group";
+export { InputManager } from "./input-manager";
+export type { RenderInputState } from "./input-manager";
+export { createDefaultLightUniform, createDirectionalLight, createHemisphereLight, createPointLight, createRectAreaLight, createSpotLight, DEFAULT_SHADOW_SETTINGS, extractPointAndSpotLights, LightType, lightTypeToStorageType, MAX_POINT_LIGHTS, MAX_SPOT_LIGHTS, packAllLightsToStorage, packLightToStorage, packLightUniform, packPointLights, packSpotLightsExtended } from "./lighting";
+export type { DirectionalLight, HemisphereLight, Light, LightUniformData, PointLight, RectAreaLight, ShadowSettings, SpotLight } from "./lighting";
+export { createLTCTextures, generateLTCLUTData, LTC_LUT_SIZE, LTC_SHADER_CHUNK } from "./lighting/area-light";
+export type { AreaLightData, AreaLightShape, LTCTextureSet } from "./lighting/area-light";
+export { ClusterGrid } from "./lighting/cluster-grid";
+export { clusterIndex3D, computeClusterCount, computeClusterGridBufferSize, computeLightDataBufferSize, computeLightIndexListSize, DEFAULT_CLUSTER_CONFIG, depthSliceToNear, packClusterUniforms, packLightsArray, packLightToStorageBuffer, screenPosToClusterXY, worldDepthToSlice } from "./lighting/cluster-types";
+export type { ClusterGridConfig, ClusterUniforms, GPULightData, LightShapeType } from "./lighting/cluster-types";
+export { createIESGpuTexture, iesProfileToTextureData, parseIES } from "./lighting/ies-parser";
+export type { IESLoadOptions, IESProfile } from "./lighting/ies-parser";
+export { ClusterLightingPass } from "./passes/cluster-lighting-pass";
+export { CSMPass, DEFAULT_CSM_SETTINGS } from "./passes/csm";
+export type { CSMSettings } from "./passes/csm";
+export { CubemapCapturePass } from "./passes/cubemap-capture";
+export type { CubemapCaptureOptions } from "./passes/cubemap-capture";
+export { DebugRenderPass } from "./passes/debug";
+export { DeferredLightingPass } from "./passes/deferred-lighting";
+export { DepthPrepass } from "./passes/depth-prepass";
+export { Dome360Pass } from "./passes/dome-360";
+export type { Dome360Config } from "./passes/dome-360";
+export { DEFAULT_FLUID_CONFIG, FluidRenderPass } from "./passes/fluid-render";
+export type { FluidConfig } from "./passes/fluid-render";
+export { DEFAULT_RSM_CONFIG, packVPLsToBuffer, sampleRSMToVPLs, VPL_FLOATS, VPL_SIZE } from "./passes/gi-types";
+export type { RSMConfig, VPLData } from "./passes/gi-types";
+export { OpaquePass } from "./passes/opaque";
+export type { OpaquePassMode, PBRMaterialResources } from "./passes/opaque";
+export { MAX_POINT_LIGHT_SHADOWS, PointLightShadowPass } from "./passes/point-light-shadow";
+export type { PointLightShadowData } from "./passes/point-light-shadow";
+export { createProceduralGpuTexture, DEFAULT_PROCEDURAL_CONFIG, generateProceduralTexture } from "./passes/procedural-texture";
+export type { ProceduralTextureConfig, ProceduralTextureType } from "./passes/procedural-texture";
+export type { ReflectionProbeConfig, ReflectionProbeData } from "./passes/reflection-probe";
+export { RSMPass } from "./passes/rsm-pass";
+export { layoutSDFText, parseSDFFont, SDF_TEXT_SHADER } from "./passes/sdf-text";
+export type { SDFFontData, SDFGlyph } from "./passes/sdf-text";
+export { ShadowPass } from "./passes/shadow";
+export { ShadowMapSystem } from "./passes/shadow-map";
+export type { ShadowMapOptions } from "./passes/shadow-map";
+export { SkyDomePass } from "./passes/sky-dome";
+export type { SkyDomeUniforms } from "./passes/sky-dome";
+export { SkyboxPass } from "./passes/skybox";
+export { MAX_SPOT_LIGHT_SHADOWS, SpotLightShadowPass } from "./passes/spot-light-shadow";
+export type { SpotLightShadowData } from "./passes/spot-light-shadow";
+export { TerrainPass } from "./passes/terrain";
+export type { TerrainUniforms } from "./passes/terrain";
+export { TransparentPass } from "./passes/transparent";
+export type { TransparentRenderItem } from "./passes/transparent";
+export { UnderwaterFogPass } from "./passes/underwater-fog";
+export { VideoTextureSource } from "./passes/video-texture";
+export type { VideoTextureConfig } from "./passes/video-texture";
+export { VolumetricLightingPass } from "./passes/volumetric-pass";
+export { computeExtinction, computeFroxelCount, computeFroxelGridBufferSize, computeFroxelLightIndexListSize, computeMiePhase, computeOpticalDepth, computeTransmittance, DEFAULT_FROXEL_CONFIG, DEFAULT_VOLUMETRIC_FOG, froxelDepthToSlice, froxelIndex3D, froxelSliceToFar, froxelSliceToNear, packVolumetricUniforms, screenPosToFroxelXY } from "./passes/volumetric-types";
+export { WaterPass } from "./passes/water";
+export type { WaterUniforms } from "./passes/water";
+export { PBRSystem } from "./pbr";
+export { PipelineCache } from "./pipeline";
+export { RenderPass } from "./render-pass";
+export type { FrameGraphBuilder } from "./render-pass";
+export { RendererInputBusImpl } from "./renderer-input-bus";
+export { RendererModuleHost } from "./renderer-module-host";
+export type { RendererModuleHostCallbacks } from "./renderer-module-host";
+export { SabCanvasOverlay } from "./sab-canvas-overlay";
+export type { SabCanvasOverlayOptions } from "./sab-canvas-overlay";
+export { clearShaderValidationDedup, createValidatedShaderModule, createValidatedShaderModuleAsync, installShaderValidationGuard } from "./shader-validator";
+export { CSM_SHADER_CHUNK, POINT_SHADOW_SHADER_CHUNK, SPOT_SHADOW_SHADER_CHUNK } from "./shaders/shadow-chunks";
+export { SkyboxRenderer } from "./skybox";
+export type { SkyboxOptions } from "./skybox";
+export { SurfaceManager } from "./surface";
+export { DEFAULT_TONE_MAPPING_SETTINGS, getToneMappingOperatorIndex, TONE_MAPPING_SHADER_CHUNK, ToneMappingOperator } from "./tonemap";
+export type { ToneMappingSettings } from "./tonemap";
+export { TrackedRenderPass } from "./tracked-render-pass";
+export type { ITrackedRenderPass } from "./tracked-render-pass";
+export { ViewportLayout, viewportRectToPixels } from "./viewport";
+export type { ViewportMode, ViewportRect } from "./viewport";
+export { wgslHotReload } from "./wgsl-hmr";
+export type { WgslReloadFn } from "./wgsl-hmr";
+
+// Decal passes (from mesh section in original barrel)
+export { computeDecalProjectionMatrix, computeDecalViewMatrix, createDecalMesh } from "./passes/decal-mesh";
+export type { DecalProjector } from "./passes/decal-mesh";
+export { DecalPass } from "./passes/decal-pass";
+export type { DecalItem } from "./passes/decal-pass";
+export { GreasedLinePass } from "./passes/greased-line-pass";
+
+// Skinning passes (from animation section in original barrel)
+export { packBoneTransformsVec4, VertexSkinningPass } from "./passes/skinning";
+export { createSkinningPass, MAX_BONE_INFLUENCES, MAX_BONES_VS, SKINNING_VS_GLSL, SKINNING_VS_WGSL } from "./passes/skinning-vs";
+export type { SkinningMode, SkinningPass } from "./passes/skinning-vs";
+
+// GPU Skinning Compute Pass
+export { packBoneTransforms, SkinningComputePass } from "./passes/skinning";
+export type { SkinningComputePassResources } from "./passes/skinning";
+
+// Compute Graph Pass + Kernel Helper
+export { runComputeKernel } from "./compute-kernel";
+export type { ComputeKernelInput, ComputeKernelResult } from "./compute-kernel";
+export { GraphComputePass } from "./passes/graph-compute";
+export type { GraphComputeBuffer } from "./passes/graph-compute";
+
+// Debug Visualization
+export { DebugVizPass, DEFAULT_DEBUG_VIZ_SETTINGS } from "./passes/debug-viz";
+export type { DebugVizMode, DebugVizSettings } from "./passes/debug-viz";
+
+// Split-Screen Layout
+export { computeViewports, getLayoutForPlayerCount, getPlayerCountForLayout } from "./splitscreen";
+export type { SplitscreenLayoutType, ViewportSlot } from "./splitscreen";
+
+// GPU Resource Tracker (destroy helpers)
+export { destroyAll, destroyAndNull, destroyMapValues } from "./resource-tracker";
+export type { Destroyable } from "./resource-tracker";
+