@downdraft/engine 0.0.0 → 0.1.0

package/libraries/weather/src/weather-system.ts

@@ -0,0 +1,271 @@
+// ============================================================================
+// Weather System — dynamic weather, rare events, rain collectors
+// Reusable plugin: depends on BiomeProvider interface, not game-specific types
+// ============================================================================
+
+import { WeatherType } from "./types";
+import type { WeatherState, WeatherConfig, BiomeProvider } from "./types";
+import { DEFAULT_WEATHER_CONFIG } from "./types";
+
+export class WeatherSystem {
+  private state: WeatherState;
+  private biomeProvider: BiomeProvider;
+  private config: WeatherConfig;
+  private rainCollectors: Map<number, number> = new Map();
+  private targetWindSpeed = 2;
+  private weatherIntensityMul = 1.0;
+  private simTime = 0;
+
+  constructor(biomeProvider: BiomeProvider, weatherIntensityMul = 1.0, config?: Partial<WeatherConfig>) {
+    this.biomeProvider = biomeProvider;
+    this.weatherIntensityMul = weatherIntensityMul;
+    this.config = { ...DEFAULT_WEATHER_CONFIG, ...config };
+    this.state = {
+      type: WeatherType.Clear,
+      intensity: 0,
+      windDirection: { x: 1, y: 0, z: 0 },
+      windSpeed: 2,
+      visibility: 1.0,
+      temperature: 20,
+      duration: 60,
+      cooldown: 0,
+      isRareEvent: false,
+    };
+  }
+
+  tick(dt: number, timeOfDay: number): void {
+    this.simTime += dt;
+    this.state.duration -= dt;
+    this.state.cooldown -= dt;
+
+    if (this.state.duration <= 0 && this.state.cooldown <= 0) {
+      this.transitionWeather(timeOfDay);
+    }
+
+    this.updateWind(dt);
+    this.updateVisibility(dt);
+    this.updateTemperature(dt, timeOfDay);
+
+    if (this.state.type === WeatherType.Rain || this.state.type === WeatherType.Storm ||
+        this.state.type === WeatherType.HellStorm) {
+      for (const [id, amount] of this.rainCollectors.entries()) {
+        const newAmount = Math.min(
+          this.config.rainCollectorCapacity,
+          amount + this.config.rainCollectorFillRate * dt * this.state.intensity,
+        );
+        this.rainCollectors.set(id, newAmount);
+      }
+    }
+  }
+
+  private transitionWeather(timeOfDay: number): void {
+    const isNight = timeOfDay > this.config.nightStartFrac || timeOfDay < this.config.nightEndFrac;
+    const roll = Math.random();
+
+    if (roll < this.config.clearChance) {
+      const cloudRoll = Math.random();
+      if (cloudRoll < this.config.fullClearChance) {
+        this.state.type = WeatherType.Clear;
+        this.state.intensity = 0;
+      } else if (cloudRoll < this.config.fullClearChance + this.config.partlyCloudyChance) {
+        this.state.type = WeatherType.PartlyCloudy;
+        this.state.intensity = 0.3 * this.weatherIntensityMul;
+      } else {
+        this.state.type = WeatherType.Overcast;
+        this.state.intensity = 0.6 * this.weatherIntensityMul;
+      }
+    } else {
+      const stormRoll = Math.random();
+      if (stormRoll < 0.4) {
+        this.state.type = WeatherType.Rain;
+        this.state.intensity = (0.5 + Math.random() * 0.3) * this.weatherIntensityMul;
+      } else if (stormRoll < 0.65) {
+        this.state.type = WeatherType.Storm;
+        this.state.intensity = (0.7 + Math.random() * 0.3) * this.weatherIntensityMul;
+      } else if (stormRoll < 0.85) {
+        this.state.type = WeatherType.Fog;
+        this.state.intensity = 0.4 * this.weatherIntensityMul;
+      } else {
+        this.state.type = WeatherType.Snow;
+        this.state.intensity = 0.5 * this.weatherIntensityMul;
+      }
+    }
+
+    if (Math.random() < this.config.rareEventChance) {
+      const rareRoll = Math.random();
+      if (rareRoll < 0.34) {
+        this.state.type = WeatherType.Eclipse;
+        this.state.intensity = 0.8;
+        this.state.isRareEvent = true;
+      } else if (rareRoll < 0.67 && isNight) {
+        this.state.type = WeatherType.FullMoon;
+        this.state.intensity = 0.3;
+        this.state.isRareEvent = true;
+      } else {
+        this.state.type = WeatherType.HellStorm;
+        this.state.intensity = 1.0 * this.weatherIntensityMul;
+        this.state.isRareEvent = true;
+      }
+    } else {
+      this.state.isRareEvent = false;
+    }
+
+    if (this.state.type === WeatherType.FullMoon && isNight) {
+      let remainingFrac: number;
+      if (timeOfDay > this.config.nightStartFrac) {
+        remainingFrac = (1.0 - timeOfDay) + this.config.nightEndFrac;
+      } else {
+        remainingFrac = this.config.nightEndFrac - timeOfDay;
+      }
+      this.state.duration = Math.max(this.config.minDuration, remainingFrac * 1200);
+    } else if (this.state.isRareEvent) {
+      this.state.duration = this.config.maxDuration;
+    } else {
+      this.state.duration = this.config.minDuration + Math.random() * (this.config.maxDuration - this.config.minDuration);
+    }
+    this.state.cooldown = 5;
+
+    if (this.state.type === WeatherType.Storm || this.state.type === WeatherType.HellStorm) {
+      this.targetWindSpeed = 15 + Math.random() * 10;
+    } else if (this.state.type === WeatherType.Rain) {
+      this.targetWindSpeed = 8 + Math.random() * 4;
+    } else if (this.state.type === WeatherType.Overcast || this.state.type === WeatherType.Snow) {
+      this.targetWindSpeed = 5;
+    } else {
+      this.targetWindSpeed = 2;
+    }
+  }
+
+  private updateWind(dt: number): void {
+    const angle = this.simTime / 10000;
+    this.state.windDirection.x = Math.cos(angle);
+    this.state.windDirection.z = Math.sin(angle);
+    this.state.windSpeed += (this.targetWindSpeed - this.state.windSpeed) * dt * 0.5;
+  }
+
+  private updateVisibility(dt: number): void {
+    let targetVisibility = 1.0;
+
+    switch (this.state.type) {
+      case WeatherType.Clear: targetVisibility = 1.0; break;
+      case WeatherType.PartlyCloudy: targetVisibility = 0.9; break;
+      case WeatherType.Overcast: targetVisibility = 0.75; break;
+      case WeatherType.Rain: targetVisibility = 0.5 + (1 - this.state.intensity) * 0.3; break;
+      case WeatherType.Storm: targetVisibility = 0.3; break;
+      case WeatherType.Fog: targetVisibility = 0.2; break;
+      case WeatherType.Eclipse: targetVisibility = 0.4; break;
+      case WeatherType.HellStorm: targetVisibility = 0.25; break;
+      case WeatherType.FullMoon: targetVisibility = 0.7; break;
+      case WeatherType.Snow: targetVisibility = 0.4; break;
+    }
+
+    const lerpFactor = Math.min(1, dt * 0.5);
+    this.state.visibility += (targetVisibility - this.state.visibility) * lerpFactor;
+  }
+
+  private updateTemperature(dt: number, timeOfDay: number): void {
+    const dayFactor = Math.sin(timeOfDay * Math.PI * 2 - Math.PI / 2) * 0.5 + 0.5;
+    let targetTemp = 15 + dayFactor * 10;
+
+    switch (this.state.type) {
+      case WeatherType.Storm:
+      case WeatherType.HellStorm:
+        targetTemp -= 5; break;
+      case WeatherType.Rain: targetTemp -= 3; break;
+      case WeatherType.Snow: targetTemp -= 15; break;
+      case WeatherType.Fog: targetTemp -= 2; break;
+      case WeatherType.Eclipse: targetTemp -= 10; break;
+    }
+
+    const lerpFactor = Math.min(1, dt / 60);
+    this.state.temperature += (targetTemp - this.state.temperature) * lerpFactor;
+  }
+
+  getState(): WeatherState {
+    return { ...this.state };
+  }
+
+  isRaining(): boolean {
+    return this.state.type === WeatherType.Rain || this.state.type === WeatherType.Storm ||
+           this.state.type === WeatherType.HellStorm;
+  }
+
+  isStormy(): boolean {
+    return this.state.type === WeatherType.Storm || this.state.type === WeatherType.HellStorm;
+  }
+
+  isRareEvent(): boolean {
+    return this.state.isRareEvent;
+  }
+
+  isHellStorm(): boolean {
+    return this.state.type === WeatherType.HellStorm;
+  }
+
+  getWindSpeed(): number {
+    return this.state.windSpeed;
+  }
+
+  getWindDirection(): { x: number; z: number } {
+    return { x: this.state.windDirection.x, z: this.state.windDirection.z };
+  }
+
+  getVisibility(): number {
+    return this.state.visibility;
+  }
+
+  getTemperature(): number {
+    return this.state.temperature;
+  }
+
+  setTemperature(temp: number): void {
+    this.state.temperature = temp;
+  }
+
+  setWeatherType(type: WeatherType, intensity?: number): void {
+    this.state.type = type;
+    this.state.intensity = intensity ?? this.defaultIntensityFor(type);
+    this.state.isRareEvent = false;
+    this.state.duration = this.config.maxDuration;
+    this.state.cooldown = 5;
+  }
+
+  setWeatherIntensityMul(mul: number): void {
+    this.weatherIntensityMul = mul;
+  }
+
+  private defaultIntensityFor(type: WeatherType): number {
+    switch (type) {
+      case WeatherType.Clear: return 0;
+      case WeatherType.PartlyCloudy: return 0.3;
+      case WeatherType.Overcast: return 0.6;
+      case WeatherType.Rain: return 0.6;
+      case WeatherType.Storm: return 0.8;
+      case WeatherType.Fog: return 0.4;
+      case WeatherType.Eclipse: return 0.8;
+      case WeatherType.FullMoon: return 0.3;
+      case WeatherType.HellStorm: return 1.0;
+      case WeatherType.Snow: return 0.5;
+      default: return 0;
+    }
+  }
+
+  registerRainCollector(entityId: number): void {
+    this.rainCollectors.set(entityId, 0);
+  }
+
+  unregisterRainCollector(entityId: number): void {
+    this.rainCollectors.delete(entityId);
+  }
+
+  getRainCollectorAmount(entityId: number): number {
+    return this.rainCollectors.get(entityId) ?? 0;
+  }
+
+  useRainCollectorWater(entityId: number, amount: number): number {
+    const current = this.rainCollectors.get(entityId) ?? 0;
+    const used = Math.min(current, amount);
+    this.rainCollectors.set(entityId, current - used);
+    return used;
+  }
+}

