topazcube 0.1.33 → 0.1.35

package/src/renderer/rendering/shaders/particle_render.wgsl

@@ -85,7 +85,8 @@ struct ParticleUniforms {
     fogAlphas: vec3f,     // [nearAlpha, midAlpha, farAlpha]
     fogPad1: f32,
     fogHeightFade: vec2f, // [bottomY, topY]
-    fogPad2: vec2f,
+    fogDebug: f32,        // 0 = off, 2 = show distance
+    fogPad2: f32,
 }
 
 struct CascadeMatrices {
@@ -101,6 +102,7 @@ struct VertexOutput {
     @location(4) lighting: vec3f,   // Pre-computed lighting from particle
     @location(5) @interpolate(flat) emitterIdx: u32,  // For per-emitter settings
     @location(6) worldPos: vec3f,   // For fog height fade
+    @location(7) @interpolate(flat) centerViewZ: f32,  // View-space Z of particle center (for fog)
 }
 
 @group(0) @binding(0) var<uniform> uniforms: ParticleUniforms;
@@ -174,6 +176,7 @@ fn vertexMain(
         output.linearDepth = 0.0;
         output.lighting = vec3f(0.0);
         output.worldPos = vec3f(0.0);
+        output.centerViewZ = 0.0;
         return output;
     }
 
@@ -181,6 +184,7 @@ fn vertexMain(
     // uniforms.blendMode: 1.0 = additive, 0.0 = alpha
     let particleIsAdditive = (particle.flags & 2u) != 0u;
     let renderingAdditive = uniforms.blendMode > 0.5;
+
     if (particleIsAdditive != renderingAdditive) {
         // Wrong blend mode for this pass - skip
         output.position = vec4f(0.0, 0.0, 0.0, 0.0);
@@ -190,6 +194,7 @@ fn vertexMain(
         output.linearDepth = 0.0;
         output.lighting = vec3f(0.0);
         output.worldPos = vec3f(0.0);
+        output.centerViewZ = 0.0;
         return output;
     }
 
@@ -236,9 +241,14 @@ fn vertexMain(
     // Pass through particle color
     output.color = particle.color;
 
-    // Pass world position for fog
+    // Pass world position for fog height
     output.worldPos = particleWorldPos;
 
+    // Use the billboard's viewZ for fog distance
+    // This matches scene fog which uses view-space Z (linear depth)
+    // The billboard viewZ is already calculated correctly: -viewPos.z
+    output.centerViewZ = output.viewZ;
+
     return output;
 }
 
@@ -464,6 +474,56 @@ fn calcSoftFade(fragPos: vec4f, particleLinearDepth: f32) -> f32 {
     return saturate(depthDiff / uniforms.softness);
 }
 
+// Calculate fog based on particle's world position (not scene depth)
+// This allows particles to fog correctly even over sky
+fn calcFog(cameraDistance: f32, worldPosY: f32) -> f32 {
+    if (uniforms.fogEnabled < 0.5) {
+        return 0.0;
+    }
+
+    // Distance fog - two gradients
+    var distanceFog: f32;
+    let d0 = uniforms.fogDistances.x;
+    let d1 = uniforms.fogDistances.y;
+    let d2 = uniforms.fogDistances.z;
+    let a0 = uniforms.fogAlphas.x;
+    let a1 = uniforms.fogAlphas.y;
+    let a2 = uniforms.fogAlphas.z;
+
+    if (cameraDistance <= d0) {
+        distanceFog = a0;
+    } else if (cameraDistance <= d1) {
+        let t = (cameraDistance - d0) / max(d1 - d0, 0.001);
+        distanceFog = mix(a0, a1, t);
+    } else if (cameraDistance <= d2) {
+        let t = (cameraDistance - d1) / max(d2 - d1, 0.001);
+        distanceFog = mix(a1, a2, t);
+    } else {
+        distanceFog = a2;
+    }
+
+    // Height fade - full fog at bottomY, zero fog at topY
+    let bottomY = uniforms.fogHeightFade.x;
+    let topY = uniforms.fogHeightFade.y;
+    var heightFactor = clamp((worldPosY - bottomY) / max(topY - bottomY, 0.001), 0.0, 1.0);
+    if (worldPosY < bottomY) {
+        heightFactor = 0.0;
+    }
+
+    return distanceFog * (1.0 - heightFactor);
+}
+
+// Apply fog to color (blend toward fog color)
+// Particles use same fog calculation as scene
+fn applyFog(color: vec3f, cameraDistance: f32, worldPosY: f32) -> vec3f {
+    let fogAlpha = calcFog(cameraDistance, worldPosY);
+    if (fogAlpha <= 0.0) {
+        return color;
+    }
+
+    return mix(color, uniforms.fogColor, fogAlpha);
+}
+
 // Fragment for alpha blend mode
 @fragment
 fn fragmentMainAlpha(input: VertexOutput) -> FragmentOutput {
@@ -487,8 +547,51 @@ fn fragmentMainAlpha(input: VertexOutput) -> FragmentOutput {
     let baseColor = texColor.rgb * input.color.rgb;
     let litColor = applyLighting(baseColor, input.lighting);
 
-    // Fog is applied as post-process to the combined HDR buffer
-    output.color = vec4f(litColor, alpha);
+    // Use pre-computed center view-space Z from vertex shader (flat interpolated)
+    let centerViewZ = input.centerViewZ;
+
+    // Debug modes using centerViewZ (flat interpolated = same value across whole particle)
+    // Use full alpha to avoid blending artifacts in debug view
+    if (uniforms.fogDebug > 0.5) {
+        // Debug mode 1: show centerViewZ/100 as grayscale (should match scene fog)
+        if (uniforms.fogDebug < 1.5) {
+            let dist = clamp(centerViewZ / 100.0, 0.0, 1.0);
+            output.color = vec4f(vec3f(dist), 1.0);
+        }
+        // Debug mode 2: show centerViewZ at 3 scales to find correct range
+        // R = /10, G = /100, B = /1000
+        else if (uniforms.fogDebug < 2.5) {
+            let r = clamp(centerViewZ / 10.0, 0.0, 1.0);
+            let g = clamp(centerViewZ / 100.0, 0.0, 1.0);
+            let b = clamp(centerViewZ / 1000.0, 0.0, 1.0);
+            output.color = vec4f(r, g, b, 1.0);
+        }
+        // Debug mode 3: compare viewZ (interpolated) vs centerViewZ (flat)
+        // R = centerViewZ/100, G = viewZ/100, B = difference
+        else if (uniforms.fogDebug < 3.5) {
+            let center = clamp(centerViewZ / 100.0, 0.0, 1.0);
+            let vertex = clamp(input.viewZ / 100.0, 0.0, 1.0);
+            let diff = abs(center - vertex);
+            output.color = vec4f(center, vertex, diff * 10.0, 1.0);
+        }
+        // Debug mode 4: show worldPos
+        else if (uniforms.fogDebug < 4.5) {
+            let r = clamp(abs(input.worldPos.x) / 100.0, 0.0, 1.0);
+            let g = clamp(abs(input.worldPos.y) / 100.0, 0.0, 1.0);
+            let b = clamp(abs(input.worldPos.z) / 100.0, 0.0, 1.0);
+            output.color = vec4f(r, g, b, 1.0);
+        }
+        // Debug mode 5: show the actual fog color being used
+        else {
+            output.color = vec4f(uniforms.fogColor, 1.0);
+        }
+        output.depth = input.linearDepth;
+        return output;
+    }
+
+    let foggedColor = applyFog(litColor, centerViewZ, input.worldPos.y);
+
+    output.color = vec4f(foggedColor, alpha);
     output.depth = input.linearDepth;
     return output;
 }
@@ -516,9 +619,53 @@ fn fragmentMainAdditive(input: VertexOutput) -> FragmentOutput {
     let baseColor = texColor.rgb * input.color.rgb;
     let litColor = applyLighting(baseColor, input.lighting);
 
-    // Fog is applied as post-process to the combined HDR buffer
+    // Use pre-computed center view-space Z from vertex shader (flat interpolated)
+    let centerViewZ = input.centerViewZ;
+
+    // Debug modes using centerViewZ (flat interpolated = same value across whole particle)
+    // Use full alpha to avoid blending artifacts in debug view
+    if (uniforms.fogDebug > 0.5) {
+        // Debug mode 1: show centerViewZ/100 as grayscale (should match scene fog)
+        if (uniforms.fogDebug < 1.5) {
+            let dist = clamp(centerViewZ / 100.0, 0.0, 1.0);
+            output.color = vec4f(vec3f(dist), 1.0);
+        }
+        // Debug mode 2: show centerViewZ at 3 scales
+        else if (uniforms.fogDebug < 2.5) {
+            let r = clamp(centerViewZ / 10.0, 0.0, 1.0);
+            let g = clamp(centerViewZ / 100.0, 0.0, 1.0);
+            let b = clamp(centerViewZ / 1000.0, 0.0, 1.0);
+            output.color = vec4f(r, g, b, 1.0);
+        }
+        // Debug mode 3: compare viewZ vs centerViewZ
+        else if (uniforms.fogDebug < 3.5) {
+            let center = clamp(centerViewZ / 100.0, 0.0, 1.0);
+            let vertex = clamp(input.viewZ / 100.0, 0.0, 1.0);
+            let diff = abs(center - vertex);
+            output.color = vec4f(center, vertex, diff * 10.0, 1.0);
+        }
+        // Debug mode 4: show worldPos
+        else if (uniforms.fogDebug < 4.5) {
+            let r = clamp(abs(input.worldPos.x) / 100.0, 0.0, 1.0);
+            let g = clamp(abs(input.worldPos.y) / 100.0, 0.0, 1.0);
+            let b = clamp(abs(input.worldPos.z) / 100.0, 0.0, 1.0);
+            output.color = vec4f(r, g, b, 1.0);
+        }
+        // Debug mode 5: show the actual fog color being used
+        else {
+            output.color = vec4f(uniforms.fogColor, 1.0);
+        }
+        output.depth = input.linearDepth;
+        return output;
+    }
+
+    // For additive particles, fog should fade the contribution to zero
+    // (not mix with fog color, which would add fog color to the already-fogged background)
+    let fogAlpha = calcFog(centerViewZ, input.worldPos.y);
+    let fadedColor = litColor * (1.0 - fogAlpha);
+
     // Premultiply for additive blending
-    let rgb = litColor * alpha;
+    let rgb = fadedColor * alpha;
     output.color = vec4f(rgb, alpha);
     output.depth = input.linearDepth;
     return output;

package/src/renderer/rendering/shaders/postproc.wgsl

@@ -6,7 +6,7 @@ struct VertexOutput {
 struct Uniforms {
     canvasSize: vec2f,
     noiseParams: vec4f,  // x = size, y = offsetX, z = offsetY, w = fxaaEnabled
-    ditherParams: vec4f, // x = enabled, y = colorLevels (32 = 5-bit PS1 style), z = unused, w = unused
+    ditherParams: vec4f, // x = enabled, y = colorLevels (32 = 5-bit PS1 style), z = tonemapMode (0=ACES, 1=Reinhard, 2=None/Linear), w = unused
     bloomParams: vec4f,  // x = enabled, y = intensity, z = radius (mip levels to sample), w = mipCount
 }
 
@@ -222,6 +222,26 @@ fn aces_tone_map(hdr: vec3<f32>) -> vec3<f32> {
     return clamp(m2 * (a / b), vec3(0.0), vec3(1.0));
 }
 
+// Reinhard tone mapping
+fn reinhard_tone_map(hdr: vec3<f32>) -> vec3<f32> {
+    return hdr / (hdr + vec3(1.0));
+}
+
+// No tone mapping - just gamma correction and clamp
+fn linear_tone_map(hdr: vec3<f32>) -> vec3<f32> {
+    return clamp(hdr, vec3(0.0), vec3(1.0));
+}
+
+// Apply selected tone mapping
+fn apply_tone_map(hdr: vec3<f32>, mode: i32) -> vec3<f32> {
+    if (mode == 1) {
+        return reinhard_tone_map(hdr);
+    } else if (mode == 2) {
+        return linear_tone_map(hdr);
+    }
+    return aces_tone_map(hdr);  // Default: ACES (mode 0)
+}
+
 @vertex
 fn vertexMain(@builtin(vertex_index) vertexIndex : u32) -> VertexOutput {
     var output : VertexOutput;
@@ -248,7 +268,8 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4<f32> {
         color += bloom * uniforms.bloomParams.y;  // y = intensity
     }
 
-    var sdr = aces_tone_map(color);
+    let tonemapMode = i32(uniforms.ditherParams.z);
+    var sdr = apply_tone_map(color, tonemapMode);
 
     // Blend GUI overlay (after tone mapping, before dithering)
     // GUI is premultiplied alpha blending

package/src/renderer/rendering/shaders/shadow.wgsl

@@ -6,6 +6,9 @@ struct Uniforms {
     lightType: f32, // 0 = directional, 1 = point, 2 = spot
     lightDirection: vec3f,      // Light direction (for surface bias)
     surfaceBias: f32,           // Expand triangles along normals (meters)
+    skinEnabled: f32,           // 1.0 if skinning enabled, 0.0 otherwise
+    numJoints: f32,             // Number of joints in the skin
+    _pad: vec2f,
 }
 
 struct VertexInput {
@@ -29,6 +32,35 @@ struct VertexOutput {
 }
 
 @group(0) @binding(0) var<uniform> uniforms: Uniforms;
+@group(0) @binding(1) var jointTexture: texture_2d<f32>;
+@group(0) @binding(2) var jointSampler: sampler;
+
+// Get a 4x4 matrix from the joint texture
+fn getJointMatrix(jointIndex: u32) -> mat4x4f {
+    let row = i32(jointIndex);
+    let col0 = textureLoad(jointTexture, vec2i(0, row), 0);
+    let col1 = textureLoad(jointTexture, vec2i(1, row), 0);
+    let col2 = textureLoad(jointTexture, vec2i(2, row), 0);
+    let col3 = textureLoad(jointTexture, vec2i(3, row), 0);
+    return mat4x4f(col0, col1, col2, col3);
+}
+
+// Apply skinning to a position
+fn applySkinning(position: vec3f, joints: vec4u, weights: vec4f) -> vec3f {
+    var skinnedPos = vec3f(0.0);
+
+    let m0 = getJointMatrix(joints.x);
+    let m1 = getJointMatrix(joints.y);
+    let m2 = getJointMatrix(joints.z);
+    let m3 = getJointMatrix(joints.w);
+
+    skinnedPos += (m0 * vec4f(position, 1.0)).xyz * weights.x;
+    skinnedPos += (m1 * vec4f(position, 1.0)).xyz * weights.y;
+    skinnedPos += (m2 * vec4f(position, 1.0)).xyz * weights.z;
+    skinnedPos += (m3 * vec4f(position, 1.0)).xyz * weights.w;
+
+    return skinnedPos;
+}
 
 @vertex
 fn vertexMain(input: VertexInput) -> VertexOutput {
@@ -42,8 +74,17 @@ fn vertexMain(input: VertexInput) -> VertexOutput {
         input.model3
     );
 
+    // Apply skinning if enabled
+    var localPos = input.position;
+    if (uniforms.skinEnabled > 0.5) {
+        let weightSum = input.weights.x + input.weights.y + input.weights.z + input.weights.w;
+        if (weightSum > 0.001) {
+            localPos = applySkinning(input.position, input.joints, input.weights);
+        }
+    }
+
     // Transform to world space
-    let worldPos = modelMatrix * vec4f(input.position, 1.0);
+    let worldPos = modelMatrix * vec4f(localPos, 1.0);
 
     // Transform to light clip space
     var clipPos = uniforms.lightViewProjection * worldPos;

package/src/renderer/rendering/shaders/volumetric_blur.wgsl

@@ -0,0 +1,80 @@
+// Volumetric Fog - Gaussian Blur
+// Blurs the ray-marched fog for softer edges
+
+struct Uniforms {
+    direction: vec2f,
+    texelSize: vec2f,
+    radius: f32,
+    _pad0: f32,
+    _pad1: f32,
+    _pad2: f32,
+}
+
+struct VertexOutput {
+    @builtin(position) position: vec4f,
+    @location(0) uv: vec2f,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: Uniforms;
+@group(0) @binding(1) var inputTexture: texture_2d<f32>;
+@group(0) @binding(2) var inputSampler: sampler;
+
+// Full-screen triangle vertex shader
+@vertex
+fn vertexMain(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+    var output: VertexOutput;
+
+    let x = f32(vertexIndex & 1u) * 4.0 - 1.0;
+    let y = f32(vertexIndex >> 1u) * 4.0 - 1.0;
+
+    output.position = vec4f(x, y, 0.0, 1.0);
+    output.uv = vec2f((x + 1.0) * 0.5, (1.0 - y) * 0.5);
+
+    return output;
+}
+
+// Gaussian weight function
+fn gaussian(x: f32, sigma: f32) -> f32 {
+    return exp(-(x * x) / (2.0 * sigma * sigma));
+}
+
+@fragment
+fn fragmentMain(input: VertexOutput) -> @location(0) vec4f {
+    let uv = input.uv;
+    let radius = uniforms.radius;
+    let sigma = radius / 3.0;  // 99.7% of Gaussian within 3 sigma
+
+    // Sample center pixel
+    var color = textureSample(inputTexture, inputSampler, uv);
+    var totalWeight = 1.0;
+
+    // Step size (sample every 1.5 texels for efficiency)
+    let stepSize = 1.5;
+    let numSamples = i32(ceil(radius / stepSize));
+
+    // Blur direction (scaled by texel size)
+    let dir = uniforms.direction * uniforms.texelSize;
+
+    // Bidirectional sampling
+    for (var i = 1; i <= numSamples; i++) {
+        let offset = f32(i) * stepSize;
+        let weight = gaussian(offset, sigma);
+
+        // Positive direction
+        let uvPos = uv + dir * offset;
+        let samplePos = textureSample(inputTexture, inputSampler, uvPos);
+        color += samplePos * weight;
+
+        // Negative direction
+        let uvNeg = uv - dir * offset;
+        let sampleNeg = textureSample(inputTexture, inputSampler, uvNeg);
+        color += sampleNeg * weight;
+
+        totalWeight += weight * 2.0;
+    }
+
+    // Normalize
+    color /= totalWeight;
+
+    return color;
+}

package/src/renderer/rendering/shaders/volumetric_composite.wgsl

@@ -0,0 +1,80 @@
+// Volumetric Fog - Composite
+// Blends the blurred fog into the scene (additive)
+
+struct Uniforms {
+    canvasSize: vec2f,
+    renderSize: vec2f,
+    texelSize: vec2f,
+    // Brightness-based fog attenuation (like bloom)
+    brightnessThreshold: f32,  // Scene luminance where fog starts fading
+    minVisibility: f32,        // Minimum fog visibility over bright surfaces (0-1)
+    skyBrightness: f32,        // Virtual brightness for sky pixels (depth at far plane)
+    _pad: f32,
+}
+
+struct VertexOutput {
+    @builtin(position) position: vec4f,
+    @location(0) uv: vec2f,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: Uniforms;
+@group(0) @binding(1) var sceneTexture: texture_2d<f32>;
+@group(0) @binding(2) var fogTexture: texture_2d<f32>;
+@group(0) @binding(3) var linearSampler: sampler;
+@group(0) @binding(4) var depthTexture: texture_depth_2d;
+
+// Full-screen triangle vertex shader
+@vertex
+fn vertexMain(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+    var output: VertexOutput;
+
+    let x = f32(vertexIndex & 1u) * 4.0 - 1.0;
+    let y = f32(vertexIndex >> 1u) * 4.0 - 1.0;
+
+    output.position = vec4f(x, y, 0.0, 1.0);
+    output.uv = vec2f((x + 1.0) * 0.5, (1.0 - y) * 0.5);
+
+    return output;
+}
+
+@fragment
+fn fragmentMain(input: VertexOutput) -> @location(0) vec4f {
+    let uv = input.uv;
+
+    // Sample scene color at full resolution
+    let sceneColor = textureSample(sceneTexture, linearSampler, uv).rgb;
+
+    // Sample fog at reduced resolution (will be upsampled by linear filtering)
+    let fog = textureSample(fogTexture, linearSampler, uv);
+
+    // Sample depth to detect sky (depth near 1.0 = far plane = sky)
+    let depthCoord = vec2i(input.position.xy);
+    let depth = textureLoad(depthTexture, depthCoord, 0);
+
+    // Calculate scene luminance for brightness-based attenuation
+    var luminance = dot(sceneColor, vec3f(0.299, 0.587, 0.114));
+
+    // Sky detection: if depth is very close to 1.0 (far plane), treat as bright
+    // This ensures fog is less visible over sky even if sky color isn't bright
+    let isSky = depth > 0.9999;
+    if (isSky) {
+        luminance = max(luminance, uniforms.skyBrightness);
+    }
+
+    // Fog visibility decreases over bright surfaces (like bloom behavior)
+    // Full visibility at dark, reduced visibility at bright, but never zero
+    let threshold = uniforms.brightnessThreshold;
+    let minVis = uniforms.minVisibility;
+
+    // Soft falloff using inverse relationship
+    // At luminance=0: visibility=1
+    // At luminance=threshold: visibility≈0.5
+    // At luminance>>threshold: visibility→minVis
+    let falloff = 1.0 / (1.0 + luminance / max(threshold, 0.01));
+    let fogVisibility = mix(minVis, 1.0, falloff);
+
+    // Additive blend with brightness attenuation
+    let finalColor = sceneColor + fog.rgb * fogVisibility;
+
+    return vec4f(finalColor, 1.0);
+}