d84914ef1e5a
gpu_bake.rs
//! GPU mesh-map baking: [`GpuBaker`] runs the ray casts of `texturecraft_bake` (a
//! [`Tracer`]) as compute shaders (`shaders/bake.wgsl` on the path tracer's BVH traversal in
//! `shaders/rays.wgsl`), on a device of its own created on the first bake. The CPU tracer is the
//! oracle: the GPU gets the same rays and queries and casts the same secondary-ray directions,
//! so both bakes agree up to float rounding. Any GPU failure is a [`BakeError::Tracer`], after
//! which `bake_on` bakes on the CPU.
use std::sync::{Arc, OnceLock};
use bytemuck::{Pod, Zeroable};
use rayon::prelude::*;
use texturecraft_bake::BakeError;
use texturecraft_bake::tracing::{ANY, Hemisphere, Query, Ray, RayKind, RayScene, TraceMesh, Tracer};
use texturecraft_core::{AmbientOcclusionAttenuation, BackfaceMode};
use texturecraft_geom::Hit;
use texturecraft_geom::glam::Vec3;
use crate::gpu_trace::{STACK, buffer, bvh_depth, bvh_rows, entry, scoped, storage};
const WORKGROUP: u32 = 64;
/// Rays per dispatch: short dispatches keep slow GPUs clear of driver watchdogs.
const RAYS_PER_DISPATCH: usize = 1 << 24;
const NONE: u32 = u32::MAX;
const UNIFORM: u32 = 1;
const IGNORE_BACKFACE: u32 = 2;
const SAME_KEY: u32 = 4;
/// `Params` of bake.wgsl.
#[repr(C)]
#[derive(Clone, Copy, Default, Pod, Zeroable)]
struct Params {
count: u32,
offset: u32,
kind: u32,
rays: u32,
dmax: f32,
eps: f32,
cos_max: f32,
sin_max: f32,
flags: u32,
root: u32,
/// Threads per query (hemisphere).
lanes: u32,
/// First result row of the pass.
out: u32,
min_distance: f32,
attenuation: u32,
ground_height: f32,
backface_mode: u32,
}
struct Gpu {
device: wgpu::Device,
queue: wgpu::Queue,
name: String,
layout: wgpu::BindGroupLayout,
transfer: wgpu::ComputePipeline,
hemisphere: wgpu::ComputePipeline,
/// Bytes between the per-dispatch parameter blocks (the dynamic uniform offset alignment).
stride: usize,
}
fn err(e: impl std::fmt::Display) -> BakeError {
BakeError::Tracer(format!("GPU baking: {e}"))
}
impl Gpu {
fn new() -> Result<Gpu, String> {
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env());
let options = wgpu::RequestAdapterOptions { power_preference: wgpu::PowerPreference::HighPerformance, ..Default::default() };
let adapter = pollster::block_on(instance.request_adapter(&options)).map_err(|e| format!("no GPU adapter: {e}"))?;
let info = adapter.get_info();
if info.device_type == wgpu::DeviceType::Cpu {
return Err(format!("{} is a software renderer", info.name));
}
let limits = adapter.limits();
if limits.max_storage_buffers_per_shader_stage < 3
|| limits.max_compute_invocations_per_workgroup < WORKGROUP
|| limits.max_compute_workgroup_size_x < WORKGROUP
{
return Err(format!("{} has no usable compute shaders", info.name));
}
let desc = wgpu::DeviceDescriptor { label: Some("tc_bake"), required_limits: limits, ..Default::default() };
let (device, queue) = pollster::block_on(adapter.request_device(&desc)).map_err(|e| format!("no GPU device: {e}"))?;
// Errors are caught by the scopes around every call; never let wgpu's default handler panic.
device.on_uncaptured_error(Arc::new(|_| {}));
let (layout, transfer, hemisphere) = scoped(&device, "GPU baking: pipelines", || {
let params = wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: true,
min_binding_size: wgpu::BufferSize::new(size_of::<Params>() as u64),
};
let entries = [entry(0, params), storage(1, true), storage(2, true), storage(3, true), storage(4, false)];
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { label: Some("tc_bake"), entries: &entries });
let source = concat!(include_str!("shaders/rays.wgsl"), include_str!("shaders/bake.wgsl"));
let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("tc_bake"), source: wgpu::ShaderSource::Wgsl(source.into()) });
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("tc_bake"),
bind_group_layouts: &[Some(&layout)],
immediate_size: 0,
});
let pipe = |entry_point: &str| {
device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: Some(entry_point),
layout: Some(&pipeline_layout),
module: &module,
entry_point: Some(entry_point),
compilation_options: Default::default(),
cache: None,
})
};
(layout, pipe("transfer_main"), pipe("hemisphere_main"))
})?;
let stride = size_of::<Params>().next_multiple_of(device.limits().min_uniform_buffer_offset_alignment.max(1) as usize);
Ok(Gpu { device, queue, name: info.name, layout, transfer, hemisphere, stride })
}
/// The largest storage buffer this device binds.
fn max_buffer(&self) -> u64 {
let l = self.device.limits();
l.max_storage_buffer_binding_size.min(l.max_buffer_size)
}
}
/// The GPU [`Tracer`]. Its device is created on the first bake; without a hardware adapter
/// every bake reports [`BakeError::Tracer`] (and runs on the CPU).
#[derive(Default)]
pub struct GpuBaker {
gpu: OnceLock<Result<Gpu, String>>,
}
impl GpuBaker {
pub fn new() -> GpuBaker {
GpuBaker::default()
}
fn gpu(&self) -> Result<&Gpu, BakeError> {
self.gpu.get_or_init(Gpu::new).as_ref().map_err(|e| BakeError::Tracer(e.clone()))
}
}
impl Tracer for GpuBaker {
fn name(&self) -> String {
match self.gpu.get() {
Some(Ok(g)) => format!("GPU ({})", g.name),
_ => "GPU".into(),
}
}
fn scene<'a>(&'a self, meshes: &[TraceMesh<'a>]) -> Result<Box<dyn RayScene + 'a>, BakeError> {
let gpu = self.gpu()?;
let (mut nodes, mut tris, mut roots) = (Vec::new(), Vec::new(), Vec::new());
for m in meshes {
let tree: Vec<_> = m.bvh.nodes().collect();
if bvh_depth(&tree).is_none_or(|d| d >= STACK) {
return Err(err("a mesh's BVH is too deep for GPU traversal"));
}
let base = ((nodes.len() / 2) as u32, (tris.len() / 4) as u32);
roots.push(base.0);
let (n, t) = bvh_rows(m.bvh, base, |o| {
([m.keys.get(o).copied().unwrap_or(ANY), u32::from(m.backface_culling.get(o).copied().unwrap_or(false)), 0], [0, 0, 0, o as u32])
});
nodes.extend(n);
tris.extend(t);
}
if (tris.len() as u64).saturating_mul(16) > gpu.max_buffer() || (nodes.len() as u64).saturating_mul(16) > gpu.max_buffer() {
return Err(err(format!("the meshes ({} MB) exceed this GPU's buffer limit", tris.len() >> 16)));
}
let (nodes, tris) = scoped(&gpu.device, "GPU baking: mesh upload", || {
(buffer(&gpu.device, "tc_bake_nodes", bytemuck::cast_slice(&nodes)), buffer(&gpu.device, "tc_bake_tris", bytemuck::cast_slice(&tris)))
})
.map_err(BakeError::Tracer)?;
Ok(Box::new(GpuScene { gpu, nodes, tris, roots, io: None }))
}
}
/// The meshes of one bake on the GPU: every BVH in one node and one triangle buffer.
struct GpuScene<'g> {
gpu: &'g Gpu,
nodes: wgpu::Buffer,
tris: wgpu::Buffer,
/// Root node of each mesh.
roots: Vec<u32>,
/// Batch buffers, grown as needed and reused across batches.
io: Option<Io>,
}
struct Io {
items: wgpu::Buffer,
results: wgpu::Buffer,
staging: wgpu::Buffer,
params: wgpu::Buffer,
bind: wgpu::BindGroup,
}
/// One pass over every item: its parameters and the items per dispatch.
struct Pass {
params: Params,
per_dispatch: usize,
/// Items per workgroup.
per_group: usize,
}
impl GpuScene<'_> {
fn root(&self, mesh: usize) -> Result<u32, BakeError> {
self.roots.get(mesh).copied().ok_or_else(|| err(format!("no scene mesh {mesh}")))
}
/// Batch buffers of at least these sizes (bytes).
fn io(&mut self, items: u64, results: u64, params: u64) -> Result<&Io, BakeError> {
let fits = |io: &Io| io.items.size() >= items && io.results.size() >= results && io.params.size() >= params;
if !self.io.as_ref().is_some_and(fits) {
let (g, dev) = (self.gpu, &self.gpu.device);
let size = |b: u64| b.max(256).next_power_of_two().min(g.max_buffer()).max(b);
let io = scoped(dev, "GPU baking: batch buffers", || {
let buf = |label, size, usage| dev.create_buffer(&wgpu::BufferDescriptor { label: Some(label), size, usage, mapped_at_creation: false });
let items = buf("tc_bake_items", size(items), wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST);
let results = buf("tc_bake_results", size(results), wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC);
let staging = buf("tc_bake_staging", results.size(), wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST);
let params = buf("tc_bake_params", size(params), wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST);
let block = wgpu::BufferBinding { buffer: ¶ms, offset: 0, size: wgpu::BufferSize::new(size_of::<Params>() as u64) };
let bind = dev.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("tc_bake"),
layout: &g.layout,
entries: &[
wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::Buffer(block) },
wgpu::BindGroupEntry { binding: 1, resource: self.nodes.as_entire_binding() },
wgpu::BindGroupEntry { binding: 2, resource: self.tris.as_entire_binding() },
wgpu::BindGroupEntry { binding: 3, resource: items.as_entire_binding() },
wgpu::BindGroupEntry { binding: 4, resource: results.as_entire_binding() },
],
});
Io { items, results, staging, params, bind }
})
.map_err(BakeError::Tracer)?;
self.io = Some(io);
}
self.io.as_ref().ok_or_else(|| err("no batch buffers"))
}
/// Run `pipeline` over `n` items (`items`: their rows) once per pass in one submission, and
/// hand `read` one result row per item and pass (pass after pass).
fn run<R: Default>(
&mut self,
pipeline: &wgpu::ComputePipeline,
items: &[u8],
n: usize,
passes: &[Pass],
read: impl FnOnce(&[[u32; 4]]) -> R,
) -> Result<R, BakeError> {
if n == 0 || passes.is_empty() {
return Ok(R::default());
}
let g = self.gpu;
let max_groups = g.device.limits().max_compute_workgroups_per_dimension as usize;
let (mut blocks, mut dispatches) = (Vec::new(), Vec::new());
for (k, p) in passes.iter().enumerate() {
let chunk = p.per_dispatch.clamp(p.per_group, max_groups * p.per_group) / p.per_group * p.per_group;
for offset in (0..n).step_by(chunk) {
let count = chunk.min(n - offset);
dispatches.push((blocks.len() as u32, count.div_ceil(p.per_group) as u32));
let block = Params { offset: offset as u32, count: count as u32, out: (k * n) as u32, ..p.params };
blocks.extend_from_slice(bytemuck::bytes_of(&block));
blocks.resize(blocks.len().next_multiple_of(g.stride), 0);
}
}
let (in_bytes, out_bytes) = (items.len() as u64, (n * passes.len()) as u64 * 16);
if in_bytes.max(out_bytes) > g.max_buffer() {
return Err(err("a batch exceeds this GPU's buffer limit"));
}
let io = self.io(in_bytes, out_bytes, blocks.len() as u64)?;
let dev = &g.device;
scoped(dev, "GPU baking: dispatch", || {
g.queue.write_buffer(&io.items, 0, items);
g.queue.write_buffer(&io.params, 0, &blocks);
let mut enc = dev.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("tc_bake") });
{
let mut pass = enc.begin_compute_pass(&wgpu::ComputePassDescriptor { label: Some("tc_bake"), timestamp_writes: None });
pass.set_pipeline(pipeline);
for &(offset, groups) in &dispatches {
pass.set_bind_group(0, &io.bind, &[offset]);
pass.dispatch_workgroups(groups, 1, 1);
}
}
enc.copy_buffer_to_buffer(&io.results, 0, &io.staging, 0, out_bytes);
g.queue.submit([enc.finish()]);
})
.map_err(BakeError::Tracer)?;
let slice = io.staging.slice(..out_bytes);
let (tx, rx) = std::sync::mpsc::channel();
slice.map_async(wgpu::MapMode::Read, move |r| {
let _ = tx.send(r);
});
dev.poll(wgpu::PollType::Wait { submission_index: None, timeout: None }).map_err(err)?;
rx.recv().map_err(err)?.map_err(err)?;
let data = slice.get_mapped_range().map_err(err)?;
let out = bytemuck::try_cast_slice::<u8, [u32; 4]>(&data).map(read).map_err(err);
drop(data);
io.staging.unmap();
out
}
}
/// A row of `v` (as bits) and `w`.
fn row(v: Vec3, w: u32) -> [u32; 4] {
[v.x.to_bits(), v.y.to_bits(), v.z.to_bits(), w]
}
impl RayScene for GpuScene<'_> {
fn closest(&mut self, mesh: usize, rays: &[Ray], ignore_backface: bool) -> Result<Vec<Option<Hit>>, BakeError> {
let pass = Pass {
params: Params { root: self.root(mesh)?, flags: u32::from(ignore_backface) * IGNORE_BACKFACE, ..Params::default() },
per_dispatch: RAYS_PER_DISPATCH,
per_group: WORKGROUP as usize,
};
let gpu = self.gpu;
self.run(&gpu.transfer, bytemuck::cast_slice(rays), rays.len(), &[pass], |out| {
out.par_iter().map(|&[t, u, v, tri]| (tri != NONE).then(|| Hit { t: f32::from_bits(t), tri, u: f32::from_bits(u), v: f32::from_bits(v) })).collect()
})
}
fn hemispheres(&mut self, passes: &[Hemisphere], queries: &[Query]) -> Result<Vec<Vec<[f32; 4]>>, BakeError> {
let roots = &self.roots;
let items = queries
.par_iter()
.map(|q| {
let root = roots.get(q.mesh as usize).copied().ok_or_else(|| err(format!("no scene mesh {}", q.mesh)))?;
Ok([row(q.pos, q.rot[0].to_bits()), row(q.nrm, q.rot[1].to_bits()), row(q.geo, q.key), [root, 0, 0, 0]])
})
.collect::<Result<Vec<_>, BakeError>>()?
.concat();
let passes: Vec<Pass> = passes
.iter()
.map(|h| {
// A sample's rays spread over `lanes` threads of a workgroup (a power of two).
let lanes = h.rays.clamp(1, WORKGROUP).next_power_of_two();
let flags =
[(h.uniform, UNIFORM), (h.ground_height.is_some(), 8), (h.same_key, SAME_KEY)].iter().filter(|(on, _)| *on).fold(0, |f, (_, b)| f | b);
let params = Params {
kind: u32::from(h.kind == RayKind::Thickness),
rays: h.rays,
dmax: h.dmax,
min_distance: h.min_distance,
attenuation: match h.attenuation {
AmbientOcclusionAttenuation::None => 0,
AmbientOcclusionAttenuation::Linear => 1,
AmbientOcclusionAttenuation::Smooth => 2,
},
ground_height: h.ground_height.unwrap_or(0.0),
backface_mode: match h.ignore_backface {
BackfaceMode::Never => 0,
BackfaceMode::Always => 1,
BackfaceMode::ByMeshName => 2,
},
eps: h.eps,
cos_max: h.cos_max,
sin_max: h.sin_max,
flags,
lanes,
..Params::default()
};
Pass { params, per_dispatch: RAYS_PER_DISPATCH / h.rays.max(1) as usize, per_group: (WORKGROUP / lanes) as usize }
})
.collect();
let gpu = self.gpu;
self.run(&gpu.hemisphere, bytemuck::cast_slice(&items), queries.len(), &passes, |out| {
out.chunks(queries.len().max(1)).map(|c| c.iter().map(|v| v.map(f32::from_bits)).collect()).collect()
})
}
}
#[cfg(test)]
mod tests {
use std::time::Instant;
use texturecraft_core::{
AmbientOcclusionSettings, BakeAntialiasing, BakeResolution, BentNormalSettings, CageSettings, CommonBakeSettings, CurvatureSettings, HighPolySettings,
ThicknessSettings,
};
use texturecraft_bake::{BakeOutput, BakeRequest, HighPoly, Progress, bake, bake_on};
use texturecraft_core::{BackfaceMode, BakeSettings, BakedMap, CurvatureMethod, RayDistribution, RaySettings, SelfOcclusion};
use texturecraft_geom::{Bvh, Mesh, primitives};
use super::*;
/// The GPU baker, or None (test skipped) without a hardware adapter.
fn gpu() -> Option<GpuBaker> {
let g = GpuBaker::new();
match g.gpu() {
Ok(_) => Some(g),
Err(e) => {
eprintln!("skipping: {e}");
None
}
}
}
fn run(low: &Mesh, high: Option<&Mesh>, s: &BakeSettings, tracer: Option<&GpuBaker>) -> BakeOutput {
let (lb, hb) = (Bvh::new(low), high.map(Bvh::new));
let high = high.zip(hb.as_ref()).map(|(mesh, bvh)| HighPoly { file_ids: &[], mesh, bvh, base_color: &[] });
let req =
BakeRequest { low_base_color: &[], mesh: low, bvh: &lb, material: 0, settings: s, high, cage: None, skew: None, cage_paint: None, tiles: (1, 1) };
match tracer {
Some(t) => bake_on(&req, &Progress::new(), t).unwrap(),
None => bake(&req, &Progress::new()).unwrap(),
}
}
/// Per map: mean absolute difference, 99th percentile and share of values off by > 0.05.
fn assert_agree(cpu: &BakeOutput, gpu: &BakeOutput) {
assert!(gpu.tracer.starts_with("GPU"), "{}", gpu.tracer);
assert_eq!(cpu.maps.keys().collect::<Vec<_>>(), gpu.maps.keys().collect::<Vec<_>>());
for (m, a) in &cpu.maps {
let mut d: Vec<f32> = a.iter().zip(&gpu.maps[m]).map(|(a, b)| (a - b).abs()).collect();
d.sort_by(f32::total_cmp);
let mean = d.iter().sum::<f32>() / d.len() as f32;
let p99 = d[d.len() * 99 / 100];
let off = d.iter().filter(|v| **v > 0.05).count() as f32 / d.len() as f32;
eprintln!("{m:?}: mean {mean:.2e}, p99 {p99:.2e}, off {:.3}%", off * 100.0);
assert!(mean < 2e-3 && p99 < 0.02 && off < 0.005, "{m:?}: mean {mean}, p99 {p99}, off {off}");
}
}
#[test]
fn gpu_respects_secondary_ray_filters_and_ground_plane() {
let Some(gpu) = gpu() else { return };
let mut mesh = primitives::material_ball();
for part in &mut mesh.submeshes {
part.name.push_str("_ignorebf");
}
let mut settings = BakeSettings::default();
settings.common.resolution = BakeResolution::R64;
settings.common.apply_diffusion = false;
settings.maps.select([BakedMap::AmbientOcclusion, BakedMap::BentNormal, BakedMap::Thickness]);
settings.high_poly.ignore_backface_suffix = "_ignorebf".into();
settings.maps.ao.parameters.rays.min_distance = 0.02;
settings.maps.ao.parameters.ignore_backface = BackfaceMode::ByMeshName;
settings.maps.ao.parameters.self_occlusion = SelfOcclusion::SameMeshName;
settings.maps.ao.parameters.ground_plane.enabled = true;
settings.maps.ao.parameters.ground_plane.offset = 0.1;
settings.maps.bent_normal.parameters.rays.min_distance = 0.02;
settings.maps.bent_normal.parameters.ignore_backface = BackfaceMode::ByMeshName;
settings.maps.thickness.parameters.rays.min_distance = 0.02;
settings.maps.thickness.parameters.self_occlusion = SelfOcclusion::SameMeshName;
for attenuation in [AmbientOcclusionAttenuation::None, AmbientOcclusionAttenuation::Smooth] {
settings.maps.ao.parameters.attenuation = attenuation;
assert_agree(&run(&mesh, None, &settings, None), &run(&mesh, None, &settings, Some(&gpu)));
}
}
#[test]
fn gpu_bake_matches_the_cpu() {
let Some(gpu) = gpu() else { return };
// Low poly: the material ball (self-occluding); every ray map with its own settings
let ball = primitives::material_ball();
let maps = [BakedMap::AmbientOcclusion, BakedMap::BentNormal, BakedMap::Thickness, BakedMap::Position, BakedMap::Curvature];
let settings = {
let mut base = BakeSettings::default();
base.common = CommonBakeSettings { resolution: BakeResolution::R128, antialiasing: BakeAntialiasing::Subsampling2x2, dilation: 0, ..base.common };
base.maps.select(maps);
base.maps.ao.parameters = AmbientOcclusionSettings {
rays: RaySettings { rays: 24, max_distance: 0.3, spread: 150.0, distribution: RayDistribution::Uniform, ..RaySettings::default() },
ignore_backface: BackfaceMode::Always,
..base.maps.ao.parameters
};
base.maps.curvature.parameters = CurvatureSettings { method: CurvatureMethod::Mesh, ..base.maps.curvature.parameters };
base.maps.bent_normal.parameters =
BentNormalSettings { rays: RaySettings { rays: 16, ..RaySettings::default() }, ..base.maps.bent_normal.parameters };
base.maps.thickness.parameters =
ThicknessSettings { rays: RaySettings { rays: 20, spread: 90.0, ..RaySettings::default() }, ..base.maps.thickness.parameters };
base
};
assert_agree(&run(&ball, None, &settings, None), &run(&ball, None, &settings, Some(&gpu)));
// A bumpy high poly over a sphere, matched by name: the transfer maps and AO on it
let low = primitives::sphere(1.0, 32, 16);
let mut high = primitives::sphere(1.0, 128, 64);
for p in &mut high.positions {
*p *= 1.0 + 0.02 * (p.x * 9.0).sin() * (p.y * 7.0).cos();
}
high.compute_normals();
high.compute_tangents();
high.submeshes[0].name = format!("{}_high", low.submeshes[0].name);
let settings = {
let mut base = BakeSettings::default();
base.common = CommonBakeSettings { resolution: BakeResolution::R128, dilation: 0, ..base.common };
base.maps.select([
BakedMap::Normal,
BakedMap::Height,
BakedMap::Id,
BakedMap::Opacity,
BakedMap::AmbientOcclusion,
BakedMap::WorldNormal,
BakedMap::Curvature,
]);
base.cage = CageSettings { max_frontal: 0.02, max_rear: 0.02, ..base.cage };
base.high_poly = HighPolySettings {
match_mode: texturecraft_core::MeshMatchMode::ByMeshName,
low_suffix: String::new(),
use_low_as_high: false,
..base.high_poly
};
base.maps.ao.parameters = AmbientOcclusionSettings {
rays: RaySettings { rays: 16, ..RaySettings::default() },
self_occlusion: SelfOcclusion::SameMeshName,
..base.maps.ao.parameters
};
base.maps.curvature.parameters = CurvatureSettings { method: CurvatureMethod::Mesh, ..base.maps.curvature.parameters };
base
};
assert_agree(&run(&low, Some(&high), &settings, None), &run(&low, Some(&high), &settings, Some(&gpu)));
}
/// `cargo test -p texturecraft-render --release -- --ignored --nocapture gpu_bake_speed`
#[test]
#[ignore]
fn gpu_bake_speed() {
let Some(g) = gpu() else { return };
let ball = primitives::material_ball();
let rays = RaySettings { rays: 64, ..RaySettings::default() };
let s = {
let mut base = BakeSettings::default();
base.common = CommonBakeSettings { resolution: BakeResolution::R2048, ..base.common };
base.maps.ao.parameters = AmbientOcclusionSettings { rays, ..base.maps.ao.parameters };
base.maps.thickness.parameters = ThicknessSettings { rays, ..base.maps.thickness.parameters };
base.maps.bent_normal.parameters = BentNormalSettings { rays, ..base.maps.bent_normal.parameters };
base
};
run(
&ball,
None,
&{
let mut base = s.clone();
base.common = CommonBakeSettings { resolution: BakeResolution::R64, ..base.common };
base
},
Some(&g),
);
let time = |t: Option<&GpuBaker>| {
let start = Instant::now();
let out = run(&ball, None, &s, t);
(start.elapsed(), out)
};
let (cpu_t, cpu) = time(None);
let (gpu_t, gpu) = time(Some(&g));
let (gpu_t2, _) = time(Some(&g));
println!("GPU again (warm clocks): {gpu_t2:.2?}");
println!(
"material ball 2048², {} maps, 64 rays: CPU {cpu_t:.2?}, {} {gpu_t:.2?}, {:.1}x",
s.maps.enabled().count(),
gpu.tracer,
cpu_t.as_secs_f64() / gpu_t.as_secs_f64()
);
assert_agree(&cpu, &gpu);
for maps in [vec![BakedMap::Position], vec![BakedMap::AmbientOcclusion], vec![BakedMap::Thickness]] {
let s = {
let mut base = s.clone();
base.maps.select(maps);
base
};
let start = Instant::now();
run(&ball, None, &s, Some(&g));
println!("{:?}: {:.2?}", s.maps.enabled().collect::<Vec<_>>(), start.elapsed());
}
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.