@downdraft/engine 0.0.0 → 0.1.1

package/core/src/render/material-types/physical.wgsl

@@ -0,0 +1,152 @@
+// Physical material — extends PBR with clearcoat, transmission, sheen, iridescence
+// Forward-rendered, Cook-Torrance BRDF + clearcoat layer
+
+struct PhysicalUniforms {
+  baseColor: vec4<f32>,
+  roughness: f32,
+  metallic: f32,
+  clearcoat: f32,
+  clearcoatRoughness: f32,
+  transmission: f32,
+  ior: f32,
+  thickness: f32,
+  sheenColor: vec3<f32>,
+  sheenRoughness: f32,
+  iridescence: f32,
+  iridescenceIOR: f32,
+  attenuationColor: vec3<f32>,
+  attenuationDistance: f32,
+  envMapIntensity: f32,
+  _pad: f32,
+  _pad2: f32,
+  emissive: vec3<f32>,
+};
+
+struct CameraUniforms {
+  viewProj: mat4x4<f32>,
+  cameraPos: vec3<f32>,
+  _pad: f32,
+};
+
+struct ModelUniforms {
+  model: mat4x4<f32>,
+  normalMatrix: mat4x4<f32>,
+};
+
+struct LightUniforms {
+  dirDirection: vec4<f32>,
+  dirColor: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> mat: PhysicalUniforms;
+@group(0) @binding(1) var<uniform> camera: CameraUniforms;
+@group(0) @binding(2) var<uniform> model: ModelUniforms;
+@group(0) @binding(3) var<uniform> lights: LightUniforms;
+@group(0) @binding(4) var albedoMap: texture_2d<f32>;
+@group(0) @binding(5) var normalMap: texture_2d<f32>;
+@group(0) @binding(6) var clearcoatNormalMap: texture_2d<f32>;
+@group(0) @binding(7) var texSampler: sampler;
+
+const PI = 3.14159265359;
+
+fn distributionGGX(N: vec3<f32>, H: vec3<f32>, roughness: f32) -> f32 {
+  let a = roughness * roughness;
+  let a2 = a * a;
+  let NdotH = max(dot(N, H), 0.0);
+  let NdotH2 = NdotH * NdotH;
+  let nom = a2;
+  let denom = NdotH2 * (a2 - 1.0) + 1.0;
+  return nom / (PI * denom * denom);
+}
+
+fn geometrySmith(N: vec3<f32>, V: vec3<f32>, L: vec3<f32>, roughness: f32) -> f32 {
+  let r = roughness + 1.0;
+  let k = (r * r) / 8.0;
+  let NdotV = max(dot(N, V), 0.0);
+  let NdotL = max(dot(N, L), 0.0);
+  let ggxV = NdotV / (NdotV * (1.0 - k) + k);
+  let ggxL = NdotL / (NdotL * (1.0 - k) + k);
+  return ggxV * ggxL;
+}
+
+fn fresnelSchlick(cosTheta: f32, F0: vec3<f32>) -> vec3<f32> {
+  return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);
+}
+
+fn fresnelSchlickRoughness(cosTheta: f32, F0: vec3<f32>, roughness: f32) -> vec3<f32> {
+  return F0 + (max(vec3<f32>(1.0 - roughness), F0) - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);
+}
+
+struct VertexInput {
+  @location(0) position: vec3<f32>,
+  @location(1) normal: vec3<f32>,
+  @location(2) uv: vec2<f32>,
+  @location(3) tangent: vec3<f32>,
+};
+
+struct VertexOutput {
+  @builtin(position) clipPosition: vec4<f32>,
+  @location(0) uv: vec2<f32>,
+  @location(1) worldNormal: vec3<f32>,
+  @location(2) worldPos: vec3<f32>,
+  @location(3) worldTangent: vec3<f32>,
+};
+
+@vertex
+fn vs_main(input: VertexInput) -> VertexOutput {
+  var output: VertexOutput;
+  let worldPos = model.model * vec4<f32>(input.position, 1.0);
+  output.clipPosition = camera.viewProj * worldPos;
+  output.uv = input.uv;
+  output.worldNormal = normalize((model.normalMatrix * vec4<f32>(input.normal, 0.0)).xyz);
+  output.worldPos = worldPos.xyz;
+  output.worldTangent = normalize((model.normalMatrix * vec4<f32>(input.tangent, 0.0)).xyz);
+  return output;
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  let N = normalize(input.worldNormal);
+  let V = normalize(camera.cameraPos - input.worldPos);
+
+  let albedo = textureSample(albedoMap, texSampler, input.uv).rgb * mat.baseColor.rgb;
+  let F0 = mix(vec3<f32>(0.04), albedo, mat.metallic);
+
+  let L = normalize(-lights.dirDirection.xyz);
+  let H = normalize(V + L);
+  let NdotL = max(dot(N, L), 0.0);
+
+  let NDF = distributionGGX(N, H, mat.roughness);
+  let G = geometrySmith(N, V, L, mat.roughness);
+  let F = fresnelSchlick(max(dot(H, V), 0.0), F0);
+
+  let numerator = NDF * G * F;
+  let denominator = 4.0 * max(dot(N, V), 0.0) * NdotL + 0.0001;
+  let specular = numerator / denominator;
+
+  let kS = F;
+  let kD = (vec3<f32>(1.0) - kS) * (1.0 - mat.metallic);
+
+  let diffuse = kD * albedo / PI;
+  var color = (diffuse + specular) * lights.dirColor.rgb * NdotL;
+
+  if (mat.clearcoat > 0.0) {
+    let ccN = normalize(textureSample(clearcoatNormalMap, texSampler, input.uv).xyz * 2.0 - 1.0);
+    let ccF0 = vec3<f32>(0.04);
+    let ccNDF = distributionGGX(ccN, H, mat.clearcoatRoughness);
+    let ccG = geometrySmith(ccN, V, L, mat.clearcoatRoughness);
+    let ccF = fresnelSchlick(max(dot(H, V), 0.0), ccF0);
+    let ccSpec = (ccNDF * ccG * ccF) / (4.0 * max(dot(ccN, V), 0.0) * NdotL + 0.0001);
+    color = mix(color, color + ccSpec * lights.dirColor.rgb * NdotL, mat.clearcoat);
+  }
+
+  if (mat.sheenRoughness < 1.0) {
+    let sheenF = pow(1.0 - max(dot(N, V), 0.0), 5.0) * (1.0 - mat.sheenRoughness);
+    color += mat.sheenColor * sheenF * NdotL * 0.3;
+  }
+
+  let ambient = albedo * 0.03 * mat.envMapIntensity;
+  color += ambient;
+
+  return vec4<f32>(color, mat.baseColor.a);
+}