package/libraries/weatherfx/README.md

@@ -0,0 +1,24 @@
+# `@downdraft/engine/libraries/weatherfx`
+
+Weather rendering — cloud, fog, and precipitation render passes driven by sim weather state (WeatherFxLib descriptor).
+
+## Install
+
+```sh
+bun add @downdraft/engine/libraries/weatherfx
+```
+
+## Key exports
+
+- `COLLISION_RADIUS`
+- `CloudSystem`
+- `CloudUniformsStruct`
+- `MAX_VOXEL_FLOATS`
+- `ParticleSystem`
+- `PerLayerUniformsStruct`
+- `RenderUniformsStruct`
+- `SimParamsStruct`
+- `WeatherFxLib`
+- `WeatherFxTok`
+
+See the [Downdraft engine repository](https://github.com/knackstedt/downdraft) for architecture docs and examples.

package/libraries/weatherfx/src/cloud-provider.ts

@@ -0,0 +1,31 @@
+// ============================================================================
+// Cloud Mesh Provider — interface for game-specific cloud field generation
+// Games implement this to supply voxel fields and mesh extraction for clouds.
+// ============================================================================
+
+import type { ExtractedMesh, VoxelField } from "@downdraft/engine/libraries/marching-cubes";
+import type { WeatherType } from "@downdraft/engine/libraries/weather";
+
+export type CloudVoxelField = VoxelField;
+export type CloudExtractedMesh = ExtractedMesh;
+
+export interface CloudLayerConfig {
+  altitude: number;
+}
+
+export interface CloudMeshProvider {
+  getLayerTypes(): string[];
+  getLayerConfig(layerType: string): CloudLayerConfig;
+  getRegenDistance(): number;
+  getMaxLayerGenPerFrame(): number;
+  getLayerGenTimeBudgetMs(): number;
+  generateLayerField(
+    layerType: string,
+    centerX: number,
+    centerZ: number,
+    weatherType: WeatherType,
+    windOffsetX: number,
+    windOffsetZ: number,
+  ): CloudVoxelField;
+  extractMesh(field: CloudVoxelField): CloudExtractedMesh;
+}

package/libraries/weatherfx/src/cloud-system.ts

@@ -0,0 +1,372 @@
+// ============================================================================
+// CloudSystem — renders continuous cloud layers as low-poly marching cubes meshes
+// Each layer is a single large voxel field sampled from world-space Perlin noise.
+// Layers scroll with the player and drift with wind.
+// ============================================================================
+
+import { calculateViewProj, createLogger, createValidatedShaderModule, DEPTH_FORMAT, MSAA_SAMPLE_COUNT, type CameraState } from "@downdraft/engine";
+import { WeatherType } from "@downdraft/engine/libraries/weather";
+import { StructView, wgsl } from "@downdraft/engine/shader-graph";
+import type { CloudExtractedMesh, CloudMeshProvider, CloudVoxelField } from "./cloud-provider";
+import CLOUD_WGSL from "./shaders/cloud.wgsl?raw" with { type: "text" };
+
+const log = createLogger();
+
+// --- Typed uniform structs (validate against cloud.wgsl) ---
+export const CloudUniformsStruct = wgsl.struct("CloudUniforms", {
+  viewProj: wgsl.mat4x4f,
+  cameraPos: wgsl.vec3f,
+  timeOfDay: wgsl.f32,
+  weatherType: wgsl.u32,
+  sunDir: wgsl.vec3f,
+  sunIntensity: wgsl.f32,
+  moonDir: wgsl.vec3f,
+  moonIntensity: wgsl.f32,
+  time: wgsl.f32,
+  weatherBlend: wgsl.f32,
+  fogColor: wgsl.vec3f,
+  fogDensity: wgsl.f32,
+});
+
+export const PerLayerUniformsStruct = wgsl.struct("PerLayerUniforms", {
+  layerPos: wgsl.vec3f,
+  _pad: wgsl.f32,
+});
+
+
+// --- Per-layer state ---
+interface CloudLayer {
+  layerType: string;
+  // GPU buffers
+  vertexBuffer: GPUBuffer | null;
+  indexBuffer: GPUBuffer | null;
+  indexCount: number;
+  useUint32: boolean;
+  // Per-layer uniform buffer
+  perLayerUniform: GPUBuffer;
+  bindGroup: GPUBindGroup | null;
+  // World position (center of the field)
+  centerX: number;
+  centerZ: number;
+  altitude: number;
+  // Wind drift offset (accumulated)
+  windOffsetX: number;
+  windOffsetZ: number;
+  // Status
+  generated: boolean;
+  // Last generation center
+  genCenterX: number;
+  genCenterZ: number;
+  // Pending regeneration
+  pendingRegen: boolean;
+}
+
+export class CloudSystem {
+  private device: GPUDevice;
+  private format: GPUTextureFormat;
+  private provider: CloudMeshProvider;
+  private pipeline: GPURenderPipeline | null = null;
+  private bindGroupLayout: GPUBindGroupLayout | null = null;
+  private uniformBuffer: GPUBuffer | null = null;
+
+  private layers: CloudLayer[] = [];
+  private genThisFrame = 0;
+  private _uniformView: StructView | null = null;
+  private _uniformBuf: Float32Array | null = null;
+  private _perLayerView: StructView | null = null;
+  private _perLayerBuf: Float32Array | null = null;
+
+  constructor(device: GPUDevice, format: GPUTextureFormat, provider: CloudMeshProvider) {
+    this.device = device;
+    this.format = format;
+    this.provider = provider;
+  }
+
+  async init(): Promise<void> {
+    this._uniformBuf = new Float32Array(CloudUniformsStruct.floatCount);
+    this._uniformView = CloudUniformsStruct.view(this._uniformBuf);
+    this._perLayerBuf = new Float32Array(PerLayerUniformsStruct.floatCount);
+    this._perLayerView = PerLayerUniformsStruct.view(this._perLayerBuf);
+
+    this.uniformBuffer = this.device.createBuffer({
+      size: 256,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+    });
+
+    this.bindGroupLayout = this.device.createBindGroupLayout({
+      entries: [
+        { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
+        { binding: 1, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: "uniform", hasDynamicOffset: true } },
+      ],
+    });
+
+    const pipelineLayout = this.device.createPipelineLayout({
+      bindGroupLayouts: [this.bindGroupLayout],
+    });
+
+    const shaderModule = createValidatedShaderModule(this.device, { code: CLOUD_WGSL, label: "WeatherFx.cloud" });
+
+    this.pipeline = this.device.createRenderPipeline({
+      layout: pipelineLayout,
+      vertex: {
+        module: shaderModule,
+        entryPoint: "vs_main",
+        buffers: [{
+          arrayStride: 36,
+          attributes: [
+            { shaderLocation: 0, offset: 0, format: "float32x3" },
+            { shaderLocation: 1, offset: 12, format: "float32x3" },
+            { shaderLocation: 2, offset: 24, format: "float32x3" },
+          ],
+        }],
+      },
+      fragment: {
+        module: shaderModule,
+        entryPoint: "fs_main",
+        targets: [{
+          format: this.format,
+          blend: {
+            color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha", operation: "add" },
+            alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" },
+          },
+        }],
+      },
+      primitive: { topology: "triangle-list" },
+      multisample: { count: MSAA_SAMPLE_COUNT },
+      depthStencil: {
+        format: DEPTH_FORMAT,
+        depthWriteEnabled: false,
+        depthCompare: "less-equal",
+      },
+    });
+
+    // Initialize cloud layers from provider
+    const layerTypes = this.provider.getLayerTypes();
+    layerTypes.forEach((layerType) => {
+      const cfg = this.provider.getLayerConfig(layerType);
+      this.layers.push({
+        layerType,
+        vertexBuffer: null,
+        indexBuffer: null,
+        indexCount: 0,
+        useUint32: false,
+        perLayerUniform: this.device.createBuffer({
+          size: 16,
+          usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        }),
+        bindGroup: null,
+        centerX: 0,
+        centerZ: 0,
+        altitude: cfg.altitude,
+        windOffsetX: 0,
+        windOffsetZ: 0,
+        generated: false,
+        genCenterX: 0,
+        genCenterZ: 0,
+        pendingRegen: true,
+      });
+    });
+
+    log.info("CloudSystem", `Initialized with ${this.layers.length} layers`);
+  }
+
+  update(
+    dt: number,
+    playerPos: { x: number; y: number; z: number },
+    windDirX: number,
+    windDirZ: number,
+    windSpeed: number,
+    weatherType: WeatherType,
+  ): void {
+    this.genThisFrame = 0;
+
+    this.layers.forEach((layer) => {
+      // Accumulate wind drift
+      layer.windOffsetX += windDirX * windSpeed * dt;
+      layer.windOffsetZ += windDirZ * windSpeed * dt;
+
+      // Update center to follow player
+      layer.centerX = playerPos.x;
+      layer.centerZ = playerPos.z;
+
+      // Check if we need to regenerate (player moved too far from last gen center)
+      const dx = layer.centerX - layer.genCenterX;
+      const dz = layer.centerZ - layer.genCenterZ;
+      const distSq = dx * dx + dz * dz;
+      const regenDist = this.provider.getRegenDistance();
+
+      if (!layer.generated || distSq > regenDist * regenDist) {
+        layer.pendingRegen = true;
+      }
+    });
+
+    // Process pending layer generation (one at a time for performance)
+    this.processPendingGen(weatherType);
+  }
+
+  private processPendingGen(weatherType: WeatherType): void {
+    const maxPerFrame = this.provider.getMaxLayerGenPerFrame();
+    const budgetMs = this.provider.getLayerGenTimeBudgetMs();
+    const startTime = performance.now();
+
+    for (let _i = 0, _it = this.layers, _n = _it.length; _i < _n; _i++) { const layer = _it[_i];
+      if (!layer.pendingRegen) continue;
+      if (this.genThisFrame >= maxPerFrame) break;
+      if (performance.now() - startTime > budgetMs) break;
+
+      this.generateLayerMesh(layer, weatherType);
+      layer.pendingRegen = false;
+      layer.generated = true;
+      layer.genCenterX = layer.centerX;
+      layer.genCenterZ = layer.centerZ;
+      this.genThisFrame++;
+    }
+  }
+
+  private generateLayerMesh(layer: CloudLayer, weatherType: WeatherType): void {
+    const field: CloudVoxelField = this.provider.generateLayerField(
+      layer.layerType,
+      layer.centerX,
+      layer.centerZ,
+      weatherType,
+      layer.windOffsetX,
+      layer.windOffsetZ,
+    );
+
+    const extracted: CloudExtractedMesh = this.provider.extractMesh(field);
+    if (extracted.verts.length === 0 || extracted.indices.length === 0) {
+      let minD = Infinity, maxD = -Infinity, solidCount = 0;
+      for (let i = 0; i < field.data.length; i++) {
+        const v = field.data[i];
+        if (v < minD) minD = v;
+        if (v > maxD) maxD = v;
+        if (v < field.isoLevel) solidCount++;
+      }
+      log.warn("CloudSystem", `Empty mesh for layer=${layer.layerType} iso=${field.isoLevel} densityRange=[${minD.toFixed(3)}, ${maxD.toFixed(3)}] solidVoxels=${solidCount}/${field.data.length} (${(solidCount/field.data.length*100).toFixed(1)}%)`);
+      return;
+    }
+
+    log.info("CloudSystem", `Generated layer ${layer.layerType}: ${extracted.verts.length / 9} verts, ${extracted.indices.length} indices`);
+
+    // Vertices are in world space relative to field origin (centered at 0,0,0)
+    const verts = extracted.verts;
+
+    // Dispose old buffers
+    if (layer.vertexBuffer) { layer.vertexBuffer.destroy(); layer.vertexBuffer = null; }
+    if (layer.indexBuffer) { layer.indexBuffer.destroy(); layer.indexBuffer = null; }
+
+    // Create vertex buffer
+    layer.vertexBuffer = this.device.createBuffer({
+      size: verts.byteLength,
+      usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+    });
+    this.device.queue.writeBuffer(layer.vertexBuffer, 0, verts as any);
+
+    // Create index buffer
+    const indexBuf = extracted.indices;
+    let indexData: Uint16Array | Uint32Array;
+    if (!extracted.useUint32 && indexBuf instanceof Uint16Array && indexBuf.length % 2 !== 0) {
+      indexData = new Uint16Array(indexBuf.length + 1);
+      indexData.set(indexBuf);
+    } else {
+      indexData = indexBuf as Uint16Array | Uint32Array;
+    }
+
+    layer.indexBuffer = this.device.createBuffer({
+      size: indexData.byteLength,
+      usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
+    });
+    this.device.queue.writeBuffer(layer.indexBuffer, 0, indexData as any);
+
+    layer.indexCount = indexBuf.length;
+    layer.useUint32 = extracted.useUint32;
+
+    // Create bind group
+    layer.bindGroup = this.device.createBindGroup({
+      layout: this.bindGroupLayout!,
+      entries: [
+        { binding: 0, resource: { buffer: this.uniformBuffer! } },
+        { binding: 1, resource: { buffer: layer.perLayerUniform, size: 16 } },
+      ],
+    });
+  }
+
+  render(
+    passEncoder: GPURenderPassEncoder | any,
+    camera: CameraState,
+    timeOfDay: number,
+    weatherType: WeatherType,
+    _windSpeed: number,
+    _windDirX: number,
+    _windDirZ: number,
+    elapsedTime: number,
+    _playerPos: { x: number; y: number; z: number },
+    sunDir: [number, number, number],
+    sunIntensity: number,
+    moonDir: [number, number, number],
+    moonIntensity: number,
+    fogColor: [number, number, number],
+    fogDensity: number,
+  ): void {
+    if (!this.pipeline || !this.uniformBuffer || !this._uniformView || !this._uniformBuf) return;
+
+    const viewProj = calculateViewProj(camera);
+    const v = this._uniformView;
+
+    // Write main uniforms via typed view
+    v.set("viewProj", viewProj);
+    v.set("cameraPos", camera.position);
+    v.set("timeOfDay", timeOfDay);
+    v.setU32("weatherType", weatherType);
+    v.set("sunDir", sunDir);
+    v.set("sunIntensity", sunIntensity);
+    v.set("moonDir", moonDir);
+    v.set("moonIntensity", moonIntensity);
+    v.set("time", elapsedTime);
+    v.set("weatherBlend", 1.0);
+    v.set("fogColor", fogColor);
+    v.set("fogDensity", fogDensity);
+
+    this.device.queue.writeBuffer(this.uniformBuffer, 0, this._uniformBuf as any);
+
+    passEncoder.setPipeline(this.pipeline);
+
+    for (let _i = 0, _it = this.layers, _n = _it.length; _i < _n; _i++) { const layer = _it[_i];
+      if (!layer.generated || !layer.vertexBuffer || !layer.indexBuffer || !layer.bindGroup) continue;
+      if (layer.indexCount === 0) continue;
+
+      if (!this._perLayerView || !this._perLayerBuf) continue;
+      const pv = this._perLayerView;
+      pv.set("layerPos", [layer.genCenterX - layer.windOffsetX, layer.altitude, layer.genCenterZ - layer.windOffsetZ]);
+      pv.set("_pad", 0);
+      this.device.queue.writeBuffer(layer.perLayerUniform, 0, this._perLayerBuf as any);
+
+      passEncoder.setBindGroup(0, layer.bindGroup, [0]);
+      passEncoder.setVertexBuffer(0, layer.vertexBuffer);
+      passEncoder.setIndexBuffer(layer.indexBuffer, layer.useUint32 ? "uint32" : "uint16");
+      passEncoder.drawIndexed(layer.indexCount);
+    }
+  }
+
+  destroy(): void {
+    this.layers.forEach((layer) => {
+      if (layer.vertexBuffer) { layer.vertexBuffer.destroy(); layer.vertexBuffer = null; }
+      if (layer.indexBuffer) { layer.indexBuffer.destroy(); layer.indexBuffer = null; }
+      layer.perLayerUniform.destroy();
+      // GPUBindGroup has no destroy() — just null it.
+      layer.bindGroup = null;
+    });
+    if (this.uniformBuffer) {
+      this.uniformBuffer.destroy();
+      this.uniformBuffer = null;
+    }
+    this.pipeline?.destroy();
+    this.pipeline = null;
+    // GPUBindGroupLayout has no destroy() — just null it.
+    this.bindGroupLayout = null;
+    this._uniformView = null;
+    this._uniformBuf = null;
+    this._perLayerView = null;
+    this._perLayerBuf = null;
+  }
+}