@multiplekex/shallot 0.2.4 → 0.3.0

package/src/standard/render/surface/index.ts

@@ -1,10 +1,11 @@
 import { MAX_ENTITIES } from "../../../core";
 import { setTraits } from "../../../core/component";
+import { WGSL_STRUCTS } from "./structs";
+import { compileVertexBody, WGSL_LIGHTING_CALC, SPECULAR_WGSL } from "./shaders";
 
 export interface SurfaceData {
     vertex?: string;
     fragment?: string;
-    lit?: boolean;
 }
 
 interface ComposedSurface extends SurfaceData {
@@ -21,23 +22,28 @@ export function createSurfaceRegistry(): SurfaceRegistry {
     return registry;
 }
 
+const surfaceNames = new Map<string, number>();
+
 function initBuiltIns(registry: SurfaceRegistry): void {
-    registry.surfaces.push({ lit: true });
+    registry.surfaces.push({});
 
     registry.surfaces.push({
-        lit: false,
         fragment: `(*surface).baseColor = (*surface).normal * 0.5 + 0.5;`,
     });
 
     registry.surfaces.push({
-        lit: false,
         fragment: `
     let depth = position.z;
     let remapped = pow(1.0 - depth, 0.1);
     (*surface).baseColor = vec3(remapped);`,
     });
 
-    registry.surfaces.push({ lit: false });
+    registry.surfaces.push({});
+
+    surfaceNames.set("default", 0);
+    surfaceNames.set("normals", 1);
+    surfaceNames.set("depth", 2);
+    surfaceNames.set("albedo", 3);
 }
 
 export const SurfaceType = {
@@ -73,14 +79,11 @@ export function composeSurfaces(registry: SurfaceRegistry, ...ids: number[]): nu
 
     const vertexParts: string[] = [];
     const fragmentParts: string[] = [];
-    let lit = true;
 
     for (const id of validIds) {
         const s = registry.surfaces[id];
         if (!s) continue;
 
-        if (s.lit === false) lit = false;
-
         if ("composed" in s) {
             for (const composedId of s.composed) {
                 const inner = registry.surfaces[composedId];
@@ -96,7 +99,6 @@ export function composeSurfaces(registry: SurfaceRegistry, ...ids: number[]): nu
     const composedData: ComposedSurface = {
         vertex: vertexParts.length > 0 ? vertexParts.join("\n    ") : undefined,
         fragment: fragmentParts.length > 0 ? fragmentParts.join("\n    ") : undefined,
-        lit,
         composed: validIds,
     };
 
@@ -107,8 +109,14 @@ export function composeSurfaces(registry: SurfaceRegistry, ...ids: number[]): nu
 
 const defaultRegistry = createSurfaceRegistry();
 
-export function surface(data: SurfaceData): number {
-    return registerSurface(defaultRegistry, data);
+export function surface(data: SurfaceData, name?: string): number {
+    const id = registerSurface(defaultRegistry, data);
+    if (name) surfaceNames.set(name, id);
+    return id;
+}
+
+export function getSurfaceByName(name: string): number | undefined {
+    return surfaceNames.get(name);
 }
 
 export function getDefaultSurface(id: number): SurfaceData | undefined {
@@ -120,6 +128,7 @@ export function getDefaultAllSurfaces(): SurfaceData[] {
 }
 
 export function clearDefaultSurfaces(): void {
+    surfaceNames.clear();
     clearSurfaces(defaultRegistry);
 }
 
@@ -141,6 +150,66 @@ setTraits(Surface, {
     defaults: () => ({
         type: SurfaceType.Default,
     }),
+    parse: { type: getSurfaceByName },
 });
 
-export { compileSurface } from "./compile";
+export function compileSurface(data: SurfaceData): string {
+    const vertexTransform = compileVertexBody(data.vertex);
+
+    const fragmentBody = data.fragment ?? "";
+
+    return /* wgsl */ `
+${WGSL_STRUCTS}
+${SPECULAR_WGSL}
+
+fn userVertexTransform(worldPos: vec3<f32>, normal: vec3<f32>, eid: u32) -> vec3<f32> {
+    ${vertexTransform}
+}
+
+fn userFragment(surface: ptr<function, SurfaceData>, position: vec4<f32>) {
+    ${fragmentBody}
+}
+
+@vertex
+fn vs(input: VertexInput) -> VertexOutput {
+    let eid = entityIds[input.instance];
+    let world = matrices[eid];
+    let scaledPos = input.position * sizes[eid].xyz;
+    let baseWorldPos = (world * vec4<f32>(scaledPos, 1.0)).xyz;
+    let worldNormal = normalize((world * vec4<f32>(input.normal, 0.0)).xyz);
+    let finalWorldPos = userVertexTransform(baseWorldPos, worldNormal, eid);
+
+    var output: VertexOutput;
+    output.position = scene.viewProj * vec4<f32>(finalWorldPos, 1.0);
+    output.color = data[eid].baseColor;
+    output.worldNormal = worldNormal;
+    output.entityId = eid;
+    output.worldPos = finalWorldPos;
+    return output;
+}
+
+@fragment
+fn fs(input: VertexOutput) -> FragmentOutput {
+    let eid = input.entityId;
+    let d = data[eid];
+
+    var surface: SurfaceData;
+    surface.baseColor = input.color.rgb;
+    surface.roughness = d.pbr.x;
+    surface.metallic = d.pbr.y;
+    surface.emission = d.emission.rgb * d.emission.a;
+    surface.normal = normalize(input.worldNormal);
+    surface.worldPos = input.worldPos;
+
+    userFragment(&surface, input.position);
+
+    let shadowFactor = 1.0;
+    ${WGSL_LIGHTING_CALC}
+
+    var output: FragmentOutput;
+    output.color = vec4<f32>(litColor, input.color.a);
+    output.entityId = input.entityId;
+    return output;
+}
+`;
+}

package/src/standard/render/surface/shaders.ts

@@ -0,0 +1,511 @@
+export function compileVertexBody(vertex?: string): string {
+    return vertex
+        ? `var pos = worldPos;
+    ${vertex}
+    return pos;`
+        : "return worldPos;";
+}
+
+const STARS_WGSL = /* wgsl */ `
+fn hashStar(p: vec2<f32>) -> f32 {
+    var p3 = fract(vec3(p.x, p.y, p.x) * 0.1031);
+    p3 += dot(p3, p3.yzx + 33.33);
+    return fract((p3.x + p3.y) * p3.z);
+}
+
+fn hash2Star(p: vec2<f32>) -> vec2<f32> {
+    var p3 = fract(vec3(p.x, p.y, p.x) * vec3(0.1031, 0.1030, 0.0973));
+    p3 += dot(p3, p3.yzx + 33.33);
+    return fract((p3.xx + p3.yz) * p3.zy);
+}
+
+fn sampleStars(dir: vec3<f32>) -> vec3<f32> {
+    if (sky.starParams.z <= 0.0 || dir.y < 0.0) {
+        return vec3(0.0);
+    }
+
+    let theta = atan2(dir.z, dir.x);
+    let phi = asin(clamp(dir.y, -1.0, 1.0));
+
+    let gridSize = mix(20.0, 100.0, sky.starParams.y);
+    let cell = vec2(theta * gridSize / 3.14159, phi * gridSize / 1.5708);
+    let cellId = floor(cell);
+    let cellFract = fract(cell);
+
+    var starColor = vec3(0.0);
+
+    for (var dy = -1; dy <= 1; dy++) {
+        for (var dx = -1; dx <= 1; dx++) {
+            let neighbor = cellId + vec2(f32(dx), f32(dy));
+            let starHash = hashStar(neighbor);
+
+            if (starHash > sky.starParams.y * 0.7) {
+                continue;
+            }
+
+            let starPos = hash2Star(neighbor);
+            let starCenter = neighbor + starPos;
+            let dist = length(cell - starCenter);
+
+            let brightness = hashStar(neighbor + vec2(100.0, 100.0));
+            let radius = 0.02 + brightness * 0.03;
+
+            if (dist < radius) {
+                let twinkle = 0.8 + 0.2 * sin(brightness * 100.0);
+                let intensity = sky.starParams.x * brightness * twinkle;
+                let falloff = 1.0 - smoothstep(0.0, radius, dist);
+
+                let temp = hashStar(neighbor + vec2(200.0, 200.0));
+                let tint = mix(vec3(1.0, 0.9, 0.8), vec3(0.8, 0.9, 1.0), temp);
+
+                starColor = max(starColor, tint * intensity * falloff);
+            }
+        }
+    }
+
+    return starColor;
+}
+`;
+
+export const NOISE_WGSL = /* wgsl */ `
+fn hash2(p: vec2<f32>) -> f32 {
+    var p3 = fract(vec3(p.x, p.y, p.x) * 0.1031);
+    p3 += dot(p3, p3.yzx + 33.33);
+    return fract((p3.x + p3.y) * p3.z);
+}
+
+fn value2d(p: vec2f, seed: vec2f) -> f32 {
+    let i = floor(p);
+    let f = fract(p);
+    let u = f * f * (3.0 - 2.0 * f);
+    return mix(
+        mix(fract(sin(dot(i, seed)) * 43758.5) * 2.0 - 1.0,
+            fract(sin(dot(i + vec2(1.0, 0.0), seed)) * 43758.5) * 2.0 - 1.0, u.x),
+        mix(fract(sin(dot(i + vec2(0.0, 1.0), seed)) * 43758.5) * 2.0 - 1.0,
+            fract(sin(dot(i + vec2(1.0, 1.0), seed)) * 43758.5) * 2.0 - 1.0, u.x), u.y);
+}
+
+fn simplex2(p: vec2<f32>) -> f32 {
+    let K1 = 0.366025404;
+    let K2 = 0.211324865;
+
+    let i = floor(p + (p.x + p.y) * K1);
+    let a = p - i + (i.x + i.y) * K2;
+
+    let o = select(vec2(0.0, 1.0), vec2(1.0, 0.0), a.x > a.y);
+    let b = a - o + K2;
+    let c = a - 1.0 + 2.0 * K2;
+
+    let h = max(0.5 - vec3(dot(a, a), dot(b, b), dot(c, c)), vec3(0.0));
+    let h4 = h * h * h * h;
+
+    let n = vec3(
+        dot(a, vec2(hash2(i) * 2.0 - 1.0, hash2(i + vec2(0.0, 1.0)) * 2.0 - 1.0)),
+        dot(b, vec2(hash2(i + o) * 2.0 - 1.0, hash2(i + o + vec2(0.0, 1.0)) * 2.0 - 1.0)),
+        dot(c, vec2(hash2(i + 1.0) * 2.0 - 1.0, hash2(i + vec2(1.0, 2.0)) * 2.0 - 1.0))
+    );
+
+    return dot(h4, n) * 70.0;
+}
+
+const FBM2_OCTAVES = 5;
+
+fn fbm2(p: vec2<f32>) -> f32 {
+    var value = 0.0;
+    var amplitude = 0.5;
+    var frequency = 1.0;
+    var pos = p;
+
+    for (var i = 0; i < FBM2_OCTAVES; i++) {
+        value += amplitude * simplex2(pos * frequency);
+        amplitude *= 0.5;
+        frequency *= 2.0;
+    }
+
+    return value;
+}
+`;
+
+const MOON_WGSL = /* wgsl */ `
+fn sampleMoon(dir: vec3<f32>) -> vec3<f32> {
+    if (sky.moonParams.z <= 0.0) {
+        return vec3(0.0);
+    }
+
+    let moonDir = sky.moonDirection.xyz;
+    let moonDot = dot(dir, moonDir);
+
+    let moonSize = 0.9995;
+    let moonColor = vec3(0.9, 0.9, 0.85);
+    let edgeWidth = 0.0003;
+    let glowStart = 0.999;
+
+    if (moonDot > moonSize - edgeWidth) {
+        let toCenter = dir - moonDir * moonDot;
+        let diskRight = normalize(cross(moonDir, vec3(0.0, 1.0, 0.0)));
+        let diskUp = cross(diskRight, moonDir);
+
+        let diskRadius = sqrt(1.0 - moonSize * moonSize);
+        let u = dot(toCenter, diskRight) / diskRadius;
+        let v = dot(toCenter, diskUp) / diskRadius;
+
+        let r2 = u * u + v * v;
+        let z = sqrt(max(0.0, 1.0 - r2));
+
+        let diskEdge = smoothstep(1.0 + edgeWidth / diskRadius, 1.0 - edgeWidth / diskRadius, sqrt(r2));
+
+        let limb = pow(z, 0.6);
+
+        let cellU = u * 8.0;
+        let cellV = v * 8.0;
+        let craterNoise = hashStar(floor(vec2(cellU, cellV)) + vec2(50.0, 50.0));
+        let surfaceVariation = 0.85 + 0.15 * craterNoise;
+
+        let phase = sky.moonParams.x;
+        let sunAngle = phase * 6.28318;
+        let sunLocalX = sin(sunAngle);
+        let sunLocalZ = -cos(sunAngle);
+
+        let illumination = u * sunLocalX + z * sunLocalZ;
+        let lit = smoothstep(-0.05, 0.05, illumination);
+
+        let earthshine = vec3(0.06, 0.07, 0.1);
+        let dayColor = moonColor * surfaceVariation * limb;
+        let surfaceColor = mix(earthshine * limb, dayColor, lit);
+
+        return surfaceColor * diskEdge * smoothstep(0.15, 0.3, sky.moonParams.y);
+    } else {
+        let glowFalloff = max(0.0, moonDot - glowStart) / (moonSize - edgeWidth - glowStart);
+        let glow = pow(glowFalloff, 2.0) * sky.moonParams.y;
+        return moonColor * glow * 0.3;
+    }
+}
+`;
+
+const CLOUDS_WGSL = /* wgsl */ `
+fn sampleClouds(dir: vec3<f32>) -> vec4<f32> {
+    if (sky.cloudParams.w <= 0.0 || dir.y < 0.01) {
+        return vec4(0.0);
+    }
+
+    let t = sky.cloudParams.z / max(dir.y, 0.001);
+    let uv = dir.xz * t;
+
+    var n = fbm2(uv);
+
+    let coverage = sky.cloudParams.x;
+    let density = sky.cloudParams.y;
+    n = smoothstep(1.0 - coverage, 1.0, n * 0.5 + 0.5) * density;
+
+    n *= smoothstep(0.0, 0.15, dir.y);
+
+    return vec4(sky.cloudColor.rgb, n);
+}
+`;
+
+export const SKY_DIR_WGSL = /* wgsl */ `
+const DEG_TO_RAD: f32 = 0.017453292;
+
+fn computeSkyDir(screenX: f32, screenY: f32) -> vec3<f32> {
+    let width = scene.viewport.x;
+    let height = scene.viewport.y;
+
+    let ndcX = screenX * 2.0 - 1.0;
+    let ndcY = 1.0 - screenY * 2.0;
+
+    let aspect = width / height;
+
+    let cameraWorld = scene.cameraWorld;
+    let r00 = cameraWorld[0][0]; let r10 = cameraWorld[0][1]; let r20 = cameraWorld[0][2];
+    let r01 = cameraWorld[1][0]; let r11 = cameraWorld[1][1]; let r21 = cameraWorld[1][2];
+    let r02 = cameraWorld[2][0]; let r12 = cameraWorld[2][1]; let r22 = cameraWorld[2][2];
+
+    let skyFov = select(scene.fov, 60.0, scene.cameraMode > 0.5);
+    let tanHalfFov = tan((skyFov * DEG_TO_RAD) / 2.0);
+    let camDirX = ndcX * aspect * tanHalfFov;
+    let camDirY = ndcY * tanHalfFov;
+    let camDirZ = -1.0;
+    var dirX = r00 * camDirX + r01 * camDirY + r02 * camDirZ;
+    var dirY = r10 * camDirX + r11 * camDirY + r12 * camDirZ;
+    var dirZ = r20 * camDirX + r21 * camDirY + r22 * camDirZ;
+    let len = sqrt(dirX * dirX + dirY * dirY + dirZ * dirZ);
+    dirX /= len; dirY /= len; dirZ /= len;
+    return vec3(dirX, dirY, dirZ);
+}
+`;
+
+export const SKY_WGSL = /* wgsl */ `
+${STARS_WGSL}
+${MOON_WGSL}
+${CLOUDS_WGSL}
+
+fn sampleSky(dir: vec3<f32>) -> vec3<f32> {
+    if (sky.skyZenith.a <= 0.0) {
+        return scene.clearColor.rgb;
+    }
+
+    let t = pow(clamp(dir.y, 0.0, 1.0), 0.25);
+    var color = mix(sky.skyHorizon.rgb, sky.skyZenith.rgb, t);
+
+    let horizonBand = 1.0 - abs(dir.y);
+    let horizonBlend = pow(horizonBand, 32.0);
+    color = mix(color, vec3(1.09), horizonBlend);
+
+    color += sampleStars(dir);
+
+    let clouds = sampleClouds(dir);
+    color = mix(color, clouds.rgb, clouds.a);
+
+    let moonContrib = sampleMoon(dir);
+    color += moonContrib * (1.0 - clouds.a * 0.7);
+
+    let sunDir = -scene.sunDirection.xyz;
+    let sunDot = dot(dir, sunDir);
+
+    let sunVisualColor = select(scene.sunColor.rgb, sky.sunVisualColor.rgb, sky.sunParams.z > 0.5);
+
+    let glowParam = sky.sunParams.y;
+
+    let baseSunSize = 0.9995;
+    let sunSizeParam = sky.sunParams.x;
+    let sunThreshold = 1.0 - (1.0 - baseSunSize) * sunSizeParam;
+    let sunEdgeWidth = (1.0 - sunThreshold) * 0.15;
+
+    let diskBlend = smoothstep(sunThreshold - sunEdgeWidth, sunThreshold + sunEdgeWidth, sunDot);
+    if (diskBlend > 0.0 && glowParam > 0.0) {
+        let radial = saturate((sunDot - sunThreshold) / (1.0 - sunThreshold));
+        let limbDarken = mix(0.7, 1.0, pow(radial, 0.5));
+        color += sunVisualColor * limbDarken * diskBlend * smoothstep(0.0, 0.3, glowParam);
+    }
+
+    let glow = max(0.0, sunDot);
+    let innerGlow = pow(glow, 32.0) * glowParam * 1.5;
+    let outerGlow = pow(glow, 3.0) * glowParam * 0.15;
+    color += sunVisualColor * (innerGlow + outerGlow);
+
+    if (sky.hazeDensity > 0.0) {
+        let horizonFactor = 1.0 - clamp(dir.y, 0.0, 1.0);
+        let hazeAmount = pow(horizonFactor, 2.0) * saturate(sky.hazeDensity * 5.0);
+        color = mix(color, sky.hazeColor.rgb, hazeAmount);
+    }
+
+    return color;
+}
+`;
+
+export const HAZE_WGSL = /* wgsl */ `
+fn applyHaze(color: vec3<f32>, dist: f32) -> vec3<f32> {
+    if (sky.hazeDensity <= 0.0) {
+        return color;
+    }
+    let haze = 1.0 - exp(-sky.hazeDensity * dist);
+    return mix(color, sky.hazeColor.rgb, haze);
+}
+`;
+
+export const SHADOW_SAMPLE_WGSL = /* wgsl */ `
+const GOLDEN_ANGLE: f32 = 2.399963229728653;
+const CASCADE_BLEND_RANGE: f32 = 0.1;
+
+fn selectCascade(viewZ: f32) -> u32 {
+    if (viewZ < shadow.cascadeSplits.x) { return 0u; }
+    if (viewZ < shadow.cascadeSplits.y) { return 1u; }
+    if (viewZ < shadow.cascadeSplits.z) { return 2u; }
+    return 3u;
+}
+
+fn getCascadeViewProj(cascade: u32) -> mat4x4<f32> {
+    switch cascade {
+        case 0u: { return shadow.cascade0ViewProj; }
+        case 1u: { return shadow.cascade1ViewProj; }
+        case 2u: { return shadow.cascade2ViewProj; }
+        default: { return shadow.cascade3ViewProj; }
+    }
+}
+
+fn getCascadeTexelSize(cascade: u32) -> f32 {
+    switch cascade {
+        case 0u: { return shadow.cascadeTexelSizes.x; }
+        case 1u: { return shadow.cascadeTexelSizes.y; }
+        case 2u: { return shadow.cascadeTexelSizes.z; }
+        default: { return shadow.cascadeTexelSizes.w; }
+    }
+}
+
+fn getCascadeSplit(cascade: u32) -> f32 {
+    switch cascade {
+        case 0u: { return shadow.cascadeSplits.x; }
+        case 1u: { return shadow.cascadeSplits.y; }
+        case 2u: { return shadow.cascadeSplits.z; }
+        default: { return shadow.cascadeSplits.w; }
+    }
+}
+
+fn computeShadowBias(cascade: u32, NdotL: f32) -> f32 {
+    let baseBias = 0.0001 + f32(cascade) * 0.00005;
+    let clampedNdotL = max(NdotL, 0.01);
+    let slopeBias = baseBias * sqrt(1.0 - clampedNdotL * clampedNdotL) / clampedNdotL;
+    return baseBias + min(slopeBias, baseBias * 5.0);
+}
+
+fn computeNormalOffset(normal: vec3<f32>, lightDir: vec3<f32>, cascade: u32) -> vec3<f32> {
+    let NdotL = abs(dot(normal, lightDir));
+    let texelSize = getCascadeTexelSize(cascade);
+    let slopeScale = saturate(1.0 - NdotL);
+    return normal * texelSize * (1.0 + slopeScale * 2.0);
+}
+
+fn sampleShadowAtCascadeWithBias(worldPos: vec3<f32>, cascade: u32, bias: f32) -> f32 {
+    let lightPos = getCascadeViewProj(cascade) * vec4(worldPos, 1.0);
+    let ndc = lightPos.xyz / lightPos.w;
+
+    let inBounds = abs(ndc.x) <= 1.0 && abs(ndc.y) <= 1.0 && ndc.z >= 0.0 && ndc.z <= 1.0;
+
+    let safeNdc = clamp(ndc, vec3(-1.0, -1.0, 0.0), vec3(1.0, 1.0, 1.0));
+    var uv = safeNdc.xy * 0.5 + 0.5;
+    uv.y = 1.0 - uv.y;
+
+    let offset = vec2(f32(cascade % 2u) * 0.5, f32(cascade / 2u) * 0.5);
+    uv = uv * 0.5 + offset;
+
+    let sampled = textureSampleCompare(shadowMap, shadowSampler, uv, safeNdc.z - bias);
+    return select(1.0, sampled, inBounds);
+}
+
+fn sampleShadowOffsetWithBias(worldPos: vec3<f32>, cascade: u32, uvOffset: vec2<f32>, bias: f32) -> f32 {
+    let lightPos = getCascadeViewProj(cascade) * vec4(worldPos, 1.0);
+    let ndc = lightPos.xyz / lightPos.w;
+
+    let inBounds = abs(ndc.x) <= 1.0 && abs(ndc.y) <= 1.0 && ndc.z >= 0.0 && ndc.z <= 1.0;
+
+    let safeNdc = clamp(ndc, vec3(-1.0, -1.0, 0.0), vec3(1.0, 1.0, 1.0));
+    var uv = safeNdc.xy * 0.5 + 0.5;
+    uv.y = 1.0 - uv.y;
+
+    let cascadeOffset = vec2(f32(cascade % 2u) * 0.5, f32(cascade / 2u) * 0.5);
+    uv = uv * 0.5 + cascadeOffset + uvOffset;
+
+    let sampled = textureSampleCompare(shadowMap, shadowSampler, uv, safeNdc.z - bias);
+    return select(1.0, sampled, inBounds);
+}
+
+fn vogelDiskSample(sampleIndex: u32, samplesCount: u32, rotation: f32) -> vec2<f32> {
+    let angle = GOLDEN_ANGLE * f32(sampleIndex) + rotation;
+    let radius = sqrt((f32(sampleIndex) + 0.5) / f32(samplesCount));
+    return vec2(cos(angle), sin(angle)) * radius;
+}
+
+fn sampleShadowPCFAtCascade(worldPos: vec3<f32>, cascade: u32, softness: f32, samples: u32, bias: f32) -> f32 {
+    let atlasTexelSize = 1.0 / 2048.0;
+    var total = 0.0;
+
+    for (var i = 0u; i < samples; i++) {
+        let disk = vogelDiskSample(i, samples, 0.0);
+        let uvOffset = disk * softness * atlasTexelSize * 4.0;
+        total += sampleShadowOffsetWithBias(worldPos, cascade, uvOffset, bias);
+    }
+    return total / f32(samples);
+}
+
+fn computeCascadeBlend(viewZ: f32, cascade: u32) -> f32 {
+    if (cascade >= 3u) { return 0.0; }
+
+    let splitEnd = getCascadeSplit(cascade);
+    let blendStart = splitEnd * (1.0 - CASCADE_BLEND_RANGE);
+
+    if (viewZ < blendStart) { return 0.0; }
+    return saturate((viewZ - blendStart) / (splitEnd - blendStart));
+}
+
+fn distanceFade(viewZ: f32, maxDist: f32) -> f32 {
+    let fadeStart = maxDist * 0.9;
+    let fade = saturate((maxDist - viewZ) / (maxDist - fadeStart));
+    return select(fade, 1.0, viewZ <= fadeStart);
+}
+
+fn sampleShadow(worldPos: vec3<f32>, normal: vec3<f32>, viewZ: f32) -> f32 {
+    let lightDir = -scene.sunDirection.xyz;
+    let NdotL = max(dot(normal, lightDir), 0.0);
+
+    let cascade = selectCascade(viewZ);
+    let offset = computeNormalOffset(normal, lightDir, cascade);
+    let offsetPos = worldPos + offset;
+    let bias = computeShadowBias(cascade, NdotL);
+    let shadowCurrent = sampleShadowAtCascadeWithBias(offsetPos, cascade, bias);
+
+    let nextCascade = min(cascade + 1u, 3u);
+    let nextOffset = computeNormalOffset(normal, lightDir, nextCascade);
+    let nextOffsetPos = worldPos + nextOffset;
+    let nextBias = computeShadowBias(nextCascade, NdotL);
+    let shadowNext = sampleShadowAtCascadeWithBias(nextOffsetPos, nextCascade, nextBias);
+
+    let blendFactor = computeCascadeBlend(viewZ, cascade) * f32(cascade < 3u);
+    let cascadeShadow = mix(shadowCurrent, shadowNext, blendFactor);
+
+    let fade = distanceFade(viewZ, shadow.cascadeSplits.w);
+    return mix(1.0, cascadeShadow, fade);
+}
+
+fn sampleShadowPCF(worldPos: vec3<f32>, normal: vec3<f32>, viewZ: f32, softness: f32, samples: u32) -> f32 {
+    if (softness <= 0.0) {
+        return sampleShadow(worldPos, normal, viewZ);
+    }
+
+    let lightDir = -scene.sunDirection.xyz;
+    let NdotL = max(dot(normal, lightDir), 0.0);
+
+    let cascade = selectCascade(viewZ);
+    let offset = computeNormalOffset(normal, lightDir, cascade);
+    let offsetPos = worldPos + offset;
+    let bias = computeShadowBias(cascade, NdotL);
+    let shadowCurrent = sampleShadowPCFAtCascade(offsetPos, cascade, softness, samples, bias);
+
+    let nextCascade = min(cascade + 1u, 3u);
+    let nextOffset = computeNormalOffset(normal, lightDir, nextCascade);
+    let nextOffsetPos = worldPos + nextOffset;
+    let nextBias = computeShadowBias(nextCascade, NdotL);
+    let shadowNext = sampleShadowPCFAtCascade(nextOffsetPos, nextCascade, softness, samples, nextBias);
+
+    let blendFactor = computeCascadeBlend(viewZ, cascade) * f32(cascade < 3u);
+    let cascadeShadow = mix(shadowCurrent, shadowNext, blendFactor);
+
+    let fade = distanceFade(viewZ, shadow.cascadeSplits.w);
+    return mix(1.0, cascadeShadow, fade);
+}
+`;
+
+export const SPECULAR_WGSL = /* wgsl */ `
+const DIELECTRIC_F0: f32 = 0.04;
+
+fn blinnPhongSpecular(N: vec3<f32>, L: vec3<f32>, V: vec3<f32>, roughness: f32) -> f32 {
+    let H = normalize(L + V);
+    let NdotH = max(dot(N, H), 0.0);
+    let shininess = pow(2.0, (1.0 - roughness) * 10.0);
+    let intensity = (1.0 - roughness) * (1.0 - roughness);
+    return pow(NdotH, shininess) * intensity;
+}
+
+fn schlickFresnel(cosTheta: f32, F0: vec3<f32>) -> vec3<f32> {
+    return F0 + (vec3(1.0) - F0) * pow(1.0 - cosTheta, 5.0);
+}
+
+fn computeF0Vec(baseColor: vec3<f32>, metallic: f32) -> vec3<f32> {
+    return mix(vec3(DIELECTRIC_F0), baseColor, metallic);
+}
+`;
+
+export const WGSL_LIGHTING_CALC = /* wgsl */ `
+let V = normalize(scene.cameraWorld[3].xyz - surface.worldPos);
+let L = -scene.sunDirection.xyz;
+let NdotL = max(dot(surface.normal, L), 0.0);
+let NdotV = max(dot(surface.normal, V), 0.0);
+let F0 = computeF0Vec(surface.baseColor, surface.metallic);
+let F = schlickFresnel(NdotV, F0);
+let diffuseWeight = 1.0 - surface.metallic;
+let ambient = scene.ambientColor.rgb * scene.ambientColor.a;
+let sunDiffuse = scene.sunColor.rgb * NdotL * shadowFactor;
+let diffuseColor = surface.baseColor * (ambient + sunDiffuse) * diffuseWeight + surface.emission;
+let specTerm = blinnPhongSpecular(surface.normal, L, V, surface.roughness);
+let specular = scene.sunColor.rgb * specTerm * F * NdotL * shadowFactor;
+let litColor = diffuseColor + specular;
+`;