package/core/src/render/material-types/sprite.wgsl

@@ -0,0 +1,46 @@
+// Sprite material — billboard quad with texture + color, no lighting
+// Forward-rendered
+
+struct SpriteUniforms {
+  color: vec4<f32>,
+};
+
+struct CameraUniforms {
+  viewProj: mat4x4<f32>,
+  cameraRight: vec3<f32>,
+  cameraUp: vec3<f32>,
+  _pad: f32,
+};
+
+@group(0) @binding(0) var<uniform> sprite: SpriteUniforms;
+@group(0) @binding(1) var<uniform> camera: CameraUniforms;
+@group(0) @binding(2) var spriteMap: texture_2d<f32>;
+@group(0) @binding(3) var spriteSampler: sampler;
+
+struct VertexInput {
+  @location(0) position: vec3<f32>,
+  @location(1) uv: vec2<f32>,
+};
+
+struct VertexOutput {
+  @builtin(position) clipPosition: vec4<f32>,
+  @location(0) uv: vec2<f32>,
+};
+
+@vertex
+fn vs_main(input: VertexInput) -> VertexOutput {
+  var output: VertexOutput;
+  let worldPos = vec4<f32>(
+    input.position + camera.cameraRight * (input.uv.x - 0.5) + camera.cameraUp * (input.uv.y - 0.5),
+    1.0,
+  );
+  output.clipPosition = camera.viewProj * worldPos;
+  output.uv = input.uv;
+  return output;
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  let texColor = textureSample(spriteMap, spriteSampler, input.uv);
+  return texColor * sprite.color;
+}

package/core/src/render/material-types/sss.wgsl

