SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
GPU path tracer: the path shader compiles on NVIDIA's Vulkan driver (#6705) (#6850)
Frank44a9f9ee42a8
diff --git a/crates/gpu/src/path/path.wgsl b/crates/gpu/src/path/path.wgslindex 7c6aa05f5d..35e3f081dd 100644--- a/crates/gpu/src/path/path.wgsl+++ b/crates/gpu/src/path/path.wgsl@@ -574,17 +574,22 @@ fn dominant_vertex(bary: vec3<f32>) -> u32 {if bary.z>bary[anchor] { anchor=2u; }return anchor;}+// The vertex after `a`, as (a+1)%3. Not written with `%`: NVIDIA's Vulkan compiler crashes on+// that index after a BVH walk (#6705).+fn next_vertex(a: u32) -> u32 {+ return select(a+1u,0u,a>=2u);+}fn surface_point(t: Triangle, bary: vec3<f32>) -> vec3<f32> {// Anchor near the hit, retaining the two other directly computed weights.// A tiny weight on a distant vertex can encode an entire corner clearance.// Do not recover that weight by subtracting the other two from one.let p=array<vec3<f32>,3>(t.p0.xyz,t.p1.xyz,t.p2.xyz);- let a=dominant_vertex(bary); let b=(a+1u)%3u; let c=(a+2u)%3u;+ let a=dominant_vertex(bary); let b=next_vertex(a); let c=next_vertex(b);return p[a]+((p[b]-p[a])*bary[b]+(p[c]-p[a])*bary[c]);}fn surface_point_precise(t: Triangle, bary: vec3<f32>) -> PrecisePoint {let p=array<vec3<f32>,3>(t.p0.xyz,t.p1.xyz,t.p2.xyz);- let a=dominant_vertex(bary); let b=(a+1u)%3u; let c=(a+2u)%3u;+ let a=dominant_vertex(bary); let b=next_vertex(a); let c=next_vertex(b);// Keep the world anchor separate from its local displacement.return PrecisePoint(p[a],(p[b]-p[a])*bary[b]+(p[c]-p[a])*bary[c]);}@@ -595,7 +600,7 @@ fn surface_ray_depth_precise(t: Triangle, bary: vec3<f32>, origin: vec3<f32>, or}fn surface_ray_depth(t: Triangle, bary: vec3<f32>, origin: vec3<f32>, axis: u32) -> f32 {let p=array<vec3<f32>,3>(t.p0.xyz,t.p1.xyz,t.p2.xyz);- let a=dominant_vertex(bary); let b=(a+1u)%3u; let c=(a+2u)%3u;+ let a=dominant_vertex(bary); let b=next_vertex(a); let c=next_vertex(b);// Original vertex differences avoid subtracting two rounded ray-relative// coordinates; adding the anchor last preserves distant thin-hit ordering.return (p[a][axis]-origin[axis])+((p[b][axis]-p[a][axis])*bary[b]+(p[c][axis]-p[a][axis])*bary[c]);@@ -660,16 +665,6 @@ fn area_pdf(light: AreaLight, delta: vec3<f32>) -> f32 {if cosine<=0.0 { return 0.0; }return dot(delta,delta)/(light.center.w*cosine);}-fn visible(o: vec3<f32>, d: vec3<f32>, distance: f32) -> ShadowResult {- if emitter_hit(o,d).distance<distance-u.lighting.x*2.0 { return blocked_shadow(); }- var visibility=shadow_transmittance(o,d,distance);- if u.volume_min.w>0.0 {- let attenuation=volume_transmittance(o,d,distance);- visibility.transmittance*=attenuation;- visibility.branch_pdf*=attenuation;- }- return visibility;-}struct EnvironmentSample { direction: vec3<f32>, radiance: vec3<f32>, pdf: f32 };fn environment_to_world(d: vec3<f32>) -> vec3<f32> {return vec3<f32>(u.environment_map.x*d.x-u.environment_map.y*d.y,u.environment_map.y*d.x+u.environment_map.x*d.y,d.z);@@ -723,43 +718,67 @@ fn sun_sample(rng:ptr<function,u32>)->EnvironmentSample {let direction=from_local(vec3<f32>(radius*cos(phi),radius*sin(phi),z),u.sun_direction.xyz);return EnvironmentSample(direction,u.sun_radiance.xyz,u.sun_radiance.w);}-fn direct_studio(t: Triangle, position: vec3<f32>, o: vec3<f32>, n: vec3<f32>, geometric: vec3<f32>, v: vec3<f32>, remaining: u32, rng: ptr<function,u32>) -> vec3<f32> {+// The three fixed lights of the preview without studio lighting: direction and intensity.+const FIXED_LIGHTS = array<vec4<f32>,3>(vec4<f32>(0.6,0.0,0.8,3.0),vec4<f32>(-0.8,0.0,0.6,1.0),vec4<f32>(0.0,-0.6,0.8,1.5));+// Next-event estimation for every light source family through ONE shadow-ray call site, like+// volume_direct. Native compilers inline each call of the BVH walk; one walk per source family+// made `main` too large for NVIDIA's Vulkan compiler (#6705). Studio lighting visits every area+// light, then the environment, then the sun, drawing random numbers in that order; without it+// the three fixed lights are used.+fn direct_light(t: Triangle, position: vec3<f32>, o: vec3<f32>, n: vec3<f32>, geometric: vec3<f32>, v: vec3<f32>, remaining: u32, rng: ptr<function,u32>) -> vec3<f32> {var result = vec3<f32>(0.0);let opaque = 1.0-t.base.w;- if opaque<=0.0 { return result; }- for (var i=0u; i<u32(u.light_count.w); i+=1u) {- let light = u.area_lights[i];- let point = light.center.xyz + light.u.xyz*(2.0*random(rng)-1.0) + light.v.xyz*(2.0*random(rng)-1.0);- let delta = point-position;- let direction = unit(delta);- let pdf = area_pdf(light,delta);- let nl = dot(n,direction);- if pdf<=0.0 || nl<=0.0 || dot(geometric,direction)<=0.0 { continue; }- let shadow = point-o;- let visibility=visible(o,unit(shadow),length(shadow));- let competing=opaque*surface_pdf(t,n,v,direction)*visibility.branch_pdf;- let weight=select(power_weight(pdf,competing),1.0,visibility.solid || visibility.crossings>=remaining);- result += visibility.transmittance*brdf(t,n,v,direction)*light.radiance.xyz*(opaque*nl*weight/pdf);- }- if u.environment_map.w>0.0 || any(u.environment.xyz>vec3<f32>(0.0)) {- let sample=env_sample(rng);- let nl=dot(n,sample.direction);- if sample.pdf>0.0 && nl>0.0 && dot(geometric,sample.direction)>0.0 {- let visibility=visible(o,sample.direction,FAR);- let competing=opaque*surface_pdf(t,n,v,sample.direction)*visibility.branch_pdf;- let weight=select(power_weight(sample.pdf,competing),1.0,visibility.solid || visibility.crossings>=remaining);- result+=visibility.transmittance*brdf(t,n,v,sample.direction)*sample.radiance*(opaque*nl*weight/sample.pdf);+ let studio = u.environment.w > 0.0;+ if studio && opaque<=0.0 { return result; }+ let area_count = u32(u.light_count.w);+ let count = select(3u, area_count+2u, studio);+ for (var source=0u; source<count; source+=1u) {+ var sample = EnvironmentSample(vec3<f32>(0.0,0.0,1.0),vec3<f32>(0.0),0.0);+ var shadow_direction = vec3<f32>(0.0,0.0,1.0);+ var shadow_distance = FAR;+ if !studio {+ let light = FIXED_LIGHTS[source];+ if u.lighting.z <= 0.0 || dot(geometric,light.xyz)<=0.0 || dot(n,light.xyz)<=0.0 { continue; }+ sample = EnvironmentSample(light.xyz,vec3<f32>(light.w*u.lighting.z*u.studio_weights[source]),1.0);+ shadow_direction = light.xyz;+ } else {+ if source<area_count {+ let light = u.area_lights[source];+ let point = light.center.xyz + light.u.xyz*(2.0*random(rng)-1.0) + light.v.xyz*(2.0*random(rng)-1.0);+ let delta = point-position;+ sample = EnvironmentSample(unit(delta),light.radiance.xyz,area_pdf(light,delta));+ let shadow = point-o;+ shadow_direction = unit(shadow);+ shadow_distance = length(shadow);+ } else if source==area_count {+ if u.environment_map.w<=0.0 && !any(u.environment.xyz>vec3<f32>(0.0)) { continue; }+ sample = env_sample(rng);+ shadow_direction = sample.direction;+ } else {+ if u.sun_radiance.w<=0.0 { continue; }+ sample = sun_sample(rng);+ shadow_direction = sample.direction;+ }+ if sample.pdf<=0.0 || dot(n,sample.direction)<=0.0 || dot(geometric,sample.direction)<=0.0 { continue; }}- }- if u.sun_radiance.w>0.0 {- let sample=sun_sample(rng);- let nl=dot(n,sample.direction);- if nl>0.0 && dot(geometric,sample.direction)>0.0 {- let visibility=visible(o,sample.direction,FAR);- let competing=opaque*surface_pdf(t,n,v,sample.direction)*visibility.branch_pdf;- let weight=select(power_weight(sample.pdf,competing),1.0,visibility.solid || visibility.crossings>=remaining);- result+=visibility.transmittance*brdf(t,n,v,sample.direction)*sample.radiance*(opaque*nl*weight/sample.pdf);+ // Studio emitters block a connection that passes them; studio volumes attenuate it.+ var visibility = blocked_shadow();+ if !studio || emitter_hit(o,shadow_direction).distance>=shadow_distance-u.lighting.x*2.0 {+ visibility = shadow_transmittance(o,shadow_direction,shadow_distance);+ if studio && u.volume_min.w>0.0 {+ let attenuation=volume_transmittance(o,shadow_direction,shadow_distance);+ visibility.transmittance*=attenuation;+ visibility.branch_pdf*=attenuation;+ }}+ let nl = dot(n,sample.direction);+ if !studio {+ result += visibility.transmittance * brdf(t,n,v,sample.direction) * (opaque*nl*sample.radiance);+ continue;+ }+ let competing=opaque*surface_pdf(t,n,v,sample.direction)*visibility.branch_pdf;+ let weight=select(power_weight(sample.pdf,competing),1.0,visibility.solid || visibility.crossings>=remaining);+ result += visibility.transmittance*brdf(t,n,v,sample.direction)*sample.radiance*(opaque*nl*weight/sample.pdf);}return result;}@@ -816,7 +835,6 @@ fn sample_path_lane(pixel: u32, lane: u32) -> vec4<f32> {var previous_delta = true;var media: array<Medium,16>;var medium_count = 0u;- let lights = array<vec4<f32>,3>(vec4<f32>(0.6,0.0,0.8,3.0),vec4<f32>(-0.8,0.0,0.6,1.0),vec4<f32>(0.0,-0.6,0.8,1.5));for (var bounce = 0u; bounce < u.sampling.y; bounce += 1u) {// Closed-glass continuations set an excluded producing triangle; every// other launch (camera, opaque or thin-sheet surface) does not.@@ -947,16 +965,7 @@ fn sample_path_lane(pixel: u32, lane: u32) -> vec4<f32> {}previous_position = position; previous_position_low=position_low;o = position + geometric*(u.lighting.x*2.0); o_low=vec3<f32>(0.0);- if u.environment.w > 0.0 {- radiance += throughput*direct_studio(t,position,o,n,geometric,v,u.sampling.y-bounce-1u,&rng);- }- for (var i=0u; i<3u && u.environment.w==0.0; i+=1u) {- let light = lights[i];- if u.lighting.z > 0.0 && dot(geometric,light.xyz)>0.0 && dot(n,light.xyz)>0.0 {- let visibility=shadow_transmittance(o,light.xyz,FAR);- radiance += visibility.transmittance * throughput * brdf(t,n,v,light.xyz) * ((1.0-t.base.w)*light.w*dot(n,light.xyz)*u.lighting.z*u.studio_weights[i]);- }- }+ radiance += throughput*direct_light(t,position,o,n,geometric,v,u.sampling.y-bounce-1u,&rng);if t.base.w > 0.0 && random(&rng) < t.base.w {var nt = t.parameters.z;if t.parameters.w < 0.0 && entering && medium_count > 0u && u.lighting.w==0.0 {@@ -1105,14 +1114,22 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {let pilots = u.adaptive_budget.x;let strata = max(1u,u.adaptive_budget.z);let lane = u32(u.adaptive_error.w);+ // Settle first whether this invocation samples at all, then take the path sample at one call+ // site: every call is inlined, and three copies of the integrator were more than NVIDIA's+ // Vulkan compiler could build (#6705).+ var budget_count = 0u;+ if pilots > 0u && u.image.z >= pilots {+ budget_count = u32(accumulation[2u*pixels+pixel].x);+ if u.image.z-pilots >= budget_count { return; }+ }+ let value = sample_path(pixel);if pilots == 0u {- let sample = sample_path(pixel)/f32(strata);+ let sample = value/f32(strata);if u.image.z == 0u && lane == 0u { accumulation[pixel] = sample; }else { accumulation[pixel] += sample; }return;}if u.image.z < pilots {- let value = sample_path(pixel);var mean = accumulation[pixels+pixel];var m2 = accumulation[2u*pixels+pixel];if u.image.z == 0u { mean=vec4<f32>(0.0); m2=vec4<f32>(0.0); }@@ -1127,10 +1144,8 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {}return;}- let budget_count=u32(accumulation[2u*pixels+pixel].x);let ordinal=u.image.z-pilots;- if ordinal>=budget_count { return; }- accumulation[pixel] += sample_path(pixel)/f32(strata);+ accumulation[pixel] += value/f32(strata);// Per-pixel production means enter both raw EXR and denoising. Pilots do not.if ordinal+1u == budget_count && lane+1u == strata { accumulation[pixel] /= f32(budget_count); }}diff --git a/crates/gpu/src/path/tests.rs b/crates/gpu/src/path/tests.rsindex ed40cae2fb..24e838ffca 100644--- a/crates/gpu/src/path/tests.rs+++ b/crates/gpu/src/path/tests.rs@@ -531,6 +531,48 @@ fn shader_validates_without_a_device() {naga::valid::Validator::new(naga::valid::ValidationFlags::all(), naga::valid::Capabilities::empty()).validate(&module).unwrap();}+/// #6705: native compilers inline every call. With 33 inlined BVH walks in `main` (three path+/// samples, a shadow walk per light source family) NVIDIA's Vulkan compiler crashed or ran out+/// of memory and never built the pipeline. Count the walks `main` inlines, so another call site+/// is a deliberate choice, checked on such a driver.+#[test]+fn main_inlines_few_bvh_walks() {+ fn callees(block: &naga::Block, out: &mut Vec<naga::Handle<naga::Function>>) {+ for statement in block.iter() {+ match statement {+ naga::Statement::Call { function, .. } => out.push(*function),+ naga::Statement::Block(inner) => callees(inner, out),+ naga::Statement::If { accept, reject, .. } => {+ callees(accept, out);+ callees(reject, out);+ }+ naga::Statement::Switch { cases, .. } => cases.iter().for_each(|case| callees(&case.body, out)),+ naga::Statement::Loop { body, continuing, .. } => {+ callees(body, out);+ callees(continuing, out);+ }+ _ => {}+ }+ }+ }+ fn walks(module: &naga::Module, function: &naga::Function) -> usize {+ let mut called = Vec::new();+ callees(&function.body, &mut called);+ called+ .into_iter()+ .map(|handle| {+ let callee = &module.functions[handle];+ let walk = matches!(callee.name.as_deref(), Some("trace_precise_within" | "trace_ordered_within"));+ usize::from(walk) + walks(module, callee)+ })+ .sum()+ }+ let module = naga::front::wgsl::parse_str(SHADER).unwrap();+ let main = module.entry_points.iter().find(|entry| entry.name == "main").unwrap();+ let inlined = walks(&module, &main.function);+ assert!(inlined <= 5, "`main` inlines {inlined} BVH walks");+}+#[test]fn render_lights_path_visibility_uniform_keeps_the_shader_contract() {shader_validates_without_a_device();