@downdraft/engine 0.1.0 → 0.1.2-alpha.5

package/dist/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/dist/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/dist/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/dist/core/src/render/passes/atmosphere.js

@@ -0,0 +1,107 @@
+import { f32, u32, vec3f, wgsl } from "@downdraft/engine/shader-graph";
+export const DEFAULT_ATMOSPHERE_CONFIG = {
+    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, coefficients, density) {
+    return [
+        coefficients[0] * density,
+        coefficients[1] * density,
+        coefficients[2] * density,
+    ];
+}
+export function computeMieScattering(coefficient, density) {
+    return coefficient * density;
+}
+export function computeAtmosphereDensity(altitude, planetRadius, atmosphereRadius) {
+    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, endAltitude, planetRadius, atmosphereRadius, samples) {
+    const depth = [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, sunDir, config) {
+    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 = 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;
+}
+`;