@@ -0,0 +1,79 @@
+// SSS material — subsurface scattering approximation with diffuse transmission
+// Forward-rendered, wraps PBR with subsurface color and transmittance
+
+struct SSSUniforms {
+  baseColor: vec4<f32>,
+  subsurfaceColor: vec3<f32>,
+  scatterRadius: f32,
+  transmittance: f32,
+};
+
+struct CameraUniforms {
+  viewProj: mat4x4<f32>,
+  cameraPos: vec3<f32>,
+  _pad: f32,
+};
+
+struct ModelUniforms {
+  model: mat4x4<f32>,
+  normalMatrix: mat4x4<f32>,
+};
+
+struct LightUniforms {
+  dirDirection: vec4<f32>,
+  dirColor: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> sss: SSSUniforms;
+@group(0) @binding(1) var<uniform> camera: CameraUniforms;
+@group(0) @binding(2) var<uniform> model: ModelUniforms;
+@group(0) @binding(3) var<uniform> lights: LightUniforms;
+@group(0) @binding(4) var albedoMap: texture_2d<f32>;
+@group(0) @binding(5) var texSampler: sampler;
+
+struct VertexInput {
+  @location(0) position: vec3<f32>,
+  @location(1) normal: vec3<f32>,
+  @location(2) uv: vec2<f32>,
+};
+
+struct VertexOutput {
+  @builtin(position) clipPosition: vec4<f32>,
+  @location(0) uv: vec2<f32>,
+  @location(1) worldNormal: vec3<f32>,
+  @location(2) worldPos: vec3<f32>,
+};
+
+@vertex
+fn vs_main(input: VertexInput) -> VertexOutput {
+  var output: VertexOutput;
+  let worldPos = model.model * vec4<f32>(input.position, 1.0);
+  output.clipPosition = camera.viewProj * worldPos;
+  output.uv = input.uv;
+  output.worldNormal = normalize((model.normalMatrix * vec4<f32>(input.normal, 0.0)).xyz);
+  output.worldPos = worldPos.xyz;
+  return output;
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  let N = normalize(input.worldNormal);
+  let V = normalize(camera.cameraPos - input.worldPos);
+  let L = normalize(-lights.dirDirection.xyz);
+
+  let albedo = textureSample(albedoMap, texSampler, input.uv).rgb * sss.baseColor.rgb;
+
+  let NdotL = max(dot(N, L), 0.0);
+  let diffuse = albedo * lights.dirColor.rgb * NdotL;
+
+  let backLight = max(dot(-N, L), 0.0);
+  let transmittanceLight = sss.subsurfaceColor * lights.dirColor.rgb * backLight * sss.transmittance;
+
+  let wrapLight = (dot(N, L) + sss.scatterRadius) / (1.0 + sss.scatterRadius);
+  let sssDiffuse = albedo * sss.subsurfaceColor * max(wrapLight, 0.0) * 0.5;
+
+  let ambient = albedo * 0.03;
+  let color = ambient + diffuse + transmittanceLight + sssDiffuse;
+
+  return vec4<f32>(color, sss.baseColor.a);
+}

package/core/src/render/material-types/toon.wgsl

@@ -0,0 +1,79 @@
+// Toon material — quantized diffuse bands with rim light and optional outline
+// Forward-rendered
+
+struct ToonUniforms {
+  baseColor: vec4<f32>,
+  stepCount: f32,
+  stepSmoothness: f32,
+  outlineWidth: f32,
+  rimColor: vec3<f32>,
+  rimPower: f32,
+};
+
+struct CameraUniforms {
+  viewProj: mat4x4<f32>,
+  cameraPos: vec3<f32>,
+  _pad: f32,
+};
+
+struct ModelUniforms {
+  model: mat4x4<f32>,
+  normalMatrix: mat4x4<f32>,
+};
+
+struct LightUniforms {
+  dirDirection: vec4<f32>,
+  dirColor: vec4<f32>,
+};
+
+@group(0) @binding(0) var<uniform> toon: ToonUniforms;
+@group(0) @binding(1) var<uniform> camera: CameraUniforms;
+@group(0) @binding(2) var<uniform> model: ModelUniforms;
+@group(0) @binding(3) var<uniform> lights: LightUniforms;
+@group(0) @binding(4) var albedoMap: texture_2d<f32>;
+@group(0) @binding(5) var albedoSampler: sampler;
+
+struct VertexInput {
+  @location(0) position: vec3<f32>,
+  @location(1) normal: vec3<f32>,
+  @location(2) uv: vec2<f32>,
+};
+
+struct VertexOutput {
+  @builtin(position) clipPosition: vec4<f32>,
+  @location(0) uv: vec2<f32>,
+  @location(1) normal: vec3<f32>,
+  @location(2) viewDir: vec3<f32>,
+};
+
+@vertex
+fn vs_main(input: VertexInput) -> VertexOutput {
+  var output: VertexOutput;
+  let worldPos = model.model * vec4<f32>(input.position, 1.0);
+  output.clipPosition = camera.viewProj * worldPos;
+  output.uv = input.uv;
+  output.normal = normalize((model.normalMatrix * vec4<f32>(input.normal, 0.0)).xyz);
+  output.viewDir = normalize(camera.cameraPos - worldPos.xyz);
+  return output;
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+  let N = normalize(input.normal);
+  let L = normalize(-lights.dirDirection.xyz);
+  let V = normalize(input.viewDir);
+
+  let NdotL = max(dot(N, L), 0.0);
+  let steps = max(toon.stepCount, 1.0);
+  let quantized = floor(NdotL * steps) / steps;
+  let smoothStep = mix(quantized, smoothstep(0.0, 1.0, NdotL), toon.stepSmoothness);
+
+  let albedo = textureSample(albedoMap, albedoSampler, input.uv).rgb * toon.baseColor.rgb;
+  let diffuse = albedo * lights.dirColor.rgb * smoothStep;
+
+  let rim = pow(1.0 - max(dot(N, V), 0.0), toon.rimPower);
+  let rimLight = toon.rimColor * rim;
+
+  let ambient = albedo * 0.3;
+  return vec4<f32>(ambient + diffuse + rimLight, toon.baseColor.a);
+}

package/core/src/render/passes/README.md

@@ -0,0 +1,121 @@
+# Render Passes
+
+This directory contains all render pass implementations (70 files). It is
+currently flat. The categorization below documents a **future migration** into
+subdirectories. Files should **not** be moved yet — doing so would break the
+many relative imports across the codebase. When the migration is performed,
+update all `./passes/<name>` import paths accordingly.
+
+## Proposed subdirectory layout
+
+### `passes/base/` — RenderPass base class & shared utilities
+Core abstractions that all other passes build on.
+
+| File | Description |
+|------|-------------|
+| (none currently — `render-pass.ts` lives in `../render-pass.ts`) | `RenderPass` base class |
+| `volumetric-types.ts` | Shared volumetric fog type definitions |
+| `gi-types.ts` | Shared global illumination (RSM/VPL) type definitions |
+
+### `passes/gbuffer/` — GBuffer & deferred lighting
+Passes related to the deferred rendering pipeline (GBuffer generation +
+deferred shading).
+
+| File | Description |
+|------|-------------|
+| `deferred-lighting.ts` | Deferred lighting pass (reads GBuffer) |
+| `depth-prepass.ts` | Depth pre-pass (z-prepass for deferred) |
+| `cluster-lighting-pass.ts` | Clustered deferred lighting pass |
+
+### `passes/postfx/` — Post-processing passes
+Screen-space and fullscreen post-processing effects.
+
+| File | Description |
+|------|-------------|
+| `highlight.ts` | Highlight/selection outline post-effect |
+| `glow.ts` | Selective bloom/glow pass |
+| `grain.ts` | Film grain post-effect |
+| `sharpen.ts` | Image sharpening pass |
+| `edges.ts` | Edge detection / toon outline pass |
+| `outline.ts` | Object outline post-effect |
+| `motion-blur.ts` | Camera/object motion blur |
+| `lens-flare.ts` | Lens flare post-effect |
+| `ssao.ts` | Screen-space ambient occlusion |
+| `ssr.ts` | Screen-space reflections |
+| `post-process.ts` | Generic post-process pass (tone mapping, etc.) |
+| `underwater-fog.ts` | Underwater fog post-effect |
+| `debug-viz.ts` | Debug visualization overlays |
+
+> **Note:** The unified `PostProcessStack` (21+ chainable effects), its WGSL
+> shaders, the `PostfxLib` engine-library descriptor, and the `LUT3D` color
+> grading effect have moved to the dedicated `@downdraft/engine/libraries/postfx`
+> package at `packages/engine/libraries/postfx/`. The standalone `lut3d.ts`
+> frame-graph pass has been removed in favor of the in-chain `lut` effect.
+
+### `passes/compute/` — Compute passes
+GPU compute shader passes (GPGPU).
+
+| File | Description |
+|------|-------------|
+| `graph-compute.ts` | Graph-based compute pass (node-authored compute shaders) |
+| `skinning.ts` | GPU skinning compute pass (`SkinningComputePass`) |
+| `skinning-vs.ts` | Vertex-shader skinning pass (compute-assisted) |
+| `procedural-texture.ts` | Procedural texture generation (compute) |
+
+### `passes/forward/` — Forward rendering passes
+Traditional forward-rendering passes (opaque, transparent, sky, etc.).
+
+| File | Description |
+|------|-------------|
+| `opaque.ts` | Opaque forward pass (main geometry pass) |
+| `transparent.ts` | Transparent/alpha-blended forward pass |
+| `skybox.ts` | Skybox rendering pass |
+| `sky-dome.ts` | Procedural sky dome pass |
+| `dome-360.ts` | 360° dome/environment pass |
+| `terrain.ts` | Terrain rendering pass |
+| `water.ts` | Water surface pass |
+| `clouds.ts` | Volumetric clouds pass |
+| `atmosphere.ts` | Atmospheric scattering pass |
+| `fluid-render.ts` | Fluid simulation render pass |
+
+### `passes/shadow/` — Shadow mapping passes
+(If a sixth subdirectory is desired; otherwise fold into `forward/`.)
+
+| File | Description |
+|------|-------------|
+| `shadow.ts` | Base shadow map pass |
+| `shadow-map.ts` | Shadow map system manager |
+| `csm.ts` | Cascaded shadow maps |
+| `point-light-shadow.ts` | Point light shadow cube maps |
+| `spot-light-shadow.ts` | Spot light shadow maps |
+
+### `passes/special/` — Specialized / miscellaneous passes
+(If a seventh subdirectory is desired; otherwise keep at top level.)
+
+| File | Description |
+|------|-------------|
+| `debug.ts` | Debug render pass (lines, points, text) |
+| `cubemap-capture.ts` | Cubemap capture pass (reflection probes) |
+| `reflection-probe.ts` | Reflection probe pass/types |
+| `rsm-pass.ts` | Reflective shadow map (RSM) pass for GI |
+| `volumetric-pass.ts` | Volumetric lighting/fog pass |
+| `sdf-text.ts` | SDF text rendering pass |
+| `ui-composite.ts` | UI composition pass |
+| `video-texture.ts` | Video texture source pass |
+| `decal-mesh.ts` | Decal mesh generation utilities |
+| `decal-pass.ts` | Decal rendering pass |
+| `greased-line-pass.ts` | Greased line rendering pass |
+| `morph-target.ts` | Morph target pass |
+
+## Migration notes
+
+1. **Import paths**: All passes are currently imported via `./passes/<name>`
+   from the render barrel and via `../passes/<name>` from sibling render files.
+   After moving, these paths become `./passes/<subdir>/<name>` and
+   `../passes/<subdir>/<name>` respectively.
+2. **Spec files**: Each `.spec.ts` file should move alongside its source file.
+3. **Barrel exports**: `packages/engine/core/src/render/index.ts` re-exports all
+   passes — update the paths there after migration.
+4. **Cross-pass imports**: Some passes import from sibling passes (e.g.
+   `post-process.ts` imports from `volumetric-types.ts`). Update these
+   relative paths after moving.

package/core/src/render/passes/atmosphere.ts

@@ -0,0 +1,152 @@
+import type { WgslStruct } from "@downdraft/engine/shader-graph";
+import { f32, u32, vec3f, wgsl } from "@downdraft/engine/shader-graph";
+
+export interface AtmosphereConfig {
+  planetRadius: number;
+  atmosphereRadius: number;
+  sunIntensity: number;
+  rayleighCoefficients: number[];
+  mieCoefficient: number;
+  mieDirectionG: number;
+  sunDirection: number[];
+  samples: number;
+}
+
+export const DEFAULT_ATMOSPHERE_CONFIG: AtmosphereConfig = {
+  planetRadius: 6371e3,
+  atmosphereRadius: 6471e3,
+  sunIntensity: 22.0,
+  rayleighCoefficients: [5.5e-6, 13.0e-6, 22.4e-6],
+  mieCoefficient: 21e-6,
+  mieDirectionG: 0.758,
+  sunDirection: [0, 1, 0],
+  samples: 16,
+};
+
+export function computeRayleighScattering(
+  wavelength: number[],
+  coefficients: number[],
+  density: number,
+): number[] {
+  return [
+    coefficients[0] * density,
+    coefficients[1] * density,
+    coefficients[2] * density,
+  ];
+}
+
+export function computeMieScattering(
+  coefficient: number,
+  density: number,
+): number {
+  return coefficient * density;
+}
+
+export function computeAtmosphereDensity(
+  altitude: number,
+  planetRadius: number,
+  atmosphereRadius: number,
+): number {
+  const height = altitude - planetRadius;
+  const atmosphereHeight = atmosphereRadius - planetRadius;
+  if (height < 0) return 1.0;
+  if (height > atmosphereHeight) return 0.0;
+  return Math.exp(-height / (atmosphereHeight * 0.25));
+}
+
+export function computeOpticalDepthRayleigh(
+  startAltitude: number,
+  endAltitude: number,
+  planetRadius: number,
+  atmosphereRadius: number,
+  samples: number,
+): number[] {
+  const depth: number[] = [0, 0, 0];
+  const stepAltitude = (endAltitude - startAltitude) / samples;
+  for (let i = 0; i < samples; i++) {
+    const alt = startAltitude + stepAltitude * (i + 0.5);
+    const density = computeAtmosphereDensity(alt, planetRadius, atmosphereRadius);
+    depth[0] += density * stepAltitude;
+    depth[1] += density * stepAltitude;
+    depth[2] += density * stepAltitude;
+  }
+  return depth;
+}
+
+export function computeSkyColor(
+  viewDir: number[],
+  sunDir: number[],
+  config: AtmosphereConfig,
+): number[] {
+  const cosTheta = viewDir[0] * sunDir[0] + viewDir[1] * sunDir[1] + viewDir[2] * sunDir[2];
+  const rayleigh = computeRayleighScattering(
+    config.rayleighCoefficients,
+    config.rayleighCoefficients,
+    1.0,
+  );
+
+  // Simplified sky color: Rayleigh phase * optical depth
+  const phase = (3.0 / (16.0 * Math.PI)) * (1.0 + cosTheta * cosTheta);
+  const intensity = config.sunIntensity * phase;
+
+  return [
+    intensity * rayleigh[0] * 1e6,
+    intensity * rayleigh[1] * 1e6,
+    intensity * rayleigh[2] * 1e6,
+  ];
+}
+
+const AtmosphereUniforms: WgslStruct = wgsl.struct("AtmosphereUniforms", {
+  planetRadius: f32,
+  atmosphereRadius: f32,
+  sunIntensity: f32,
+  mieG: f32,
+  rayleighCoeffs: vec3f,
+  mieCoefficient: f32,
+  sunDirection: vec3f,
+  samples: u32,
+});
+
+export const ATMOSPHERE_SHADER_CHUNK = /* wgsl */ `
+${AtmosphereUniforms.wgsl}
+
+fn atmosphereDensity(altitude: f32, planetRadius: f32, atmosphereRadius: f32) -> f32 {
+  let height = altitude - planetRadius;
+  let atmosphereHeight = atmosphereRadius - planetRadius;
+  if (height < 0.0) { return 1.0; }
+  if (height > atmosphereHeight) { return 0.0; }
+  return exp(-height / (atmosphereHeight * 0.25));
+}
+
+fn rayleighPhase(cosTheta: f32) -> f32 {
+  return (3.0 / (16.0 * 3.14159265)) * (1.0 + cosTheta * cosTheta);
+}
+
+fn miePhase(cosTheta: f32, g: f32) -> f32 {
+  let g2 = g * g;
+  let denom = 1.0 + g2 - 2.0 * g * cosTheta;
+  return (3.0 * (1.0 - g2)) / (8.0 * 3.14159265 * denom * sqrt(max(denom, 0.0001)));
+}
+
+fn computeAtmosphereColor(
+  rayOrigin: vec3<f32>,
+  rayDir: vec3<f32>,
+  sunDir: vec3<f32>,
+  uniforms: AtmosphereUniforms,
+) -> vec3<f32> {
+  // Simplified atmospheric scattering
+  let cosTheta = dot(rayDir, sunDir);
+  let rayleighPhaseVal = rayleighPhase(cosTheta);
+  let miePhaseVal = miePhase(cosTheta, uniforms.mieG);
+
+  // Approximate optical depth based on view direction
+  let upDot = max(rayDir.y, 0.0);
+  let opticalDepth = 1.0 / (upDot + 0.1);
+
+  let rayleighColor = uniforms.rayleighCoeffs * rayleighPhaseVal * opticalDepth;
+  let mieColor = uniforms.mieCoefficient * miePhaseVal * opticalDepth;
+
+  let color = (rayleighColor + vec3<f32>(mieColor)) * uniforms.sunIntensity;
+  return color;
+}
+`;