mirror of
https://github.com/storytold/texturecraft.git
synced 2026-11-19 05:50:43 +01:00
571 lines
26 KiB
Rust
571 lines
26 KiB
Rust
//! 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());
|
|
}
|
|
}
|
|
}
|