@meimu/mutracer 0.1.5 → 0.2.0

package/lib/renderer/wgsl/proceduralSky.compute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proceduralSky.compute.js","sourceRoot":"","sources":["../../../src/renderer/wgsl/proceduralSky.compute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAE9F,gFAAgF;AAChF,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;uBAiBrB,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC;;;;;;;;;;;8CAWC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoIzC,WAAW,2BAA2B,qBAAqB,cAAc,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkC7G,CAAC","sourcesContent":["import { TURBIDITY, GROUND_ALBEDO, ILLUMINANCE, REFERENCE_ILLUMINANCE } from '../skyModel.js';\n\n// Same atmosphere, quadrature and pass order as WebGLSkyBaker. Distances in km.\nexport const proceduralSkyWGSL = /* wgsl */ `\nstruct Params { sun: vec4f, sunWorld: vec4f, size: vec4f, scale: vec4f, ambient: vec4f }\n@group(0) @binding(0) var<uniform> params: Params;\n@group(0) @binding(1) var transmittanceTable: texture_2d<f32>;\n@group(0) @binding(2) var multipleTable: texture_2d<f32>;\n@group(0) @binding(3) var skyTable: texture_2d<f32>;\n@group(0) @binding(4) var irradianceTable: texture_2d<f32>;\n@group(0) @binding(5) var output: texture_storage_2d<rgba32float, write>;\nconst PI = 3.14159265358979;\nconst R_GROUND = 6360.0;\nconst R_TOP = 6460.0;\nconst CAMERA_ALTITUDE = 0.2;\nconst RAYLEIGH = vec3f(5.802e-3, 13.558e-3, 33.1e-3);\nconst MIE_SCATTERING = 3.996e-3;\nconst MIE_EXTINCTION = 4.44e-3;\nconst MIE_G = 0.8;\nconst OZONE = vec3f(0.65e-3, 1.881e-3, 0.085e-3);\nconst ALBEDO = vec3f(${GROUND_ALBEDO.join(', ')});\nconst T_SIZE = vec2u(256, 64);\nconst MS_ALTITUDES = 32u;\nconst SV_SIZE = vec2u(96, 192);\n\nfn discriminant(r: f32, mu: f32, radius: f32) -> f32 { return (radius - r) * (radius + r) + r * r * mu * mu; }\nfn hitsGround(r: f32, mu: f32) -> bool { return mu < 0.0 && discriminant(r, mu, R_GROUND) >= 0.0; }\nfn distanceToGround(r: f32, mu: f32) -> f32 { return max(-r * mu - sqrt(max(discriminant(r, mu, R_GROUND), 0.0)), 0.0); }\nfn distanceToTop(r: f32, mu: f32) -> f32 { return max(-r * mu + sqrt(max(discriminant(r, mu, R_TOP), 0.0)), 0.0); }\nfn densities(r: f32) -> vec3f {\n  let h = max(r - R_GROUND, 0.0);\n  return vec3f(exp(-h / 8.0), exp(-h / 1.2) * ${TURBIDITY}, max(0.0, 1.0 - abs(h - 25.0) / 15.0));\n}\nfn extinction(d: vec3f) -> vec3f { return RAYLEIGH * d.x + MIE_EXTINCTION * d.y + OZONE * d.z; }\nfn altitudeAt(x: f32) -> f32 { return x * x * (R_TOP - R_GROUND); }\nfn altitudeCoord(h: f32) -> f32 { return sqrt(clamp(h / (R_TOP - R_GROUND), 0.0, 1.0)); }\nfn fetchLinear(table: texture_2d<f32>, p: vec2f) -> vec3f {\n  let size = vec2i(textureDimensions(table));\n  let q = clamp(p, vec2f(0.0), vec2f(size - 1));\n  let i = min(vec2i(floor(q)), max(size - 2, vec2i(0)));\n  let f = clamp(q - vec2f(i), vec2f(0.0), vec2f(1.0));\n  let j = min(i + 1, size - 1);\n  let a = textureLoad(table, i, 0).rgb;\n  let b = textureLoad(table, vec2i(j.x, i.y), 0).rgb;\n  let c = textureLoad(table, vec2i(i.x, j.y), 0).rgb;\n  let d = textureLoad(table, j, 0).rgb;\n  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);\n}\nfn transmittanceTo(r: f32, mu: f32) -> vec3f {\n  return fetchLinear(transmittanceTable, vec2f((clamp(mu, -1.0, 1.0) + 1.0) * 0.5 * f32(T_SIZE.x - 1u), altitudeCoord(r - R_GROUND) * f32(T_SIZE.y - 1u)));\n}\nfn cornetteShanks(nu: f32) -> f32 {\n  let g2 = MIE_G * MIE_G;\n  return 3.0 / (8.0 * PI) * ((1.0 - g2) * (1.0 + nu * nu)) / ((2.0 + g2) * pow(1.0 + g2 - 2.0 * MIE_G * nu, 1.5));\n}\nstruct March { radiance: vec3f, throughput: vec3f }\nfn march(origin: vec3f, dir: vec3f, steps: u32, full: bool, skyIrradiance: vec3f) -> March {\n  let r = length(origin);\n  let mu = dot(origin, dir) / r;\n  let ground = hitsGround(r, mu);\n  var len = distanceToTop(r, mu);\n  if (ground) { len = distanceToGround(r, mu); }\n  let nu = dot(dir, params.sun.xyz);\n  var rayleighPhase = 1.0 / (4.0 * PI);\n  var miePhase = rayleighPhase;\n  if (full) { rayleighPhase = 3.0 / (16.0 * PI) * (1.0 + nu * nu); miePhase = cornetteShanks(nu); }\n  var result = March(vec3f(0.0), vec3f(0.0));\n  var view = vec3f(1.0);\n  var previous = 0.0;\n  for (var i = 0u; i < steps; i++) {\n    let s = f32(i + 1u) / f32(steps);\n    let next = len * s * s;\n    let dt = next - previous;\n    let p = origin + dir * (0.5 * (previous + next));\n    previous = next;\n    let pr = length(p);\n    let d = densities(pr);\n    let e = extinction(d);\n    let sunT = transmittanceTo(pr, dot(p, params.sun.xyz) / pr);\n    let scatterR = RAYLEIGH * d.x;\n    let scatterM = MIE_SCATTERING * d.y;\n    var ms = vec3f(0.0);\n    if (full) { ms = fetchLinear(multipleTable, vec2f(altitudeCoord(pr - R_GROUND) * f32(MS_ALTITUDES - 1u), 0.0)); }\n    let source = sunT * (scatterR * rayleighPhase + scatterM * miePhase) + (scatterR + scatterM) * ms;\n    let segment = exp(-e * dt);\n    let weight = (1.0 - segment) / max(e, vec3f(1e-9));\n    result.radiance += view * source * weight;\n    result.throughput += view * (scatterR + scatterM) * weight;\n    view *= segment;\n  }\n  if (ground) {\n    let p = origin + dir * len;\n    let pr = length(p);\n    let cosSun = dot(p, params.sun.xyz) / pr;\n    let irradiance = transmittanceTo(pr, cosSun) * max(cosSun, 0.0) + skyIrradiance;\n    result.radiance += view * ALBEDO / PI * irradiance;\n  }\n  return result;\n}\nfn elevationAt(row: f32) -> f32 {\n  let x = row / f32(SV_SIZE.y - 1u) * 2.0 - 1.0;\n  return sign(x) * x * x * (PI / 2.0);\n}\nfn elevationCoord(e: f32) -> f32 {\n  let x = sign(e) * sqrt(abs(e) / (PI / 2.0));\n  return clamp((x + 1.0) * 0.5, 0.0, 1.0) * f32(SV_SIZE.y - 1u);\n}\n@compute @workgroup_size(8, 8)\nfn transmittance(@builtin(global_invocation_id) id: vec3u) {\n  if (any(id.xy >= T_SIZE)) { return; }\n  let mu = f32(id.x) / f32(T_SIZE.x - 1u) * 2.0 - 1.0;\n  let r = R_GROUND + altitudeAt(f32(id.y) / f32(T_SIZE.y - 1u));\n  if (hitsGround(r, mu)) { textureStore(output, vec2i(id.xy), vec4f(0.0, 0.0, 0.0, 1.0)); return; }\n  let len = distanceToTop(r, mu);\n  var depth = vec3f(0.0);\n  for (var i = 0u; i < 48u; i++) {\n    let t = (f32(i) + 0.5) / 48.0 * len;\n    depth += extinction(densities(sqrt(t * t + 2.0 * r * mu * t + r * r))) * (len / 48.0);\n  }\n  textureStore(output, vec2i(id.xy), vec4f(exp(-depth), 1.0));\n}\n@compute @workgroup_size(8, 8)\nfn multiple(@builtin(global_invocation_id) id: vec3u) {\n  if (id.x >= MS_ALTITUDES || id.y > 0u) { return; }\n  let r = R_GROUND + altitudeAt(f32(id.x) / f32(MS_ALTITUDES - 1u));\n  var second = vec3f(0.0);\n  var transfer = vec3f(0.0);\n  for (var i = 0u; i < 64u; i++) {\n    let mu = 1.0 - 2.0 * (f32(i) + 0.5) / 64.0;\n    let phi = f32(i) * PI * (3.0 - sqrt(5.0));\n    let s = sqrt(1.0 - mu * mu);\n    let result = march(vec3f(0.0, r, 0.0), vec3f(s * cos(phi), mu, s * sin(phi)), 20u, false, vec3f(0.0));\n    second += result.radiance / 64.0;\n    transfer += result.throughput / 64.0;\n  }\n  textureStore(output, vec2i(id.xy), vec4f(second / (1.0 - transfer), 1.0));\n}\n@compute @workgroup_size(8, 8)\nfn skyView(@builtin(global_invocation_id) id: vec3u) {\n  if (any(id.xy >= SV_SIZE)) { return; }\n  let e = elevationAt(f32(id.y));\n  let phi = f32(id.x) / f32(SV_SIZE.x - 1u) * PI;\n  var sky = vec3f(0.0);\n  if (params.size.w > 0.0) { sky = textureLoad(irradianceTable, vec2i(0), 0).rgb; }\n  let result = march(vec3f(0.0, R_GROUND + CAMERA_ALTITUDE, 0.0), vec3f(cos(e) * cos(phi), sin(e), cos(e) * sin(phi)), 40u, true, sky);\n  textureStore(output, vec2i(id.xy), vec4f(result.radiance, 1.0));\n}\n@compute @workgroup_size(8, 8)\nfn irradiance(@builtin(global_invocation_id) id: vec3u) {\n  if (id.x >= 2u || id.y > 0u) { return; }\n  var sky = vec3f(0.0);\n  for (var i = 0u; i < 128u; i++) {\n    let e = (f32(i) + 0.5) / 128.0 * (PI / 2.0);\n    let weight = 2.0 * sin(e) * cos(e) * (PI / 2.0 / 128.0) * (PI / 48.0);\n    for (var j = 0u; j < 48u; j++) {\n      let phi = (f32(j) + 0.5) / 48.0 * PI;\n      sky += fetchLinear(skyTable, vec2f(phi / PI * f32(SV_SIZE.x - 1u), elevationCoord(e))) * weight;\n    }\n  }\n  if (id.x == 0u) { textureStore(output, vec2i(id.xy), vec4f(sky, 1.0)); return; }\n  let sunT = transmittanceTo(R_GROUND + CAMERA_ALTITUDE, params.sun.y);\n  let luma = vec3f(0.2126, 0.7152, 0.0722);\n  let horizontal = dot(sky, luma) + dot(sunT, luma) * max(params.sun.y, 0.0);\n  let scale = ${ILLUMINANCE} / sqrt(max(horizontal, ${REFERENCE_ILLUMINANCE} * 1e-3) * ${REFERENCE_ILLUMINANCE});\n  textureStore(output, vec2i(id.xy), vec4f(sunT, scale));\n}\nfn mapDirection(texel: vec2f) -> vec3f {\n  let theta = texel.y / params.size.y * PI;\n  let phi = texel.x / params.size.x * 2.0 * PI;\n  return vec3f(-sin(theta) * cos(phi), cos(theta), -sin(theta) * sin(phi));\n}\n@compute @workgroup_size(8, 8)\nfn map(@builtin(global_invocation_id) id: vec3u) {\n  if (any(id.xy >= vec2u(params.size.xy))) { return; }\n  let texel = vec2f(id.xy) + 0.5;\n  let dir = mapDirection(texel);\n  let rawRelative = abs(atan2(dir.z, dir.x) - params.sun.w);\n  let wrapped = rawRelative - floor(rawRelative / (2.0 * PI)) * (2.0 * PI);\n  let relative = min(wrapped, 2.0 * PI - wrapped);\n  let e = asin(clamp(dir.y, -1.0, 1.0));\n  var radiance = fetchLinear(skyTable, vec2f(relative / PI * f32(SV_SIZE.x - 1u), elevationCoord(e)));\n  let sun = textureLoad(irradianceTable, vec2i(1, 0), 0);\n  let radius = params.sunWorld.w;\n  let texelAngle = PI / params.size.y;\n  if (acos(clamp(dot(dir, params.sunWorld.xyz), -1.0, 1.0)) < radius + 3.0 * texelAngle / max(sqrt(1.0 - dir.y * dir.y), 0.05)) {\n    var coverage = 0.0;\n    for (var y = 0u; y < 6u; y++) { for (var x = 0u; x < 6u; x++) {\n      let d = mapDirection(texel - 0.5 + (vec2f(f32(x), f32(y)) + 0.5) / 6.0);\n      let angle = 2.0 * asin(min(length(d - params.sunWorld.xyz) * 0.5, 1.0));\n      let t = angle / radius;\n      if (t < 1.0) { coverage += 1.0 - 0.6 * (1.0 - sqrt(1.0 - t * t)); }\n    } }\n    let solidAngle = 2.0 * PI * (1.0 - cos(radius));\n    radiance += coverage / 36.0 / (solidAngle * (1.0 - 0.6 / 3.0)) * sun.rgb;\n  }\n  textureStore(output, vec2i(id.xy), vec4f(radiance * sun.a * params.scale.xyz + params.ambient.xyz, 1.0));\n}\n`;\n"]}

