//! 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 { 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::() 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::().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>, } 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, 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, /// Batch buffers, grown as needed and reused across batches. io: Option, } 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 { 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::() 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( &mut self, pipeline: &wgpu::ComputePipeline, items: &[u8], n: usize, passes: &[Pass], read: impl FnOnce(&[[u32; 4]]) -> R, ) -> Result { 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::(&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>, 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>, 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::, BakeError>>()? .concat(); let passes: Vec = 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 { 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::>(), gpu.maps.keys().collect::>()); for (m, a) in &cpu.maps { let mut d: Vec = a.iter().zip(&gpu.maps[m]).map(|(a, b)| (a - b).abs()).collect(); d.sort_by(f32::total_cmp); let mean = d.iter().sum::() / 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::>(), start.elapsed()); } } }