Headless 3D and VFX engine for agents. Research preview.
//! Install-time environment convolution.
use super::*;
mod cache;
mod evaluated;
pub(crate) use evaluated::Validation;
// Preserve float32 bits without a float-sampling capability or precision loss.
#[cfg(test)]
const SOURCE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba32Uint;
const FILTER_SHADER: &str = include_str!("../shaders/environment.slang");
const REDUCE_SHADER: &str = include_str!("../shaders/environment_reduce.slang");
pub(crate) const REDUCE_LAYOUT: [wgpu::BindGroupLayoutEntry; 2] = [
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Uint,
view_dimension: wgpu::TextureViewDimension::D2Array,
multisampled: false,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::StorageTexture {
access: wgpu::StorageTextureAccess::WriteOnly,
format: wgpu::TextureFormat::Rgba32Float,
view_dimension: wgpu::TextureViewDimension::D2,
},
count: None,
},
];
pub(super) struct Environment {
pub settings: environment_node::Settings,
pub primary: Option<environment_program::Primary>,
pub mean: [f32; 3],
animated: Option<Animated>,
initial_filter_scale:f32,
pub node: Option<usize>,
pub source: wgpu::TextureView,
pub distribution: Option<wgpu::Buffer>,
pub distribution_size: [u32; 2],
pub specular: wgpu::TextureView,
pub diffuse: wgpu::TextureView,
pub brdf: wgpu::TextureView,
pub ltc: wgpu::TextureView,
pub sampler: wgpu::Sampler,
pub image_sampler: wgpu::Sampler,
}
struct Animated {
program: environment_program::Program,
evaluation:evaluated::Evaluation,
integrals: Vec<Integral>,
}
struct Integral {
bind: wgpu::BindGroup,
params: wgpu::Buffer,
groups: [u32; 2],
}
impl Integral {
fn encode(&self, encoder: &mut wgpu::CommandEncoder, pipeline: &wgpu::ComputePipeline) {
let mut pass = encoder.begin_compute_pass(&Default::default());
pass.set_pipeline(pipeline);
pass.set_bind_group(0, &self.bind, &[]);
pass.dispatch_workgroups(self.groups[0], self.groups[1], 1);
}
}
impl Environment {
pub(crate) fn animated(&self) -> bool {
self.animated.is_some()
}
pub(crate) fn sample_key(&self,time:f32)->Result<Vec<u8>> {
Ok(self.animated.as_ref().map_or_else(Vec::new, |a|a.program.sample_key(time)))
}
/// Only values change: source radiance, proposal, moments and the retained
/// filter passes. Every consumer keeps the same installed texture views.
pub(crate) fn update(&self, r: &Renderer, time: f32, changes: &mut values::LightingTracker) -> Result<()> {
let Some(animated) = &self.animated else {
return Ok(());
};
let key=animated.program.sample_key(time);
if !changes.changed(values::LightingKey::EnvironmentRadiance,&key) {return Ok(());}
animated.program.evaluate_source(r,time)?;
let mut encoder = r.device.create_command_encoder(&Default::default());
animated.evaluation.encode(r,&mut encoder);
for integral in &animated.integrals {
animated.evaluation.publish_filter(&mut encoder,&integral.params);
integral.encode(&mut encoder, Self::pipeline(r));
}
crate::command_finish::Segments::submit(&r.queue, encoder);
Ok(())
}
pub(crate) fn initial_filter_scale(&self) -> f32 {self.initial_filter_scale}
pub(crate) fn initial_mean(&self) -> [f32;3] {self.mean}
#[cfg(test)]
pub(crate) fn sampled_mean(&self,r:&Renderer)->Result<[f32;3]> {
if let Some(animated)=&self.animated {Ok(animated.evaluation.read_metadata(r,r.device.create_command_encoder(&Default::default()))?.0[0].as_vec3().to_array())} else {Ok(self.mean)}
}
pub(crate) fn publish_metadata(&self,encoder:&mut wgpu::CommandEncoder,uniform:&wgpu::Buffer) {
if let Some(animated)=&self.animated {animated.evaluation.publish_frame(encoder,uniform);}
}
pub(crate) fn diagnostics(&self,r:&Renderer)->Option<Validation> {self.animated.as_ref().map(|a|a.evaluation.diagnostics(r))}
pub(crate) fn pipeline(r: &Renderer) -> &wgpu::ComputePipeline {
let d = &r.device;
r.pipelines.environment.get_or_init(|| {
let module = crate::native::shader_module(d, &crate::native::ENVIRONMENT_FILTER_MAIN);
// Native modules require an explicit layout: wgpu cannot reflect them.
let layout = d.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("environment integrals"),
entries: &layout_entries(),
});
let pipeline_layout = d.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("environment integrals"),
bind_group_layouts: &[Some(&layout)],
immediate_size: 0,
});
r.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some("environment install"),
layout: Some(&pipeline_layout),
module: &module,
entry_point: Some("filter_main"),
compilation_options: Default::default(),
cache: r.cache.as_ref(),
})
})
}
pub fn new(
r: &Renderer,
config: environment_node::Settings,
scene: &vork_scene::v2::Scene,
base: &Path,
) -> Result<Self> {
let settings = config.has_radiance().then_some(&config);
let d = &r.device;
let mut program=None;
let mut primary=None;
let mut filtered=None;
let mut filtered_path=None;
let source=if let Some(e)=settings {
let material=e.material.as_ref().context("environment radiance material")?;
let (baked,installed)=environment_program::install_source(r,scene,material,base)?;
primary=baked.primary;program=installed;
if primary.is_none() {
let path=cache::path(r,baked.identity);filtered=cache::Filtered::read(&path);filtered_path=Some(path);
}
baked.texture
} else {
let texture=environment_program::source_texture(r,[1,1]);
r.queue.write_texture(texture.as_image_copy(),bytemuck::cast_slice(&[0f32;8]),wgpu::TexelCopyBufferLayout {offset:0,bytes_per_row:Some(16),rows_per_image:Some(1)},texture.size());texture
};
let source_transport=primary.is_none() && scene.render.settings.integrator.is_path();
let proposal_needed=filtered.is_none() || program.is_some() || source_transport;
let evaluation=(settings.is_some() && primary.is_none()).then(||if proposal_needed {evaluated::Evaluation::new(r,&source)} else {evaluated::Evaluation::validation(r,&source)});
// Release preparation only constructs shaders/resources. The no-op
// device cannot evaluate radiance or produce readback metadata.
let (mut sh,filter_scale)=if r.release_preparation {([glam::DVec3::ZERO;4],1.)} else {
evaluation.as_ref().map(|e|e.update(r)).transpose()?.unwrap_or(([glam::DVec3::ZERO;4],1.))
};
if !proposal_needed {sh=filtered.as_ref().unwrap().sh.map(glam::DVec3::from_array);}
let [dw,dh]=evaluation.as_ref().map_or([1,1],|e|e.size);
let distribution=std::cell::OnceCell::new();
if let Some(buffer)=evaluation.as_ref().and_then(|e|e.distribution.clone()) {let _=distribution.set(buffer);}
// The shared filter layout needs a proposal even for first-device LUT
// initialization. A warm raster install dispatches neither, so creates none.
let proposal=||distribution.get_or_init(||init(d,"uniform environment proposal",bytemuck::cast_slice(&[[1f32,1./(4.*std::f32::consts::PI)]]),wgpu::BufferUsages::STORAGE));
let source=source.create_view(&Default::default());
let texture = |label, width, height, mips, format, usage| {
crate::gpu_memory::texture(
&d,
&wgpu::TextureDescriptor {
label: Some(label),
size: wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
},
mip_level_count: mips,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage,
view_formats: &[],
},
)
};
let sampler = d.create_sampler(&wgpu::SamplerDescriptor {
label: Some("lighting integrals linear longitude repeat"),
address_mode_u: wgpu::AddressMode::Repeat,
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Linear,
mipmap_filter: wgpu::MipmapFilterMode::Linear,
..Default::default()
});
let image_sampler=sampler.clone();
let usage = wgpu::TextureUsages::TEXTURE_BINDING
| wgpu::TextureUsages::STORAGE_BINDING
| wgpu::TextureUsages::COPY_SRC
| wgpu::TextureUsages::COPY_DST;
let size = if settings.is_some() && primary.is_none() {
crate::constants::ENVIRONMENT_WIDTH
} else {
1
};
let levels = if settings.is_some() && primary.is_none() {
crate::constants::ENVIRONMENT_LEVELS
} else {
1
};
let specular = texture(
"GGX environment mips",
size,
(size / 2).max(1),
levels,
wgpu::TextureFormat::Rgba16Float,
usage,
);
let diffuse = texture(
"First-order SH irradiance over pi",
crate::constants::DIFFUSE_SIZE[0],
crate::constants::DIFFUSE_SIZE[1],
1,
wgpu::TextureFormat::Rgba16Float,
usage,
);
let pipeline = Self::pipeline(r);
let integrate =
|encoder: &mut wgpu::CommandEncoder, target: &wgpu::Texture, mode: u32, mip: u32| {
let view = target.create_view(&wgpu::TextureViewDescriptor {
base_mip_level: mip,
mip_level_count: Some(1),
..Default::default()
});
let parameters = filter_parameters(mip, mode, filter_scale, sh, [dw, dh]);
let params = init(
d,
"environment integral parameters",
bytemuck::cast_slice(¶meters),
wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
);
let bind = d.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("environment filter"),
layout: &pipeline.get_bind_group_layout(0),
entries: &[
entry(0, wgpu::BindingResource::TextureView(&source)),
entry(1, wgpu::BindingResource::TextureView(&view)),
entry(2, params.as_entire_binding()),
entry(3, proposal().as_entire_binding()),
],
});
let integral = Integral {
bind,
params,
groups: [
(target.width() >> mip).max(1).div_ceil(8),
(target.height() >> mip).max(1).div_ceil(8),
],
};
if filtered.is_none() || mode == 2 {
integral.encode(encoder, pipeline);
}
integral
};
// The LUT is device-owned and scene-independent. OnceLock serializes its
// initialization, including submission, before another install can use it.
let brdf = r.brdf.get_or_init(|| {
let mut encoder = d.create_command_encoder(&Default::default());
let lut = texture(
"BRDF moments and dielectric directional albedo",
crate::constants::BRDF_SIZE,
crate::constants::BRDF_HEIGHT,
1,
wgpu::TextureFormat::Rgba16Float,
usage,
);
integrate(&mut encoder, &lut, 2, 0);
// Submit inside initialization so concurrent installs observe GPU queue
// ordering as well as the completed CPU initialization.
crate::command_finish::Segments::submit(&r.queue, encoder);
lut.create_view(&Default::default())
});
let mut encoder = d.create_command_encoder(&Default::default());
let mut integrals = Vec::new();
if settings.is_some() && primary.is_none() && (filtered.is_none() || program.is_some()) {
for (target, mode, mip) in (0..levels)
.map(|m| (&specular, 0u32, m))
.chain([(&diffuse, 1, 0)])
{
integrals.push(integrate(&mut encoder, target, mode, mip));
}
}
crate::command_finish::Segments::submit(&r.queue, encoder);
if let Some(cached) = &filtered {
cached.upload(r, &specular, &diffuse);
}
if filtered.is_none() {if let Some(path)=filtered_path {
cache::Filtered::capture(r,&specular,&diffuse,sh,path);
}}
// Immutable LTC fits are uploaded once per device, shared by every scene
// and frame slot. RGBA16F supports filtering on both Vulkan and Metal.
let ltc = r.ltc.get_or_init(|| {
let bytes = include_bytes!("ltc/amplitude.rgba32f");
{
let values: Vec<u16> = bytes
.chunks_exact(4)
.map(|v| {
half::f16::from_f32(f32::from_le_bytes(v.try_into().unwrap())).to_bits()
})
.collect();
let size = crate::constants::LTC_SIZE;
let texture = crate::gpu_memory::texture(
&d,
&wgpu::TextureDescriptor {
label: Some("LTC GGX and sheen fit"),
size: wgpu::Extent3d {
width: size,
height: size,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba16Float,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
},
);
r.queue.write_texture(
texture.as_image_copy(),
bytemuck::cast_slice(&values),
wgpu::TexelCopyBufferLayout {
offset: 0,
bytes_per_row: Some(size * 8),
rows_per_image: Some(size),
},
wgpu::Extent3d {
width: size,
height: size,
depth_or_array_layers: 1,
},
);
texture.create_view(&Default::default())
}
});
Ok(Self {
primary,
animated: program.map(|program| Animated {
program,
evaluation:evaluation.expect("animated environment evaluated state"),
integrals,
}),
initial_filter_scale:filter_scale,
settings: config,
mean: sh[0].as_vec3().to_array(),
node: None,
source,
distribution: source_transport.then(||proposal().clone()),
distribution_size: [dw,dh],
specular: specular.create_view(&Default::default()),
diffuse: diffuse.create_view(&Default::default()),
brdf: brdf.clone(),
ltc: ltc.clone(),
sampler,
image_sampler,
})
}
}
/// Cache the GPU-filtered importance image, not a full-resolution lookup table.
/// Rotation does not affect this unmodified radiance proposal.
/// Bindings shared by pipeline creation and native shader reflection checks.
pub(crate) fn layout_entries() -> [wgpu::BindGroupLayoutEntry; 4] {
let binding = |binding, ty| wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::COMPUTE,
ty,
count: None,
};
[
binding(
0,
wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Uint,
view_dimension: wgpu::TextureViewDimension::D2Array,
multisampled: false,
},
),
binding(
1,
wgpu::BindingType::StorageTexture {
access: wgpu::StorageTextureAccess::WriteOnly,
format: wgpu::TextureFormat::Rgba16Float,
view_dimension: wgpu::TextureViewDimension::D2,
},
),
binding(
2,
wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: wgpu::BufferSize::new(96),
},
),
binding(
3,
wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Storage { read_only: true },
has_dynamic_offset: false,
min_binding_size: wgpu::BufferSize::new(8),
},
),
]
}
// One constructor owns the 96-byte shader ABI for installation and animation.
// Upload the reciprocal: shaders never divide by a runtime buffer field.
fn filter_parameters(mip: u32, mode: u32, scale: f32, sh: [glam::DVec3; 4], size: [u32; 2]) -> [[f32; 4]; 6] {
assert!(scale.is_finite() && scale >= 1.);
assert!(size.into_iter().all(|n| n > 0));
let inverse = scale.recip();
assert!(inverse.is_finite() && inverse > 0.);
[
[mip as f32 / 5., mode as f32, inverse, 0.],
(sh[0] / scale as f64).as_vec3().extend(0.).to_array(),
(sh[1] / scale as f64).as_vec3().extend(0.).to_array(),
(sh[2] / scale as f64).as_vec3().extend(0.).to_array(),
(sh[3] / scale as f64).as_vec3().extend(0.).to_array(),
[size[0] as f32, size[1] as f32, 0., 0.],
]
}
#[cfg(test)]
fn radiance_scale(image: &image::Rgb32FImage) -> f32 {
(image.as_raw().iter().copied().fold(0f32,f32::max) / (crate::constants::HALF_FLOAT_MAX*0.5)).max(1.)
}
// Full source RGB remains available to the camera. Alpha records the selected
// core's chromatic residual fraction, applied per texel before interpolation.
#[cfg(test)]
fn source_rgba(camera:&image::Rgb32FImage,lighting:&image::Rgb32FImage)->Vec<f32> {
camera.pixels().chain(lighting.pixels()).flat_map(|p|[p[0],p[1],p[2],1.]).collect()
}
/// First-order radiance moments; source splitting is an authoring operation.
#[cfg(test)]
fn analyze(image: &image::Rgb32FImage) -> [glam::DVec3;4] {
let mut sh = [glam::DVec3::ZERO; 4];
// Solid-angle quadrature over the HDR: isolate the bright lobe's
// radiometric energy and RGB-magnitude-weighted direction. Uses the same
// equirectangular integration math as the CDF below.
let width = image.width();
let height = image.height();
let longitude: Vec<_> = (0..width).map(|x| {
let phi = std::f64::consts::TAU * ((x as f64 + 0.5) / width as f64 - 0.5);
(phi.cos(), phi.sin())
}).collect();
for y in 0..height {
let omega = std::f64::consts::TAU / width as f64
* ((std::f64::consts::PI * y as f64 / height as f64).cos()
- (std::f64::consts::PI * (y + 1) as f64 / height as f64).cos());
let theta = std::f64::consts::PI * (y as f64 + 0.5) / height as f64;
let (sin_theta, cos_theta) = (theta.sin(), theta.cos());
for x in 0..width {
let pixel = image.get_pixel(x,y);
let radiance = glam::DVec3::new(pixel[0] as f64, pixel[1] as f64, pixel[2] as f64);
let (cos_phi,sin_phi) = longitude[x as usize];
let direction = glam::DVec3::new(sin_theta*cos_phi,cos_theta,sin_theta*sin_phi);
{
let residual = radiance;
// Lookup applies environment rotation; retain local coefficients.
let local_direction = direction;
sh[0] += residual * (omega / (4. * std::f64::consts::PI));
for axis in 0..3 {
sh[axis + 1] +=
residual * local_direction[axis] * (omega / (2. * std::f64::consts::PI));
}
}
}
}
// Dering the first-order reconstruction with one shared factor,
// preserving hue and keeping every channel nonnegative for all n.
let mut factor = 1f64;
for channel in 0..3 {
let amplitude = glam::DVec3::new(sh[1][channel], sh[2][channel], sh[3][channel]).length();
factor = factor.min(
sh[0][channel]
/ (amplitude * (1. + 0.05 / (crate::constants::SH_FIRST_ORDER * (2. / 3.))))
.max(crate::constants::POSITIVE_EPSILON_F64),
);
}
for coefficient in &mut sh[1..] {
*coefficient *= factor;
}
sh
}
#[cfg(test)]
fn distribution(dw: u32, dh: u32, proposal: &[f32]) -> Vec<[f32; 2]> {
// Radiance-weighted solid-angle distribution, built at install time.
let mut distribution = Vec::<[f64; 2]>::with_capacity((dw * dh) as usize);
let mut total = 0f64;
let columns: Vec<_> = (0..dw).map(|x| [-1i32,0,1].map(|dx|
(x as i32+dx).rem_euclid(dw as i32) as usize)).collect();
for y in 0..dh {
let solid_angle = std::f64::consts::TAU / dw as f64
* ((std::f64::consts::PI * y as f64 / dh as f64).cos()
- (std::f64::consts::PI * (y + 1) as f64 / dh as f64).cos());
let rows = [-1i32,0,1].map(|dy|
(y as i32+dy).clamp(0,dh as i32-1) as usize*dw as usize);
for x in 0..dw {
// Keep each RGB sum's order, but share address/alpha preparation
// between channels and hoist coordinate wrapping out of the stencil.
let mut rgb = [0f64;3];
for (dy,row) in rows.into_iter().enumerate() {
for (dx,column) in columns[x as usize].into_iter().enumerate() {
let at=(row+column)*4;
let alpha=proposal[at+3] as f64;
let wx=if dx==1 {2.} else {1.};
let wy=if dy==1 {2.} else {1.};
for c in 0..3 { rgb[c]+=proposal[at+c] as f64*alpha*wx*wy; }
}
}
let rgb=rgb.map(|v|v/16.);
let luminance = crate::constants::LUMINANCE_REC709[0] as f64 * rgb[0]
+ crate::constants::LUMINANCE_REC709[1] as f64 * rgb[1]
+ crate::constants::LUMINANCE_REC709[2] as f64 * rgb[2];
total += luminance * solid_angle;
distribution.push([total, luminance]);
}
}
if total > 0. {
let mut result:Vec<[f32;2]>=distribution.into_iter().map(|v|[(v[0]/total) as f32,(v[1]/total) as f32]).collect();
result.last_mut().unwrap()[0] = 1.;
return result;
} else {
// Black environments use a uniform sphere proposal.
let mut result=vec![[0f32;2];distribution.len()];
for (i, value) in result.iter_mut().enumerate() {
let y = i as u32 / dw;
let row = (1. - (std::f32::consts::PI * y as f32 / dh as f32).cos()) / 2.;
let next = (1. - (std::f32::consts::PI * (y + 1) as f32 / dh as f32).cos()) / 2.;
*value = [
row + (next - row) * ((i as u32 % dw + 1) as f32 / dw as f32),
1. / (4. * std::f32::consts::PI),
];
}
result
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
#[ignore="requires real GPU"]
fn gpu_environment_moments_and_cdf_match_numerical_references()->Result<()> {
let r=Renderer::new()?;
let varying=image::Rgb32FImage::from_fn(17,9,|x,y|image::Rgb([(x+1) as f32*10000.,(y+1) as f32*5000.,(x*y+1) as f32]));
let black=image::Rgb32FImage::new(17,9);
let hdr=image::Rgb32FImage::from_fn(8,4,|x,y|image::Rgb([(0.5+((y*8+x)%3) as f32*0.5)*1e38,1e38,2e38]));
let mut seam=image::Rgb32FImage::new(8,4);seam.put_pixel(0,2,image::Rgb([2e6,0.,0.]));
for image in [varying,black,hdr,seam] {
let (width,height)=image.dimensions();
let data=source_rgba(&image,&image);
let source=environment_program::source_texture(&r,[width,height]);
r.queue.write_texture(source.as_image_copy(),bytemuck::cast_slice(&data),wgpu::TexelCopyBufferLayout {offset:0,bytes_per_row:Some(width*16),rows_per_image:Some(height)},source.size());
let evaluated=evaluated::Evaluation::new(&r,&source);let (actual,scale)=evaluated.update(&r)?;
assert!((scale-radiance_scale(&image)).abs()<1e-5+1e-6*radiance_scale(&image));
let reference=analyze(&image);
// Signed moments can cancel to zero. Float32 reduction/trigonometric
// roundoff scales with integrated channel energy, not that residual.
for (a,b) in actual.into_iter().zip(reference) {for c in 0..3 {
if reference[0][c]==0. {assert_eq!(a[c],0.,"empty channel acquired energy");}
else {assert!((a[c]-b[c]).abs()<0.02+2e-6*reference[0][c].abs().max(b[c].abs()),"{a:?} != {b:?}");}
}}
let expected=distribution(width,height,&data[data.len()/2..]);
let size=expected.len() as u64*8;
let read=crate::gpu_memory::buffer(&r.device,&wgpu::BufferDescriptor {label:Some("CDF oracle"),size,usage:wgpu::BufferUsages::MAP_READ|wgpu::BufferUsages::COPY_DST,mapped_at_creation:false});
let mut encoder=r.device.create_command_encoder(&Default::default());encoder.copy_buffer_to_buffer(evaluated.distribution.as_ref().unwrap(),0,&read,0,size);r.queue.submit([encoder.finish()]);
let(tx,rx)=std::sync::mpsc::channel();read.map_async(wgpu::MapMode::Read,..,move |v|{let _=tx.send(v);});r.wait(None)?;rx.recv()??;
let mapped=read.get_mapped_range(..);let values:&[[f32;2]]=bytemuck::cast_slice(&mapped);
for (a,b) in values.iter().zip(expected) {for c in 0..2 {assert!((a[c]-b[c]).abs()<2e-6,"CDF {a:?} != {b:?}");}}
}
Ok(())
}
#[test]
#[ignore="requires real GPU"]
fn warm_raster_cache_skips_proposal_and_matches_path_energy()->Result<()> {
let r=Renderer::new()?;
let fixtures=Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures");
let mut input:serde_json::Value=vork_scene::v2::with_test_settings(include_str!("../tests/fixtures/analytic.json"),include_str!("../tests/presets/analytic-7fefd52a.json"))?;
input["animation"]=serde_json::json!([]);
input["render"]=serde_json::json!({"resolution":[8,8],"settings":{"integrator":"raster","samples":64,"denoiser":null}});
input["programs"]=serde_json::json!({"world":{"source":"struct Inputs {}; float3 environment(EnvironmentContext c,Inputs i){return float3(1.);}"}});
input["materials"]=serde_json::json!({"world":{"program":"world"},"white":{"inputs":{"base_color":[1,1,1],"specular_weight":0}}});
input["nodes"]=serde_json::json!([
{"name":"camera","type":"camera","translation":[0,0,5],"material":{"program":"std/camera","inputs":{"projection":"ortho","ortho_scale":0.1}}},
{"type":"mesh","geometry":"shape_box","materials":["white"],"scale":[20,20,0.25]},
{"type":"light","shape":"environment","material":"world","energy":1,"color":[1,1,1]}]);
let render=|scene:&InstalledScene|->Result<Vec<[f32;4]>> {
let mut frame=scene.create_frame_slot(&r,ReadbackPrecision::Float)?;
frame.submit_outputs(scene,&r,0.,ReadbackOutputs {float:FloatOutputs {color:true,..Default::default()},..Default::default()})?;
Ok(frame.collect(&r)?.linear_rgba.context("linear pixels")?)
};
// Seed the normal cache and wait only in the test for optional persistence.
let cold=r.install(vork_scene::v2::from_test_value(input.clone())?,&fixtures)?;
let original=render(&cold)?;
r.wait(None)?;
disk_cache::wait_persistence()?;
let (warm,allocations)=crate::gpu_memory::test_buffer_allocations(||r.install(vork_scene::v2::from_test_value(input.clone())?,&fixtures));
let warm=warm?;
assert!(!allocations.iter().any(|label|label=="uniform environment proposal"),"complete warm install allocated a dummy: {allocations:?}");
assert_eq!(warm.environment.distribution_size,[1,1],"warm raster allocated a proposal");
assert!(warm.environment.distribution.is_none());
let cached=render(&warm)?;
for (a,b) in cached.iter().zip(&original) {for c in 0..3 {assert!((a[c]-b[c]).abs()<1e-5,"cached raster changed energy: {a:?} {b:?}");}}
// Exercise the validation-only GPU path and its actual allocation/dispatch
// plan independently of the cached metadata used for lighting.
let source=environment_program::install_source(&r,&warm.scene,"world",&fixtures)?.0;
let validation=evaluated::Evaluation::validation(&r,&source.texture);
assert_eq!(validation.work(),(false,0,2),"warm validation must allocate no proposal/CDF and dispatch only peaks and summary");
assert_eq!(validation.update(&r)?.1,warm.environment.initial_filter_scale());
for invalid in [-1.,f32::NAN] {
r.queue.write_texture(source.texture.as_image_copy(),bytemuck::cast_slice(&[invalid,0.,0.,1.]),wgpu::TexelCopyBufferLayout {offset:0,bytes_per_row:Some(16),rows_per_image:Some(1)},extent(1,1));
assert!(validation.update(&r).is_err(),"warm source validation accepted {invalid}");
}
input["render"]["settings"]["integrator"]=serde_json::json!("path");
input["render"]["settings"]["samples"]=serde_json::json!(256);
let path=r.install(vork_scene::v2::from_test_value(input)?,&fixtures)?;
assert_ne!(path.environment.distribution_size,[1,1],"warm path lost its proposal");
let reference=render(&path)?;
for c in 0..3 {
let mean=|pixels:&Vec<[f32;4]>|pixels.iter().map(|p|p[c] as f64).sum::<f64>()/pixels.len() as f64;
let raster=mean(&cached);let path=mean(&reference);
eprintln!("cached raster / std/path energy channel {c}: {raster} / {path}");
assert!((path-1.).abs()<0.03 && (raster-path).abs()<0.03,"raster {raster}, path {path}");
}
r.errors.check()?;Ok(())
}
#[test]
#[ignore="requires real GPU"]
fn held_environment_inputs_skip_production_evaluation()->Result<()> {
let r=Renderer::new()?;
let scene=vork_scene::v2::from_test_value(serde_json::json!({"version":2,
"programs":{"world":{"source":"struct Inputs {float gain=1.;}; float3 environment(EnvironmentContext c,Inputs i){return float3(i.gain);}"}},
"materials":{"world":{"program":"world"}},
"nodes":[{"type":"light","shape":"environment","material":"world"}],
"animation":[{"tracks":[{"path":["materials","world","inputs","gain"],"interpolation":"STEP","keys":[[0,1],[1,2]]}]}]}))?;
let environment=Environment::new(&r,environment_node::Settings::from_scene(&scene)?,&scene,Path::new("."))?;
let mut changes=values::LightingTracker::default();
environment.update(&r,0.,&mut changes)?;
let program=&environment.animated.as_ref().context("animated environment")?.program;
// Perturb the GPU source without touching the production change tracker.
// A held update must leave it alone, proving evaluation itself was skipped.
let source=program.evaluate_source(&r,1.)?;
environment.update(&r,0.9,&mut changes)?;
assert!(source.read(&r)?.image.pixels().all(|p|p.0==[2.;3]));
program.evaluate_source(&r,0.)?;
environment.update(&r,1.,&mut changes)?;
assert!(source.read(&r)?.image.pixels().all(|p|p.0==[2.;3]));
r.errors.check()?;Ok(())
}
#[test]
#[ignore="requires real GPU"]
fn animated_metadata_matches_path_energy_across_queued_slots_and_rewinds()->Result<()> {
let mut r=Renderer::new()?;
// Match the existing numerical transport oracle: production path firefly
// clamps deliberately bias HDR energy, so disable them for this check.
r.reference_transport_bounces=Some(64);
let fixtures=Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures");
let base:serde_json::Value=vork_scene::v2::with_test_settings(include_str!("../tests/fixtures/analytic.json"),include_str!("../tests/presets/analytic-7fefd52a.json"))?;
let mut reference=None;
for path in [true,false] {for scenario in ["plain","capture"] {
let capture=scenario=="capture";
let high=40000.;
let mut input=base.clone();input["animation"]=serde_json::json!([]);
input["render"]=serde_json::json!({"camera":"camera","resolution":[8,8],"background":"environment","settings":{"integrator":if path {"path"} else {"raster"},"denoiser":null,"samples":128}});
if !path {input["render"]["settings"]["fast_gi"]=serde_json::Value::Null;input["render"]["settings"]["reflections"]=serde_json::json!("environment");}
input["programs"]=serde_json::json!({"world":{"source":format!("struct Inputs {{}}; float3 environment(EnvironmentContext c,Inputs i){{return float3(c.time<.5?1.:c.time<1.5?{high:.1}:2.);}}")}});
input["materials"]=serde_json::json!({"world":{"program":"world"},"white":{"inputs":{"base_color":[1,1,1],"specular_weight":0}}});
input["nodes"]=serde_json::json!([
{"type":"camera","name":"camera","translation":[0,0,5],"material":{"program":"std/camera","inputs":{"projection":"ortho","ortho_scale":0.1}}},
{"type":"mesh","geometry":"shape_box","materials":["white"],"scale":[20,20,0.25]},
{"type":"light","shape":"environment","material":"world","energy":2,"color":[0.5,0.375,0.25]}]);
if capture {
input["images"]=serde_json::json!({"capture":{"render":{"camera":"camera","resolution":[8,8],"background":"environment"}}});
input["programs"]["copy"]=serde_json::json!({"source":"struct Inputs {Image source;}; float4 composite(CompositeContext c,Inputs i){return compositor_load(i.source,int2(c.uv*c.size));}"});
input["materials"]["copy"]=serde_json::json!({"program":"copy","inputs":{"source":{"image":"capture"}}});
input["render"]["compositor"]=serde_json::json!(["copy"]);
}
// Cross the filter scale threshold within the existing sample
// output format. Medium mean consumption has its own oracle below.
let installed=r.install(vork_scene::v2::from_test_value(input)?,&fixtures)?;
let mut slots=[installed.create_frame_slot(&r,ReadbackPrecision::Float)?,installed.create_frame_slot(&r,ReadbackPrecision::Float)?];
let outputs=ReadbackOutputs {float:FloatOutputs {color:true,..Default::default()},..Default::default()};
slots[0].submit_outputs(&installed,&r,0.,outputs)?;
slots[1].submit_outputs(&installed,&r,1.,outputs)?;
for (index,time,gain) in [(0,0.,1.),(1,1.,high),(0,2.,2.),(0,0.,1.)] {
let pixels=slots[index].collect(&r)?.linear_rgba.unwrap();
let mean:[f64;3]=std::array::from_fn(|c|pixels.iter().map(|p|p[c] as f64/gain).sum::<f64>()/pixels.len() as f64);
if reference.is_none() {for c in 0..3 {assert!((mean[c]/[1.,0.75,0.5][c]-1.).abs()<0.03,"std/path white energy {mean:?}");} reference=Some(mean);}
let expected=reference.unwrap();
for c in 0..3 {assert!((mean[c]/expected[c]-1.).abs()<0.03,"path={path} scenario={scenario} time={time}: {mean:?} vs std/path {expected:?}");}
eprintln!("animated energy path={path} scenario={scenario} time={time}: {mean:?}");
if index==1 {slots[0].submit_outputs(&installed,&r,2.,outputs)?;}
else if time==2. {slots[0].submit_outputs(&installed,&r,0.,outputs)?;}
}
}}
r.errors.check()?;Ok(())
}
#[test]
#[ignore="requires real GPU"]
fn animated_gpu_mean_feeds_production_medium_illumination()->Result<()> {
let r=Renderer::new()?;
let scene=vork_scene::v2::from_test_value(serde_json::json!({"version":2,
"programs":{"world":{"source":"struct Inputs {}; float3 environment(EnvironmentContext c,Inputs i){return float3(c.time<.5?1.:c.time<1.5?100000.:2.);}"}},
"materials":{"world":{"program":"world"}},"nodes":[{"type":"light","shape":"environment","material":"world"}]}))?;
let environment=Environment::new(&r,environment_node::Settings::from_scene(&scene)?,&scene,Path::new("."))?;
// Exercise the actual mean consumer without conflating single-scattering
// raster transport with the multiple-scattering path reference above.
let source=r#"import vork_prelude;
import vork_medium_visibility;
[[vk::binding(0,0)]] ConstantBuffer<Frame> parameters;
[[vk::binding(1,0)]] RWStructuredBuffer<float4> output;
export Frame medium_frame(){return parameters;}
export uint medium_light_list(float3 p,out uint base){base=0u;return 0u;}
export uint medium_light_index(uint base,uint next){return 0u;}
export Light medium_light(uint index){Light light={};return light;}
[shader("compute")][numthreads(1,1,1)] void numerical_test(uint3 id:SV_DispatchThreadID){output[0]=float4(medium_shared_illumination(float3(0.),float3(0.,0.,1.),0.),0.);}
"#;
let entries=[pipelines::buffer_entry(0,wgpu::ShaderStages::COMPUTE,wgpu::BufferBindingType::Uniform),pipelines::buffer_entry(1,wgpu::ShaderStages::COMPUTE,wgpu::BufferBindingType::Storage {read_only:false})];
let pipeline=crate::medium::test_pipeline(&r,source,&crate::medium::Native::default(),&entries,(1,1,1))?;
let mut uniform=Uniform::zeroed();uniform.medium[3]=1;uniform.environment[0]=2.;uniform.environment_color=[0.5,0.375,0.25,0.];
let params=init(&r.device,"medium mean oracle frame",bytemuck::bytes_of(&uniform),wgpu::BufferUsages::UNIFORM|wgpu::BufferUsages::COPY_DST);
let output=init(&r.device,"medium mean oracle output",bytemuck::bytes_of(&[0f32;4]),wgpu::BufferUsages::STORAGE|wgpu::BufferUsages::COPY_SRC);
let read=crate::gpu_memory::buffer(&r.device,&wgpu::BufferDescriptor {label:Some("medium mean readback"),size:16,usage:wgpu::BufferUsages::MAP_READ|wgpu::BufferUsages::COPY_DST,mapped_at_creation:false});
let bind=r.device.create_bind_group(&wgpu::BindGroupDescriptor {label:None,layout:&pipeline.get_bind_group_layout(0),entries:&[entry(0,params.as_entire_binding()),entry(1,output.as_entire_binding())]});
let mut changes=values::LightingTracker::default();
for (time,gain) in [(0.,1.),(1.,100000.),(2.,2.),(0.,1.)] {
environment.update(&r,time,&mut changes)?;
let mut encoder=r.device.create_command_encoder(&Default::default());
environment.publish_metadata(&mut encoder,¶ms);
{let mut pass=encoder.begin_compute_pass(&Default::default());pass.set_pipeline(&pipeline);pass.set_bind_group(0,&bind,&[]);pass.dispatch_workgroups(1,1,1);}
encoder.copy_buffer_to_buffer(&output,0,&read,0,16);r.queue.submit([encoder.finish()]);
let(tx,rx)=std::sync::mpsc::channel();read.map_async(wgpu::MapMode::Read,..,move |v|{let _=tx.send(v);});r.wait(None)?;rx.recv()??;
let mapped=read.get_mapped_range(..);let value:&[f32]=bytemuck::cast_slice(&mapped);
let actual:[f32;3]=std::array::from_fn(|c|value[c]/gain);
// Allow the latitude quadrature integration error (about 9e-5).
for c in 0..3 {assert!((actual[c]/[1.,0.75,0.5][c]-1.).abs()<2e-4,"medium incident energy time={time}: {actual:?}");}
eprintln!("medium incident energy time={time}: {actual:?}");
drop(mapped);read.unmap();
}
r.errors.check()?;Ok(())
}
#[test]
#[ignore="requires real GPU"]
fn animated_environment_rejects_earlier_invalid_shutter_samples_and_recovers()->Result<()> {
let r=Renderer::new()?;
let last=1.+crate::sampling::shutter_time(7,8)-0.5;
for invalid in ["-1.","asfloat(0x7fc00000u)"] {
let source=format!("struct Inputs {{}}; float3 environment(EnvironmentContext c,Inputs i){{return float3(c.time>=.5 && c.time<=1.5 && abs(c.time-{last:.9})>.001 ? {invalid} : 1.);}}");
let input=serde_json::json!({"version":2,
"render":{"resolution":[8,8],"fps":1,"background":"environment","motion_blur":{"shutter":1},"settings":{"samples":8,"denoiser":null,"fast_gi":null,"reflections":"environment"}},
"programs":{"world":{"source":source}},"materials":{"world":{"program":"world"}},
"nodes":[{"type":"camera"},{"type":"light","shape":"environment","material":"world"}]});
let installed=r.install(vork_scene::v2::from_test_value(input)?,Path::new("."))?;
assert_eq!(installed.plan.exposure_samples,8);
let mut slot=installed.create_frame_slot(&r,ReadbackPrecision::Float)?;
let outputs=ReadbackOutputs {float:FloatOutputs {color:true,..Default::default()},..Default::default()};
slot.submit_outputs(&installed,&r,1.,outputs)?;
let error=slot.collect(&r).err().context("invalid earlier shutter sample was accepted")?;
assert!(error.to_string().contains("radiance must be finite and nonnegative"),"{error:#}");
assert!(installed.environment.sampled_mean(&r)?.iter().all(|v|v.is_finite() && *v>0.),"last sample must be valid so diagnostics prove accumulation");
slot.submit_outputs(&installed,&r,3.,outputs)?;
assert!(slot.collect(&r)?.linear_rgba.unwrap().iter().flatten().all(|v|v.is_finite()));
}
r.errors.check()?;Ok(())
}
#[test]
fn source_storage_cannot_use_a_filtering_sampler() {
let entries=layout_entries();
assert!(!entries.iter().any(|e| matches!(e.ty,wgpu::BindingType::Sampler(_))));
// Native SPIR-V bypasses wgpu's dense Vulkan binding remap.
for (index,entry) in entries.iter().enumerate() {assert_eq!(entry.binding,index as u32);}
for entry in [entries[0],REDUCE_LAYOUT[0]] {
assert!(matches!(entry.ty,wgpu::BindingType::Texture {
sample_type:wgpu::TextureSampleType::Uint,..
}));
}
assert_eq!(SOURCE_FORMAT,wgpu::TextureFormat::Rgba32Uint);
}
#[test]
fn source_layers_keep_independent_full_precision_radiance() {
let full=image::Rgb32FImage::from_raw(2,1,vec![2e6,1e6,5e5,12.,16.,20.]).unwrap();
let residual=image::Rgb32FImage::from_raw(2,1,vec![20.,10.,5.,12.,16.,20.]).unwrap();
let packed=source_rgba(&full,&residual);
assert_eq!(packed,vec![2e6,1e6,5e5,1.,12.,16.,20.,1.,20.,10.,5.,1.,12.,16.,20.,1.]);
}
#[test]
fn proposal_normalization_preserves_float32_hdr_range() {
let original:Vec<f32>=(0..8*4).flat_map(|i|[0.5+(i%3) as f32*0.5,1.,2.,1.]).collect();
let scaled:Vec<f32>=original.chunks_exact(4).flat_map(|p|[p[0]*1e38,p[1]*1e38,p[2]*1e38,p[3]]).collect();
let a=distribution(8,4,&original);let b=distribution(8,4,&scaled);
for (a,b) in a.iter().zip(b) {for k in 0..2 {assert!(b[k].is_finite() && (a[k]-b[k]).abs()<1e-7);}}
}
#[test]
fn proposal_support_covers_bilinear_neighbors_and_longitude_seam() {
let mut image=vec![0f32;8*4*4];image[(2*8)*4]=2e6;image[(2*8)*4+3]=1.;
let cdf=distribution(8,4,&image);
for y in 1..=3 {for x in [7,0,1] {
let at=y*8+x;let mass=cdf[at][0]-if at>0 {cdf[at-1][0]} else {0.};
assert!(mass>0.,"cell {x},{y}");
}}
}
#[test]
fn filter_parameters_preserve_hdr_scale_and_abi() {
for scale in [1., 2., 1000., f32::MAX] {
let p = filter_parameters(3, 0, scale, [glam::DVec3::splat(2.); 4], [64, 32]);
assert_eq!(std::mem::size_of_val(&p), 96);
assert!(p[0][2].is_finite() && p[0][2] > 0.);
assert!((p[0][2] as f64 * scale as f64 - 1.).abs() < 1e-6);
assert_eq!(p[5], [64., 32., 0., 0.]);
assert_eq!(p[1][0], (2. / scale as f64) as f32);
}
for scale in [0., -1., f32::NAN, f32::INFINITY] {
assert!(std::panic::catch_unwind(|| filter_parameters(0, 0, scale, [glam::DVec3::ZERO; 4], [1, 1])).is_err());
}
}
// Instrument the undefined intrinsic domain so Vulkan's benign atan2(0,0)
// cannot conceal the Metal failure. Exercise the production mapping itself.
#[test]
#[ignore = "requires GPU and pinned Slang"]
fn equirect_poles_never_evaluate_undefined_longitude() -> Result<()> {
let r=Renderer::new()?;let d=&r.device;
let prelude=include_str!("../shaders/vork_prelude.slang");
let mapping=prelude.split("float2 equirect_uv(").nth(1).unwrap().split("float2 environment_uv(").next().unwrap();
let mapping=format!("float2 checked_equirect_uv({mapping}").replace("atan2(","checked_atan2(");
let shader=format!(r#"
import vork_prelude;
import vork_constants;
[[vk::binding(0,0)]] RWStructuredBuffer<float4> result;
float checked_atan2(float y,float x) {{
if (x==0. && y==0.) {{result[0]=float4(0.);return asfloat(0x7fc00000u);}}
return atan2(y,x);
}}
{mapping}
[shader("compute")][numthreads(1,1,1)] void numerical_test(uint3 id:SV_DispatchThreadID) {{
result[0]=float4(1.);
for (uint i=0u;i<8u;i++) {{
let x=asfloat((i&1u)*0x80000000u);let z=asfloat((i&2u)*0x40000000u);
let direction=float3(x,i<4u ? 1. : -1.,z);
result[1u+i]=float4(checked_equirect_uv(direction),equirect_uv(direction));
}}
result[9]=float4(checked_equirect_uv(float3(1.,0.,0.)),checked_equirect_uv(float3(0.,0.,1.)));
}}
"#);
let entries=[crate::pipelines::buffer_entry(0,wgpu::ShaderStages::COMPUTE,wgpu::BufferBindingType::Storage {read_only:false})];
let pipeline=crate::medium::test_pipeline(&r,&shader,&crate::medium::Native::default(),&entries,(1,1,1))?;
let output=d.create_buffer(&wgpu::BufferDescriptor {label:None,size:160,usage:wgpu::BufferUsages::STORAGE|wgpu::BufferUsages::COPY_SRC,mapped_at_creation:false});
let read=d.create_buffer(&wgpu::BufferDescriptor {label:None,size:160,usage:wgpu::BufferUsages::MAP_READ|wgpu::BufferUsages::COPY_DST,mapped_at_creation:false});
let bind=d.create_bind_group(&wgpu::BindGroupDescriptor {label:None,layout:&pipeline.get_bind_group_layout(0),entries:&[entry(0,output.as_entire_binding())]});
let mut encoder=d.create_command_encoder(&Default::default());
{let mut pass=encoder.begin_compute_pass(&Default::default());pass.set_pipeline(&pipeline);pass.set_bind_group(0,&bind,&[]);pass.dispatch_workgroups(1,1,1);}
encoder.copy_buffer_to_buffer(&output,0,&read,0,160);r.queue.submit([encoder.finish()]);
let(tx,rx)=std::sync::mpsc::channel();read.map_async(wgpu::MapMode::Read,..,move |v|{let _=tx.send(v);});r.wait(None)?;rx.recv()??;
let mapped=read.get_mapped_range(..);let results:&[[f32;4]]=bytemuck::cast_slice(&mapped);
assert_eq!(results[0],[1.;4],"equirectangular mapping evaluated atan2(0,0)");
for i in 0..8 {let v=if i<4 {0.} else {1.};assert_eq!(results[i+1],[0.5,v,0.5,v]);}
assert_eq!(results[9],[0.5,0.5,0.75,0.5]);
Ok(())
}
#[test]
#[ignore = "requires GPU and pinned Slang"]
fn filtered_environment_writes_sh_without_source_sampling() -> Result<()> {
let r=Renderer::new()?;let d=&r.device;
let source=d.create_texture(&wgpu::TextureDescriptor {label:None,
size:wgpu::Extent3d {width:1,height:1,depth_or_array_layers:2},
mip_level_count:1,sample_count:1,dimension:wgpu::TextureDimension::D2,
format:SOURCE_FORMAT,usage:wgpu::TextureUsages::TEXTURE_BINDING,view_formats:&[]});
let output=d.create_texture(&wgpu::TextureDescriptor {label:None,
size:wgpu::Extent3d {width:1,height:1,depth_or_array_layers:1},
mip_level_count:1,sample_count:1,dimension:wgpu::TextureDimension::D2,
format:wgpu::TextureFormat::Rgba16Float,
usage:wgpu::TextureUsages::STORAGE_BINDING|wgpu::TextureUsages::COPY_SRC,view_formats:&[]});
let parameters=[[0f32,1.,1.,0.],[0.5,0.25,0.125,0.],[0.;4],[0.;4],[0.;4],[1.,1.,0.,0.]];
let params=init(d,"SH fixture",bytemuck::cast_slice(¶meters),wgpu::BufferUsages::UNIFORM);
let cdf=init(d,"SH unused CDF",bytemuck::cast_slice(&[1f32,1.]),wgpu::BufferUsages::STORAGE);
let source_view=source.create_view(&Default::default());let view=output.create_view(&Default::default());
let pipeline=Environment::pipeline(&r);
let bind=d.create_bind_group(&wgpu::BindGroupDescriptor {label:None,layout:&pipeline.get_bind_group_layout(0),entries:&[
entry(0,wgpu::BindingResource::TextureView(&source_view)),entry(1,wgpu::BindingResource::TextureView(&view)),entry(2,params.as_entire_binding()),entry(3,cdf.as_entire_binding())]});
let read=d.create_buffer(&wgpu::BufferDescriptor {label:None,size:256,usage:wgpu::BufferUsages::MAP_READ|wgpu::BufferUsages::COPY_DST,mapped_at_creation:false});
let mut encoder=d.create_command_encoder(&Default::default());
{let mut pass=encoder.begin_compute_pass(&Default::default());pass.set_pipeline(pipeline);pass.set_bind_group(0,&bind,&[]);pass.dispatch_workgroups(1,1,1);}
encoder.copy_texture_to_buffer(output.as_image_copy(),wgpu::TexelCopyBufferInfo {buffer:&read,layout:wgpu::TexelCopyBufferLayout {offset:0,bytes_per_row:Some(256),rows_per_image:Some(1)}},output.size());
r.queue.submit([encoder.finish()]);
let(tx,rx)=std::sync::mpsc::channel();read.map_async(wgpu::MapMode::Read,..,move |v|{let _=tx.send(v);});r.wait(None)?;rx.recv()??;
let mapped=read.get_mapped_range(..);
let actual:Vec<f32>=mapped[..8].chunks_exact(2).map(|v|half::f16::from_bits(u16::from_le_bytes(v.try_into().unwrap())).to_f32()).collect();
assert_eq!(actual,[0.5,0.25,0.125,1.]);
Ok(())
}
#[test]
#[ignore = "requires GPU and pinned Slang"]
fn filtered_environment_preserves_constant_hdr_in_every_mode() -> Result<()> {
let r=Renderer::new()?;let d=&r.device;
let source=d.create_texture(&wgpu::TextureDescriptor {label:None,
size:wgpu::Extent3d {width:1,height:1,depth_or_array_layers:2},
mip_level_count:1,sample_count:1,dimension:wgpu::TextureDimension::D2,
format:SOURCE_FORMAT,usage:wgpu::TextureUsages::TEXTURE_BINDING|wgpu::TextureUsages::COPY_DST,view_formats:&[]});
let output=d.create_texture(&wgpu::TextureDescriptor {label:None,
size:wgpu::Extent3d {width:1,height:2,depth_or_array_layers:1},
mip_level_count:1,sample_count:1,dimension:wgpu::TextureDimension::D2,
format:wgpu::TextureFormat::Rgba16Float,
usage:wgpu::TextureUsages::STORAGE_BINDING|wgpu::TextureUsages::COPY_SRC,view_formats:&[]});
r.queue.write_texture(source.as_image_copy(), bytemuck::cast_slice(&[4e6f32,2e6,1e6,1.,2e6,1e6,5e5,1.]), wgpu::TexelCopyBufferLayout {offset:0,bytes_per_row:Some(16),rows_per_image:Some(1)}, source.size());
for (mode,mip) in [(1,0),(0,0),(0,1),(0,3),(0,5)] {
let parameters=filter_parameters(mip,mode,4e6,[glam::DVec3::new(2e6,1e6,5e5),glam::DVec3::ZERO,glam::DVec3::ZERO,glam::DVec3::ZERO],[1,1]);
let params=init(d,"SH fixture",bytemuck::cast_slice(¶meters),wgpu::BufferUsages::UNIFORM);
let cdf=init(d,"SH unused CDF",bytemuck::cast_slice(&[1f32,1.]),wgpu::BufferUsages::STORAGE);
let source_view=source.create_view(&Default::default());let view=output.create_view(&Default::default());
let pipeline=Environment::pipeline(&r);
let bind=d.create_bind_group(&wgpu::BindGroupDescriptor {label:None,layout:&pipeline.get_bind_group_layout(0),entries:&[
entry(0,wgpu::BindingResource::TextureView(&source_view)),entry(1,wgpu::BindingResource::TextureView(&view)),entry(2,params.as_entire_binding()),entry(3,cdf.as_entire_binding())]});
let read=d.create_buffer(&wgpu::BufferDescriptor {label:None,size:512,usage:wgpu::BufferUsages::MAP_READ|wgpu::BufferUsages::COPY_DST,mapped_at_creation:false});
let mut encoder=d.create_command_encoder(&Default::default());
{let mut pass=encoder.begin_compute_pass(&Default::default());pass.set_pipeline(pipeline);pass.set_bind_group(0,&bind,&[]);pass.dispatch_workgroups(1,1,1);}
encoder.copy_texture_to_buffer(output.as_image_copy(),wgpu::TexelCopyBufferInfo {buffer:&read,layout:wgpu::TexelCopyBufferLayout {offset:0,bytes_per_row:Some(256),rows_per_image:Some(2)}},output.size());
r.queue.submit([encoder.finish()]);
let(tx,rx)=std::sync::mpsc::channel();read.map_async(wgpu::MapMode::Read,..,move |v|{let _=tx.send(v);});r.wait(None)?;rx.recv()??;
let mapped=read.get_mapped_range(..);
for row in 0..2 {
let actual:Vec<f32>=mapped[row*256..row*256+8].chunks_exact(2).map(|v|half::f16::from_bits(u16::from_le_bytes(v.try_into().unwrap())).to_f32()).collect();
assert_eq!(actual,[0.5,0.25,0.125,1.],"mode {mode}, mip {mip}, row {row}");
}
drop(mapped);
read.unmap();
}
Ok(())
}
/// Integer source bindings make optional float32 filtering impossible. Check
/// decoding, interpolation, addressing and residual multiplication together.
#[test]
#[ignore = "requires GPU and pinned Slang"]
fn source_bits_interpolate_hdr_without_float_filtering() -> Result<()> {
let r=Renderer::new()?;
let d=&r.device;
let pixels=[[2e6f32,1e6,5e5,0.25],[4e6,2e6,1e6,0.75],
[8.,16.,32.,1.],[64.,128.,256.,0.]];
let image=d.create_texture(&wgpu::TextureDescriptor {
label:Some("HDR source bits regression"),
size:wgpu::Extent3d {width:2,height:2,depth_or_array_layers:2},
mip_level_count:1,sample_count:1,dimension:wgpu::TextureDimension::D2,
format:SOURCE_FORMAT,
usage:wgpu::TextureUsages::TEXTURE_BINDING|wgpu::TextureUsages::COPY_DST,
view_formats:&[],
});
let pixels= pixels.into_iter().chain(pixels.map(|p|[p[0]*p[3],p[1]*p[3],p[2]*p[3],1.])).collect::<Vec<_>>();
r.queue.write_texture(image.as_image_copy(),bytemuck::cast_slice(&pixels),
wgpu::TexelCopyBufferLayout {offset:0,bytes_per_row:Some(32),rows_per_image:Some(2)},image.size());
let shader=r#"
import vork_prelude;
[[vk::binding(0,0)]] Texture2DArray<uint4> source;
[[vk::binding(1,0)]] RWStructuredBuffer<float4> result;
[shader("compute")][numthreads(1,1,1)] void numerical_test(uint3 id:SV_DispatchThreadID) {
result[0]=float4(environment_radiance(source,float2(.5,.5)),1.);
result[1]=float4(environment_radiance(source,float2(.5,.5),0u,true),1.);
result[2]=float4(environment_radiance(source,float2(0.,.25)),1.);
result[3]=float4(environment_radiance(source,float2(0.,.25),1u),1.);
result[4]=float4(environment_radiance(source,float2(0.,.25),2u),1.);
result[5]=float4(environment_radiance(source,float2(.5,.5),4u),1.);
result[6]=float4(1.);
for (uint mode=0u;mode<8u;mode++) {
for (int x=-8;x<=8;x++) {for (int y=-8;y<=8;y++) {
let uv=float2(float(x),float(y))*.25;
checked_environment_radiance(source,uv,mode);
checked_environment_radiance(source,uv*1e20,mode);
}}
}
result[7]=float4(environment_radiance(source,float2(1e20,.25),0u),1.);
}
"#;
// Replace only the load with an explicit coordinate assertion. This
// exercises production addressing without Vulkan robust access masking
// invalid reads. Extreme finite UVs catch integer conversion overflow.
let prelude=include_str!("../shaders/vork_prelude.slang");
let addressing=prelude.split("float3 environment_radiance(").nth(1).unwrap()
.split("// Invocation-local").next().unwrap();
let addressing=format!("float3 checked_environment_radiance({addressing}")
.replace("environment_texel(","checked_environment_texel(");
let checked=r#"
float3 checked_environment_texel(Texture2DArray<uint4> image,int2 cell,bool residual) {
uint width,height,layers;image.GetDimensions(width,height,layers);
if (any(cell<int2(0)) || any(cell>=int2(width,height))) {result[6]=float4(0.);}
return float3(0.);
}
"#;
let shader=format!("{checked}\n{addressing}\n{shader}");
let entries=[
wgpu::BindGroupLayoutEntry {visibility:wgpu::ShaderStages::COMPUTE,..crate::pipelines::environment_texture_entry(0)},
crate::pipelines::buffer_entry(1,wgpu::ShaderStages::COMPUTE,wgpu::BufferBindingType::Storage {read_only:false}),
];
let pipeline=crate::medium::test_pipeline(&r,&shader,&crate::medium::Native::default(),&entries,(1,1,1))?;
let output=d.create_buffer(&wgpu::BufferDescriptor {label:None,size:128,usage:wgpu::BufferUsages::STORAGE|wgpu::BufferUsages::COPY_SRC,mapped_at_creation:false});
let read=d.create_buffer(&wgpu::BufferDescriptor {label:None,size:128,usage:wgpu::BufferUsages::MAP_READ|wgpu::BufferUsages::COPY_DST,mapped_at_creation:false});
let view=image.create_view(&Default::default());
let bind=d.create_bind_group(&wgpu::BindGroupDescriptor {label:None,layout:&pipeline.get_bind_group_layout(0),entries:&[entry(0,wgpu::BindingResource::TextureView(&view)),entry(1,output.as_entire_binding())]});
let mut encoder=d.create_command_encoder(&Default::default());
{let mut pass=encoder.begin_compute_pass(&Default::default());pass.set_pipeline(&pipeline);pass.set_bind_group(0,&bind,&[]);pass.dispatch_workgroups(1,1,1);}
encoder.copy_buffer_to_buffer(&output,0,&read,0,128);r.queue.submit([encoder.finish()]);
let(tx,rx)=std::sync::mpsc::channel();read.map_async(wgpu::MapMode::Read,..,move |v|{let _=tx.send(v);});r.wait(None)?;rx.recv()??;
let mapped=read.get_mapped_range(..);let results:&[[f32;4]]=bytemuck::cast_slice(&mapped);
assert_eq!(results[6],[1.;4],"source load coordinates escaped the texture");
assert_eq!(results[7],[3e6,1.5e6,750000.,1.],"wrap must precede integer conversion");
for channel in 0..3 {
let a=pixels[0][channel];let b=pixels[1][channel];
let c=pixels[2][channel];let e=pixels[3][channel];
let expected=[(a+b+c+e)*0.25,(a*0.25+b*0.75+c)*0.25,(a+b)*0.5,a,a,e];
for (i,value) in expected.into_iter().enumerate() {
assert!((results[i][channel]-value).abs()<=value.abs()*1e-6,"sample {i}, channel {channel}: {:?}, expected {value}",results[i]);
}
}
Ok(())
}
#[test]
#[ignore = "requires pinned Slang and Vulkan"]
fn hdr_proposal_keeps_selected_cell_pdf_at_real_resolution() -> Result<()> {
let r=Renderer::new()?;let d=&r.device;
let shader=r#"
import environment_proposal;
import vork_constants;
[[vk::binding(0,0)]] StructuredBuffer<float2> cdf;
[[vk::binding(1,0)]] RWStructuredBuffer<float4> result;
[shader("compute")][numthreads(64,1,1)] void numerical_test(uint3 id:SV_DispatchThreadID) {
let i=id.x;let u=float2((float(i)+.5)/65536.,(float(reversebits(i)>>16u)+.5)/65536.);
float pdf;let direction=environment_proposal_sample(cdf,uint2(2048,1024),u,pdf);
result[i]=float4(direction,pdf);
}
"#;
let entries=[
crate::pipelines::buffer_entry(0,wgpu::ShaderStages::COMPUTE,wgpu::BufferBindingType::Storage{read_only:true}),
crate::pipelines::buffer_entry(1,wgpu::ShaderStages::COMPUTE,wgpu::BufferBindingType::Storage{read_only:false}),
];
let pipeline=crate::medium::test_pipeline(&r,shader,&crate::medium::Native::default(),&entries,(64,1,1))?;
for row in [1u32,350,1022] {
let at=row*2048+1024;
let values:Vec<[f32;2]>=(0..2048*1024).map(|i|[if i>=at {1.} else {0.},0.]).collect();
let table=init(d,"HDR CDF",bytemuck::cast_slice(&values),wgpu::BufferUsages::STORAGE);
let output=d.create_buffer(&wgpu::BufferDescriptor {label:None,size:65536*16,usage:wgpu::BufferUsages::STORAGE|wgpu::BufferUsages::COPY_SRC,mapped_at_creation:false});
let read=d.create_buffer(&wgpu::BufferDescriptor {label:None,size:65536*16,usage:wgpu::BufferUsages::MAP_READ|wgpu::BufferUsages::COPY_DST,mapped_at_creation:false});
let bind=d.create_bind_group(&wgpu::BindGroupDescriptor {label:None,layout:&pipeline.get_bind_group_layout(0),entries:&[entry(0,table.as_entire_binding()),entry(1,output.as_entire_binding())]});
let mut encoder=d.create_command_encoder(&Default::default());
{let mut pass=encoder.begin_compute_pass(&Default::default());pass.set_pipeline(&pipeline);pass.set_bind_group(0,&bind,&[]);pass.dispatch_workgroups(1024,1,1);}
encoder.copy_buffer_to_buffer(&output,0,&read,0,65536*16);r.queue.submit([encoder.finish()]);
let(tx,rx)=std::sync::mpsc::channel();read.map_async(wgpu::MapMode::Read,..,move |v|{let _=tx.send(v);});r.wait(None)?;rx.recv()??;
let mapped=read.get_mapped_range(..);let results:&[[f32;4]]=bytemuck::cast_slice(&mapped);
let theta = std::f64::consts::PI / 1024.;
let omega = std::f64::consts::TAU / 2048. * ((row as f64 * theta).cos() - ((row + 1) as f64 * theta).cos());
let expected=1./omega as f32;
for value in results {assert!((value[3]/expected-1.).abs()<0.0002,"row {row}: {value:?}, PDF {expected}");}
drop(mapped);read.unmap();
}
Ok(())
}
/// Independent angular moments and cell mass check the production GPU CDF
/// inversion and PDF, including an all-black map and sparse HDR support.
#[test]
#[ignore = "requires pinned Slang and Vulkan"]
fn environment_proposal_pdf_and_sampling() -> Result<()> {
let r=Renderer::new()?;let d=&r.device;
let shader=r#"
import environment_proposal;
import vork_constants;
import vork_prelude;
[[vk::binding(0,0)]] StructuredBuffer<float2> cdf;
[[vk::binding(1,0)]] RWStructuredBuffer<float4> result;
[shader("compute")][numthreads(1,1,1)] void numerical_test(uint3 id:SV_DispatchThreadID) {
let cell=id.x;let row=cell/8u;let col=cell%8u;
let phi=REG_TAU*((float(col)+0.5)/8.-0.5);
let theta=REG_PI*(float(row)+0.5)/4.;
let center=float3(sin(theta)*cos(phi),cos(theta),sin(theta)*sin(phi));
let omega=REG_TAU/8.*(cos(REG_PI*float(row)/4.)-cos(REG_PI*float(row+1u)/4.));
var count=0.;var moment=0.;
for (uint i=0u;i<65536u;i++) {
let u=float2((float(i)+0.5)/65536.,(float(reversebits(i)>>16u)+0.5)/65536.);
float sampled_pdf;let direction=environment_proposal_sample(cdf,uint2(8,4),u,sampled_pdf);
let uv=equirect_uv(direction);
let actual=min(uint2(float2(frac(uv.x),clamp(uv.y,0.,1.))*float2(8,4)),uint2(7,3));
if (actual.y*8u+actual.x==cell) {count+=1.;moment+=direction.y;}
}
result[cell]=float4(count/65536.,moment/65536.,environment_proposal_pdf(cdf,uint2(8,4),center)*omega,0.);
}
"#;
let entries=[
crate::pipelines::buffer_entry(0,wgpu::ShaderStages::COMPUTE,wgpu::BufferBindingType::Storage{read_only:true}),
crate::pipelines::buffer_entry(1,wgpu::ShaderStages::COMPUTE,wgpu::BufferBindingType::Storage{read_only:false}),
];
let pipeline=crate::medium::test_pipeline(&r,shader,&crate::medium::Native::default(),&entries, (1, 1, 1))?;
for sparse in [false,true] {
let mut pixels=vec![0f32;32*4];
for p in pixels.chunks_exact_mut(4) {p[3]=1.;}
if sparse {for (index,value) in [(3,500.),(17,1.)] {for channel in 0..3 {pixels[index*4+channel]=value;}}}
let values=distribution(8,4,&pixels);
let table=init(d,"CDF test",bytemuck::cast_slice(&values),wgpu::BufferUsages::STORAGE);
let output=d.create_buffer(&wgpu::BufferDescriptor{label:None,size:512,usage:wgpu::BufferUsages::STORAGE|wgpu::BufferUsages::COPY_SRC,mapped_at_creation:false});
let readback=d.create_buffer(&wgpu::BufferDescriptor{label:None,size:512,usage:wgpu::BufferUsages::MAP_READ|wgpu::BufferUsages::COPY_DST,mapped_at_creation:false});
let bind=d.create_bind_group(&wgpu::BindGroupDescriptor{label:None,layout:&pipeline.get_bind_group_layout(0),entries:&[entry(0,table.as_entire_binding()),entry(1,output.as_entire_binding())]});
let mut encoder=d.create_command_encoder(&Default::default());
{let mut pass=encoder.begin_compute_pass(&Default::default());pass.set_pipeline(&pipeline);pass.set_bind_group(0,&bind,&[]);pass.dispatch_workgroups(32,1,1);}
encoder.copy_buffer_to_buffer(&output,0,&readback,0,512);
let submission=r.queue.submit([encoder.finish()]);
let(tx,rx)=std::sync::mpsc::channel();readback.map_async(wgpu::MapMode::Read,..,move|v|{let _=tx.send(v);});
d.poll(wgpu::PollType::Wait{submission_index:Some(submission),timeout:None})?;rx.recv()??;
let mapped=readback.get_mapped_range(..);let actual:&[[f32;4]]=bytemuck::cast_slice(&mapped);
for (i,v) in actual.iter().enumerate() {
let mass=values[i][0]-if i==0 {0.} else {values[i-1][0]};
let row=i/8;let angle=std::f64::consts::PI/4.;
let mean=((angle*row as f64).cos()+(angle*(row+1) as f64).cos()) as f32*0.5;
assert!(v.iter().all(|x|x.is_finite()),"sparse={sparse} cell{i}: {v:?}");
// Histogram bins round-trip directions through GPU atan2/acos;
// allow 0.05% absolute mass at cell edges. PDF mass stays tight.
assert!((v[0]-mass).abs()<0.0005,"sample mass sparse={sparse} cell{i}: {v:?}, expected{mass}");
assert!((v[1]-mass*mean).abs()<0.0005,"angular moment sparse={sparse} cell{i}: {v:?}");
assert!((v[2]-mass).abs()<0.00001,"PDF mass sparse={sparse} cell{i}: {v:?}, expected{mass}");
}
}
r.errors.check()?;Ok(())
}
/// A row of two equal one-ULP cells after a large prefix: the conditional
/// column choice must stay 1/2 each with uniform azimuth inside each cell,
/// which a search against the rounded global target loses.
#[test]
#[ignore = "requires pinned Slang and Vulkan"]
fn environment_proposal_keeps_conditional_precision_after_large_prefix() -> Result<()> {
let r=Renderer::new()?;let d=&r.device;
let shader=r#"
import environment_proposal;
import vork_constants;
import vork_prelude;
[[vk::binding(0,0)]] StructuredBuffer<float2> cdf;
[[vk::binding(1,0)]] RWStructuredBuffer<float4> result;
[shader("compute")][numthreads(64,1,1)] void numerical_test(uint3 id:SV_DispatchThreadID) {
let u=float2((float(id.x)+0.5)/65536.,0.75+asfloat(0x33800000u));
float sampled_pdf;let uv=equirect_uv(environment_proposal_sample(cdf,uint2(2,3),u,sampled_pdf));
result[id.x]=float4(uv,0.,0.);
}
"#;
let entries=[
crate::pipelines::buffer_entry(0,wgpu::ShaderStages::COMPUTE,wgpu::BufferBindingType::Storage{read_only:true}),
crate::pipelines::buffer_entry(1,wgpu::ShaderStages::COMPUTE,wgpu::BufferBindingType::Storage{read_only:false}),
];
let pipeline=crate::medium::test_pipeline(&r,shader,&crate::medium::Native::default(),&entries,(64,1,1))?;
let ulp=f32::from_bits(0x33800000);
let values:[[f32;2];6]=[[0.375,0.],[0.75,0.],[0.75+ulp,0.],[0.75+2.*ulp,0.],[0.875,0.],[1.,0.]];
let table=init(d,"CDF test",bytemuck::cast_slice(&values),wgpu::BufferUsages::STORAGE);
let bytes=65536*16;
let output=d.create_buffer(&wgpu::BufferDescriptor{label:None,size:bytes,usage:wgpu::BufferUsages::STORAGE|wgpu::BufferUsages::COPY_SRC,mapped_at_creation:false});
let readback=d.create_buffer(&wgpu::BufferDescriptor{label:None,size:bytes,usage:wgpu::BufferUsages::MAP_READ|wgpu::BufferUsages::COPY_DST,mapped_at_creation:false});
let bind=d.create_bind_group(&wgpu::BindGroupDescriptor{label:None,layout:&pipeline.get_bind_group_layout(0),entries:&[entry(0,table.as_entire_binding()),entry(1,output.as_entire_binding())]});
let mut encoder=d.create_command_encoder(&Default::default());
{let mut pass=encoder.begin_compute_pass(&Default::default());pass.set_pipeline(&pipeline);pass.set_bind_group(0,&bind,&[]);pass.dispatch_workgroups(1024,1,1);}
encoder.copy_buffer_to_buffer(&output,0,&readback,0,bytes);
let submission=r.queue.submit([encoder.finish()]);
let(tx,rx)=std::sync::mpsc::channel();readback.map_async(wgpu::MapMode::Read,..,move|v|{let _=tx.send(v);});
d.poll(wgpu::PollType::Wait{submission_index:Some(submission),timeout:None})?;rx.recv()??;
let mapped=readback.get_mapped_range(..);let uv:&[[f32;4]]=bytemuck::cast_slice(&mapped);
let mut count=[0usize;2];let mut moment=[0f64;2];
for p in uv {
assert!(p[1]>1./3.-1e-4 && p[1]<2./3.+1e-4,"row {p:?}");
let x=(p[0].rem_euclid(1.)*2.) as f64;let column=(x as usize).min(1);
count[column]+=1;moment[column]+=x-column as f64;
}
for c in 0..2 {
assert!((count[c] as f64/65536.-0.5).abs()<0.002,"column {c}: {count:?}");
assert!((moment[c]/count[c] as f64-0.5).abs()<0.01,"column {c} mean in-cell azimuth {}",moment[c]/count[c] as f64);
}
drop(mapped);r.errors.check()?;Ok(())
}
#[test]
#[ignore = "requires pinned Slang and Vulkan"]
fn environment_mis_energy_links_and_null_connections() -> Result<()> {
let r=Renderer::new()?;
let fixtures=std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures");
let base:serde_json::Value=vork_scene::v2::with_test_settings(include_str!("../tests/fixtures/analytic.json"), include_str!("../tests/presets/analytic-7fefd52a.json"))?;
let directory=std::env::temp_dir().join(format!("vork-environment-test-{}-{}",std::process::id(),std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH)?.as_nanos()));
std::fs::create_dir(&directory)?;
let image=directory.join("white.png");
image::RgbImage::from_pixel(16,8,image::Rgb([255u8;3])).save(&image)?;
let hemisphere=directory.join("hemisphere.png");
let mut half_image=image::RgbImage::from_pixel(16,8,image::Rgb([0u8;3]));
for y in 0..8 {for x in 4..12 {half_image.put_pixel(x,y,image::Rgb([255u8;3]));}}
half_image.save(&hemisphere)?;
// Repeated installs must preserve the source proposal on warm caches.
for (scenario,expected) in [
("open",1.),("open",1.),
("blocked",0.),("unlinked",0.),
("null-linked",1.),
("rotated-dark",0.),("rotated-white",1.),
] {
let mut input=base.clone();input["animation"]=serde_json::json!([]);
input["render"]=serde_json::json!({"resolution":[8,8],"background":"environment","settings":{"integrator":"path","denoiser":null,"samples":256}});
input["images"]=serde_json::json!({"world":{"file":image,"color_space":"Linear Rec.709"}});
input["materials"]=serde_json::json!({
"environment_image":{"program":"std/environment_image","inputs":{"image":{"image":"world"}}},
"white":{"inputs":{"base_color":[1,1,1],"specular_weight":0}},
"block":{"inputs":{"base_color":[0,0,0],"specular_weight":0,"geometry_opacity":if scenario=="null-linked" {0.} else {1.}}}});
input["nodes"]=serde_json::json!([
{"name":"camera","type":"camera","translation":[0,0,5],"material":{"program":"std/camera","inputs":{"projection":"ortho","ortho_scale":0.1}}},
{"name":"slab","type":"mesh","geometry":"shape_box","materials":["white"],"light_link_tags":["receiver"],"scale":[20,20,0.25]},
{"name":"world","type":"light","shape":"environment","material":"environment_image","energy":1,"color":[1,1,1],"illuminates":if scenario=="unlinked" {serde_json::json!([])} else {serde_json::json!(["receiver"])}}
]);
if scenario=="blocked" || scenario=="null-linked" {
input["nodes"].as_array_mut().unwrap().push(serde_json::json!({"name":"blocker","type":"mesh","geometry":"shape_box","materials":["block"],"visible_camera":false,"light_link_tags":["other"],"translation":[0,0,3],"scale":[4000,4000,0.1]}));
}
if scenario.starts_with("rotated-") {
input["images"]["world"]["file"]=serde_json::json!(hemisphere);
let sine=if scenario=="rotated-dark" {std::f32::consts::FRAC_1_SQRT_2} else {-std::f32::consts::FRAC_1_SQRT_2};
vork_scene::v2::set_transform(&mut input["nodes"][2], serde_json::json!({"rotation":[0,sine,0,std::f32::consts::FRAC_1_SQRT_2]}));
}
let installed=r.install(vork_scene::v2::from_test_value(input)?,&fixtures)?;
{assert_ne!(installed.environment.distribution_size,[1,1],"cached filters dropped source CDF");}
let mut frame=installed.create_frame_slot(&r,ReadbackPrecision::Float)?;
frame.submit_outputs(&installed,&r,0.,ReadbackOutputs{float:FloatOutputs{color:true,..Default::default()},..Default::default()})?;
let pixels=frame.collect(&r)?.linear_rgba.unwrap();
let mean=pixels.iter().map(|p|p[0]).sum::<f32>()/pixels.len() as f32;
assert!((mean-expected).abs()<0.03,"{scenario}: mean{mean}, expected{expected}");
}
std::fs::remove_dir_all(&directory)?;
r.errors.check()?;Ok(())
}
}
pub(crate) fn reduce_pipeline(r: &Renderer) -> &wgpu::ComputePipeline {
let d = &r.device;
r.pipelines.environment_reduce.get_or_init(|| {
let module = native::shader_module(d, &native::ENVIRONMENT_REDUCE_REDUCE_ENVIRONMENT);
let group = d.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("HDR solid-angle reduction"),
entries: &REDUCE_LAYOUT,
});
let layout = d.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("HDR solid-angle reduction"),
bind_group_layouts: &[Some(&group)],
immediate_size: 0,
});
r.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some("HDR solid-angle reduction"),
layout: Some(&layout),
module: &module,
entry_point: Some(native::ENVIRONMENT_REDUCE_REDUCE_ENVIRONMENT.entry),
compilation_options: Default::default(),
cache: r.cache.as_ref(),
})
})
}