package/lib/renderer/wgsl/rayTrace.compute.d.ts

@@ -1,4 +1,13 @@
 export declare const WORKGROUP_SIZE = 8;
+/** Native input instrumentation; omitted hooks preserve the production source. */
+export interface RayTraceInputHooks {
+    declarations: string;
+    begin: string;
+    primarySurface: string;
+    unclampedColor: string;
+    end: string;
+    uniformJitter: boolean;
+}
 export interface RayTraceShaderOptions {
     hasDisplacement: boolean;
     /** Include direction frames only when used, preserving the legacy shader arithmetic otherwise. */
@@ -11,6 +20,13 @@ export interface RayTraceShaderOptions {
     hasSceneAlpha?: boolean;
     /** Bit mask of the BLAS layouts present in the scene (bvh2, bvh4, bvh-gpu, cwbvh). */
     blasLayoutMask?: number;
+    /** Defined only when pipeline constants are baked into the source. */
+    spectral?: boolean;
+    sceneCapabilities?: number;
+    /** Retained environment support must still respect the current illumination state. */
+    dynamicEnvironment?: boolean;
+    materialCapabilities?: number;
+    lightCapabilities?: number;
 }
 /** Generates the WebGPU megakernel path tracing compute shader. */
-export default function rayTraceCompute({ hasDisplacement, hasAnisotropyDirections, hasCoatNormals, hasAlpha, hasSceneAlpha, blasLayoutMask }: RayTraceShaderOptions): string;
+export default function rayTraceCompute({ hasDisplacement, hasAnisotropyDirections, hasCoatNormals, hasAlpha, hasSceneAlpha, blasLayoutMask, spectral, sceneCapabilities, dynamicEnvironment, materialCapabilities, lightCapabilities }: RayTraceShaderOptions, sceneIntersections?: string, pathDiagnostic?: boolean, inputHooks?: RayTraceInputHooks): string;