topazcube 0.1.31 → 0.1.35

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);
+}