mirror of
https://github.com/storytold/texturecraft.git
synced 2026-11-20 22:40:44 +01:00
A UV tile with a lower resolution than its atlas block fills the block's corner, so it has fewer texels per UV unit. Neighbourhood filters (blur, sharpen, warps, bevel, glow, ...) and height-to-normal slopes used the block's texel density for every tile, so such a tile blurred twice as wide and showed twice as steep slopes in UV space. TextureSet::block_scales gives each block's share; the compositor filters each block at its tile's radius, texture export and the CPU path tracer scale the slope by it, and the display packs it into the Extra texture's alpha for the viewport and GPU path tracer shaders (parallax too).
1337 lines
57 KiB
Rust
1337 lines
57 KiB
Rust
//! Progressive CPU path tracing for Rendering mode: the textured mesh under the environment,
|
||
//! with the raster viewport's material conventions (metallic/roughness or specular/glossiness
|
||
//! GGX, specular level,
|
||
//! height-to-normal slope rule, normal channel blended with RNM, emissive, opacity) but real
|
||
//! multi-bounce light transport. Each [`Tracer::pass`] adds one sample per pixel.
|
||
//!
|
||
//! The optional lobe channels: anisotropic GGX (true anisotropic evaluation and visible-normal
|
||
//! sampling along the turned mesh tangent), a GGX clear coat (IOR 1.5) on the mesh normal that
|
||
//! takes `1 − coat Fresnel` from everything below it, a Charlie sheen with Estevez–Kulla
|
||
//! visibility and albedo scaling of the base, and subsurface scattering as a random walk: the
|
||
//! scattering part of the diffuse light enters the mesh, scatters isotropically with the
|
||
//! project's per-channel mean free path (no absorption: the base color tints it once, on entry)
|
||
//! and leaves where the walk next crosses the surface, as a Lambertian emitter. Walks are capped
|
||
//! at [`WALK_STEPS`] (their energy is dropped) and need closed meshes. The clear coat follows the
|
||
//! Coat normal channel where a set has it. Transmission turns that part of the dielectric base
|
||
//! into a rough glass interface: GGX visible-normal sampling, exact Fresnel at the project's IOR,
|
||
//! refraction through the mesh (tinted by the base color on the way in). Depth of field comes from
|
||
//! a thin-lens camera ([`TraceScene::lens`]).
|
||
|
||
use std::f32::consts::{PI, TAU};
|
||
use std::sync::Arc;
|
||
|
||
use rayon::prelude::*;
|
||
use texturecraft_compose::{Composite, ImageRes};
|
||
use texturecraft_core::Channel;
|
||
use texturecraft_core::project::{DisplaySettings, ToneMapping};
|
||
use texturecraft_geom::glam::{Vec2, Vec3};
|
||
use texturecraft_geom::{Bvh, Mesh, OrbitCamera};
|
||
|
||
use crate::ibl::EnvImage;
|
||
|
||
/// One texture set's composited channels.
|
||
#[derive(Clone)]
|
||
pub struct TraceSet {
|
||
/// Mesh material the set covers.
|
||
pub material: usize,
|
||
pub composite: Composite,
|
||
pub height_strength: f32,
|
||
}
|
||
|
||
/// Everything a pass reads (cheap to clone: shared or copy-on-write data).
|
||
#[derive(Clone)]
|
||
pub struct TraceScene {
|
||
pub mesh: Arc<Mesh>,
|
||
pub bvh: Arc<Bvh>,
|
||
pub sets: Vec<TraceSet>,
|
||
pub env: Arc<EnvImage>,
|
||
/// Environment rotation around +Y (radians), as in the viewport.
|
||
pub env_rotation: f32,
|
||
/// Texture set per triangle (`usize::MAX`: none, default material).
|
||
pub(crate) tri_set: Arc<Vec<usize>>,
|
||
/// Importance sampling of the environment (None for an empty image).
|
||
pub(crate) light: Option<Arc<EnvSampler>>,
|
||
/// Specular/glossiness shading (Specular color is F0, base color is diffuse).
|
||
pub spec_gloss: bool,
|
||
/// Ray offset off surfaces, scaled to the mesh.
|
||
pub(crate) eps: f32,
|
||
/// Subsurface scattering extinction per color channel (1 / mean free path, world units).
|
||
pub(crate) scatter_sigma: Vec3,
|
||
/// Bounding radius of the mesh (scales the scatter radius and the lens).
|
||
pub(crate) radius: f32,
|
||
/// Index of refraction of the Transmission channel.
|
||
pub ior: f32,
|
||
/// Thin lens: focus depth along the view axis (0: the camera's orbit target) and lens radius
|
||
/// as a fraction of the mesh's bounding radius (the viewport's depth of field).
|
||
pub lens: Option<[f32; 2]>,
|
||
}
|
||
|
||
impl TraceScene {
|
||
pub fn new(mesh: Arc<Mesh>, bvh: Arc<Bvh>, sets: Vec<TraceSet>, env: Arc<EnvImage>, env_rotation: f32) -> TraceScene {
|
||
let mut tri_set = vec![usize::MAX; mesh.triangle_count()];
|
||
let set_of = |material: usize| sets.iter().position(|s| s.material == material).unwrap_or(usize::MAX);
|
||
if mesh.submeshes.is_empty() {
|
||
tri_set.fill(set_of(0));
|
||
}
|
||
for sm in &mesh.submeshes {
|
||
let set = set_of(sm.material);
|
||
let first = sm.start as usize / 3;
|
||
for t in tri_set.iter_mut().skip(first).take(sm.count as usize / 3) {
|
||
*t = set;
|
||
}
|
||
}
|
||
let (lo, hi) = mesh.bounds();
|
||
let eps = ((hi - lo).length() * 2e-5).max(1e-6);
|
||
let light = EnvSampler::new(&env).map(Arc::new);
|
||
let radius = ((hi - lo).length() * 0.5).max(1e-6);
|
||
let mut scene = TraceScene {
|
||
mesh,
|
||
bvh,
|
||
sets,
|
||
env,
|
||
env_rotation,
|
||
tri_set: Arc::new(tri_set),
|
||
light,
|
||
spec_gloss: false,
|
||
eps,
|
||
scatter_sigma: Vec3::ONE,
|
||
radius,
|
||
ior: 1.5,
|
||
lens: None,
|
||
};
|
||
let d = DisplaySettings::default();
|
||
scene.set_scatter(d.scatter_color, d.scatter_radius);
|
||
scene
|
||
}
|
||
|
||
/// Subsurface scattering: the mean free path of each color channel is `radius` (a fraction
|
||
/// of the mesh's bounding radius) times that channel of `color`.
|
||
pub fn set_scatter(&mut self, color: [f32; 3], radius: f32) {
|
||
let floor = self.eps * 4.0;
|
||
self.scatter_sigma = Vec3::from(color.map(|c| 1.0 / (radius * c * self.radius).max(floor)));
|
||
}
|
||
|
||
/// The scene as `display` shows it: the imported environment `env_image` (when the display
|
||
/// names a resource and it decodes) or the built-in one, its rotation and the shading mode.
|
||
pub fn for_display(mesh: Arc<Mesh>, bvh: Arc<Bvh>, sets: Vec<TraceSet>, display: &DisplaySettings, env_image: Option<&ImageRes>) -> TraceScene {
|
||
let imported = env_image.and_then(|i| EnvImage::from_rgba(i.width, i.height, &i.rgba, i.srgb));
|
||
let env = imported.unwrap_or_else(|| crate::ibl::environment(&display.environment, 1024));
|
||
let mut scene = TraceScene::new(mesh, bvh, sets, Arc::new(env), display.env_rotation.to_radians());
|
||
scene.spec_gloss = display.spec_gloss;
|
||
scene.set_scatter(display.scatter_color, display.scatter_radius);
|
||
scene.ior = display.ior;
|
||
scene.lens = display.dof.enabled.then_some([display.dof.focus_distance, display.dof.aperture]);
|
||
scene
|
||
}
|
||
|
||
/// The camera ray through `ndc`, through a point of the lens when the scene has one.
|
||
fn camera_ray(&self, cam: &OrbitCamera, ndc: Vec2, aspect: f32, rng: &mut Rng) -> texturecraft_geom::Ray {
|
||
let ray = cam.ray(ndc, aspect);
|
||
let Some([focus, aperture]) = self.lens else { return ray };
|
||
let lens = aperture.max(0.0) * self.radius;
|
||
let fwd = cam.forward();
|
||
let along = ray.dir.dot(fwd);
|
||
if lens <= 0.0 || along <= 1e-6 {
|
||
return ray;
|
||
}
|
||
// The point this pixel sees on the focus plane, viewed from a random point of the lens.
|
||
let depth = if focus > 0.0 { focus } else { cam.distance };
|
||
let focal = ray.origin + ray.dir * ((depth - (ray.origin - cam.eye()).dot(fwd)) / along);
|
||
let right = fwd.cross(Vec3::Y).normalize_or(Vec3::X);
|
||
let up = right.cross(fwd);
|
||
let (r, phi) = (lens * rng.next().sqrt(), TAU * rng.next());
|
||
let origin = ray.origin + (right * phi.cos() + up * phi.sin()) * r;
|
||
texturecraft_geom::Ray { origin, dir: (focal - origin).normalize_or(ray.dir) }
|
||
}
|
||
|
||
/// World direction to environment space.
|
||
fn to_env(&self, d: Vec3) -> Vec3 {
|
||
let (s, c) = self.env_rotation.sin_cos();
|
||
Vec3::new(c * d.x - s * d.z, d.y, s * d.x + c * d.z)
|
||
}
|
||
|
||
fn env(&self, d: Vec3) -> Vec3 {
|
||
self.env.sample(self.to_env(d))
|
||
}
|
||
|
||
/// Solid-angle density of [`Self::sample_env`] picking world direction `d`.
|
||
fn env_pdf(&self, d: Vec3) -> f32 {
|
||
self.light.as_ref().map_or(0.0, |l| l.pdf(self.to_env(d)))
|
||
}
|
||
|
||
/// A world direction toward the environment, chosen by brightness, with its density.
|
||
fn sample_env(&self, rng: &mut Rng) -> Option<(Vec3, f32)> {
|
||
let (e, pdf) = self.light.as_ref()?.sample(rng.next(), rng.next(), rng.next(), rng.next())?;
|
||
let (s, c) = self.env_rotation.sin_cos();
|
||
Some((Vec3::new(c * e.x + s * e.z, e.y, -s * e.x + c * e.z), pdf))
|
||
}
|
||
}
|
||
|
||
/// Piecewise-constant importance sampling of an equirect environment by luminance and sin(theta).
|
||
pub(crate) struct EnvSampler {
|
||
pub(crate) width: usize,
|
||
pub(crate) height: usize,
|
||
/// Cumulative row probabilities (last = 1).
|
||
pub(crate) rows: Vec<f32>,
|
||
/// Cumulative probabilities within each row (last of each row = 1).
|
||
pub(crate) cols: Vec<f32>,
|
||
/// Probability of each pixel.
|
||
pub(crate) prob: Vec<f32>,
|
||
}
|
||
|
||
impl EnvSampler {
|
||
fn new(env: &EnvImage) -> Option<EnvSampler> {
|
||
let (w, h) = (env.width as usize, env.height as usize);
|
||
if w == 0 || h == 0 || env.data.len() < w * h {
|
||
return None;
|
||
}
|
||
let mut weight: Vec<f32> = env.data.iter().take(w * h).map(|c| luminance(Vec3::from(*c)).max(0.0)).collect();
|
||
for (y, row) in weight.chunks_mut(w).enumerate() {
|
||
let sin = (PI * (y as f32 + 0.5) / h as f32).sin();
|
||
row.iter_mut().for_each(|v| *v = (*v + 1e-4) * sin);
|
||
}
|
||
let total: f32 = weight.iter().sum();
|
||
if !total.is_finite() || total <= 0.0 {
|
||
return None;
|
||
}
|
||
let prob: Vec<f32> = weight.iter().map(|v| v / total).collect();
|
||
let mut rows = Vec::with_capacity(h);
|
||
let mut cols = Vec::with_capacity(w * h);
|
||
let mut acc_rows = 0.0;
|
||
for row in prob.chunks(w) {
|
||
let sum: f32 = row.iter().sum();
|
||
acc_rows += sum;
|
||
rows.push(acc_rows);
|
||
let mut acc = 0.0;
|
||
for p in row {
|
||
acc += if sum > 0.0 { p / sum } else { 1.0 / w as f32 };
|
||
cols.push(acc);
|
||
}
|
||
}
|
||
Some(EnvSampler { width: w, height: h, rows, cols, prob })
|
||
}
|
||
|
||
/// Environment-space direction and its solid-angle density.
|
||
fn sample(&self, u0: f32, u1: f32, u2: f32, u3: f32) -> Option<(Vec3, f32)> {
|
||
let y = self.rows.partition_point(|c| *c < u0 * self.rows.last().copied().unwrap_or(1.0)).min(self.height - 1);
|
||
let row = self.cols.get(y * self.width..(y + 1) * self.width)?;
|
||
let x = row.partition_point(|c| *c < u1 * row.last().copied().unwrap_or(1.0)).min(self.width - 1);
|
||
let d = crate::ibl::dir_of((x as f32 + u2) / self.width as f32, (y as f32 + u3) / self.height as f32);
|
||
let pdf = self.pdf(d);
|
||
(pdf > 0.0).then_some((d, pdf))
|
||
}
|
||
|
||
fn pdf(&self, d: Vec3) -> f32 {
|
||
let uv = crate::ibl::uv_of(d);
|
||
let x = ((uv.x * self.width as f32) as usize).min(self.width - 1);
|
||
let y = ((uv.y * self.height as f32) as usize).min(self.height - 1);
|
||
let sin = (PI * (y as f32 + 0.5) / self.height as f32).sin();
|
||
let p = self.prob.get(y * self.width + x).copied().unwrap_or(0.0);
|
||
if sin <= 1e-6 { 0.0 } else { p * (self.width * self.height) as f32 / (2.0 * PI * PI * sin) }
|
||
}
|
||
}
|
||
|
||
/// How the accumulated radiance becomes display pixels.
|
||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||
pub struct TraceDisplay {
|
||
/// Exposure multiplier (2^EV).
|
||
pub exposure: f32,
|
||
pub aces: bool,
|
||
/// How much of the environment shows behind the mesh (0: studio backdrop).
|
||
pub env_opacity: f32,
|
||
/// Filter the remaining noise (edge-aware; keeps texture detail).
|
||
pub denoise: bool,
|
||
}
|
||
|
||
impl TraceDisplay {
|
||
/// Exposure, tone mapping and background as the viewport shows them.
|
||
pub fn from_display(d: &DisplaySettings) -> TraceDisplay {
|
||
TraceDisplay { exposure: d.env_exposure.exp2(), aces: d.tone_mapping == ToneMapping::AcesFilmic, env_opacity: d.env_opacity, denoise: false }
|
||
}
|
||
}
|
||
|
||
/// Light transport settings.
|
||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||
pub struct TraceSettings {
|
||
/// Diffuse/specular bounces after the camera hit.
|
||
pub bounces: u32,
|
||
}
|
||
|
||
impl Default for TraceSettings {
|
||
fn default() -> Self {
|
||
TraceSettings { bounces: 6 }
|
||
}
|
||
}
|
||
|
||
#[derive(Clone, Copy, Default)]
|
||
struct Px {
|
||
/// Radiance summed over samples that hit the mesh.
|
||
hit: Vec3,
|
||
/// Sum of the squared luminance of those samples (for the variance).
|
||
hit_lum2: f32,
|
||
/// First-hit reflectance, shading normal and distance, summed (denoiser guides).
|
||
albedo: Vec3,
|
||
normal: Vec3,
|
||
depth: f32,
|
||
/// Environment radiance summed over samples that missed it.
|
||
env: Vec3,
|
||
hits: f32,
|
||
}
|
||
|
||
/// What one camera sample saw.
|
||
struct Sample {
|
||
radiance: Vec3,
|
||
albedo: Vec3,
|
||
normal: Vec3,
|
||
depth: f32,
|
||
}
|
||
|
||
/// The accumulation buffer of one view.
|
||
pub struct Tracer {
|
||
pub width: u32,
|
||
pub height: u32,
|
||
pub samples: u32,
|
||
/// First row of the pass in progress (see [`Tracer::pass_rows`]).
|
||
row: u32,
|
||
acc: Vec<Px>,
|
||
}
|
||
|
||
impl Tracer {
|
||
pub fn new(width: u32, height: u32) -> Tracer {
|
||
let (w, h) = (width.clamp(1, 8192), height.clamp(1, 8192));
|
||
Tracer { width: w, height: h, samples: 0, row: 0, acc: vec![Px::default(); (w * h) as usize] }
|
||
}
|
||
|
||
/// Add one sample per pixel.
|
||
pub fn pass(&mut self, scene: &TraceScene, cam: &OrbitCamera, settings: &TraceSettings) {
|
||
while !self.pass_rows(scene, cam, settings, self.height) {}
|
||
}
|
||
|
||
/// Sample up to `rows` more rows of the current pass; true when that finished the pass (the
|
||
/// new sample then counts in [`Tracer::samples`]). Lets a single-threaded caller spread a
|
||
/// pass over several frames.
|
||
pub fn pass_rows(&mut self, scene: &TraceScene, cam: &OrbitCamera, settings: &TraceSettings, rows: u32) -> bool {
|
||
let (w, h, pass) = (self.width, self.height, self.samples);
|
||
let aspect = w as f32 / h as f32;
|
||
let (y0, y1) = (self.row, self.row.saturating_add(rows.max(1)).min(h));
|
||
let span = self.acc.get_mut(y0 as usize * w as usize..y1 as usize * w as usize).unwrap_or_default();
|
||
span.par_chunks_mut(w as usize).enumerate().for_each(|(dy, row)| {
|
||
let y = y0 as usize + dy;
|
||
for (x, px) in row.iter_mut().enumerate() {
|
||
let mut rng = Rng::new(x as u32, y as u32, pass);
|
||
let ndc = Vec2::new((x as f32 + rng.next()) / w as f32 * 2.0 - 1.0, 1.0 - (y as f32 + rng.next()) / h as f32 * 2.0);
|
||
let ray = scene.camera_ray(cam, ndc, aspect, &mut rng);
|
||
match trace(scene, ray.origin, ray.dir, settings, &mut rng) {
|
||
Some(s) => {
|
||
px.hit += s.radiance;
|
||
px.hit_lum2 += luminance(s.radiance).powi(2);
|
||
px.albedo += s.albedo;
|
||
px.normal += s.normal;
|
||
px.depth += s.depth;
|
||
px.hits += 1.0;
|
||
}
|
||
None => px.env += scene.env(ray.dir),
|
||
}
|
||
}
|
||
});
|
||
if y1 >= h {
|
||
self.row = 0;
|
||
self.samples += 1;
|
||
true
|
||
} else {
|
||
self.row = y1;
|
||
false
|
||
}
|
||
}
|
||
|
||
/// Tone-mapped sRGB pixels, row-major from the top.
|
||
pub fn rgba8(&self, d: &TraceDisplay) -> Vec<u8> {
|
||
let n = self.samples.max(1) as f32;
|
||
let (w, h) = (self.width as f32, self.height as f32);
|
||
let denoised = if d.denoise { self.denoise() } else { Vec::new() };
|
||
let mut out = vec![0u8; self.acc.len() * 4];
|
||
out.par_chunks_mut(4).zip(self.acc.par_iter()).enumerate().for_each(|(i, (o, px))| {
|
||
let uv = Vec2::new(((i as u32 % self.width) as f32 + 0.5) / w, ((i as u32 / self.width) as f32 + 0.5) / h);
|
||
let a = px.hits / n;
|
||
let misses = n - px.hits;
|
||
let back = if misses > 0.0 { backdrop(uv).lerp(tonemap(px.env / misses, d), d.env_opacity.clamp(0.0, 1.0)) } else { backdrop(uv) };
|
||
let mean = denoised.get(i).copied().unwrap_or(px.hit / px.hits.max(1.0));
|
||
let scene = if px.hits > 0.0 { tonemap(mean, d) } else { Vec3::ZERO };
|
||
let c = back.lerp(scene, a);
|
||
for (k, v) in c.to_array().into_iter().enumerate() {
|
||
if let Some(o) = o.get_mut(k) {
|
||
*o = (texturecraft_texel::linear_to_srgb(v.clamp(0.0, 1.0)) * 255.0 + 0.5) as u8;
|
||
}
|
||
}
|
||
if let Some(o) = o.get_mut(3) {
|
||
*o = 255;
|
||
}
|
||
});
|
||
out
|
||
}
|
||
}
|
||
|
||
impl Tracer {
|
||
/// Edge-avoiding à-trous filtering of the mesh radiance: lighting is divided by the first-hit
|
||
/// reflectance (so texture detail stays sharp), filtered five times with growing steps, its
|
||
/// weights falling off across normal, depth and luminance edges (scaled by the estimated
|
||
/// noise), then multiplied back. Returns the mean radiance per pixel.
|
||
fn denoise(&self) -> Vec<Vec3> {
|
||
let (w, h) = (self.width as usize, self.height as usize);
|
||
struct G {
|
||
illum: Vec3,
|
||
albedo: Vec3,
|
||
normal: Vec3,
|
||
depth: f32,
|
||
var: f32,
|
||
hit: bool,
|
||
}
|
||
let guides: Vec<G> = self
|
||
.acc
|
||
.par_iter()
|
||
.map(|px| {
|
||
let n = px.hits.max(1.0);
|
||
let albedo = (px.albedo / n).max(Vec3::splat(0.02));
|
||
let mean = px.hit / n;
|
||
let var = (px.hit_lum2 / n - luminance(mean).powi(2)).max(0.0) / n;
|
||
let a = luminance(albedo).max(0.02);
|
||
G { illum: mean / albedo, albedo, normal: px.normal.normalize_or(Vec3::Z), depth: px.depth / n, var: var / (a * a), hit: px.hits > 0.0 }
|
||
})
|
||
.collect();
|
||
const H: [f32; 5] = [1.0 / 16.0, 1.0 / 4.0, 3.0 / 8.0, 1.0 / 4.0, 1.0 / 16.0];
|
||
let mut cur: Vec<(Vec3, f32)> = guides.iter().map(|g| (g.illum, g.var)).collect();
|
||
for step in [1usize, 2, 4, 8, 16] {
|
||
let prev = cur;
|
||
cur = (0..w * h)
|
||
.into_par_iter()
|
||
.map(|i| {
|
||
let (Some(p), Some(&(ip, vp))) = (guides.get(i), prev.get(i)) else { return (Vec3::ZERO, 0.0) };
|
||
if !p.hit {
|
||
return (ip, vp);
|
||
}
|
||
let (x, y) = ((i % w) as i64, (i / w) as i64);
|
||
let sigma_l = 4.0 * vp.sqrt() + 1e-3;
|
||
let (mut sum, mut wsum, mut vsum) = (Vec3::ZERO, 0.0f32, 0.0f32);
|
||
for (j, hy) in H.iter().enumerate() {
|
||
for (k, hx) in H.iter().enumerate() {
|
||
let qx = x + (k as i64 - 2) * step as i64;
|
||
let qy = y + (j as i64 - 2) * step as i64;
|
||
if qx < 0 || qy < 0 || qx >= w as i64 || qy >= h as i64 {
|
||
continue;
|
||
}
|
||
let qi = qy as usize * w + qx as usize;
|
||
let (Some(q), Some(&(iq, vq))) = (guides.get(qi), prev.get(qi)) else { continue };
|
||
if !q.hit {
|
||
continue;
|
||
}
|
||
let wn = p.normal.dot(q.normal).max(0.0).powi(64);
|
||
let wz = (-(p.depth - q.depth).abs() / (0.01 * p.depth.max(1e-3) * step as f32)).exp();
|
||
let wl = (-(luminance(ip) - luminance(iq)).abs() / sigma_l).exp();
|
||
let wt = hx * hy * wn * wz * wl;
|
||
sum += iq * wt;
|
||
wsum += wt;
|
||
vsum += wt * wt * vq;
|
||
}
|
||
}
|
||
if wsum > 1e-8 { (sum / wsum, vsum / (wsum * wsum)) } else { (ip, vp) }
|
||
})
|
||
.collect();
|
||
}
|
||
cur.iter().zip(&guides).map(|((illum, _), g)| *illum * g.albedo).collect()
|
||
}
|
||
}
|
||
|
||
/// The viewport's studio backdrop: a cool slate, lighter at the top (matches the post pass).
|
||
fn backdrop(uv: Vec2) -> Vec3 {
|
||
let d = uv * 2.0 - Vec2::ONE;
|
||
Vec3::new(0.0295, 0.0343, 0.0437).lerp(Vec3::new(0.0110, 0.0130, 0.0168), uv.y) * (1.0 - 0.09 * d.length_squared())
|
||
}
|
||
|
||
fn tonemap(hdr: Vec3, d: &TraceDisplay) -> Vec3 {
|
||
let x = hdr.max(Vec3::ZERO) * d.exposure;
|
||
if !d.aces {
|
||
return x.min(Vec3::ONE);
|
||
}
|
||
let v = x * 0.6;
|
||
((v * (v * 2.51 + 0.03)) / (v * (v * 2.43 + 0.59) + 0.14)).clamp(Vec3::ZERO, Vec3::ONE)
|
||
}
|
||
|
||
/// Small, fast per-sample generator (PCG hash seeded by pixel and pass).
|
||
struct Rng(u32);
|
||
|
||
impl Rng {
|
||
fn new(x: u32, y: u32, pass: u32) -> Rng {
|
||
Rng(texturecraft_texel::noise::pcg3d(x, y, pass.wrapping_mul(7919).wrapping_add(17))[0] | 1)
|
||
}
|
||
|
||
fn next(&mut self) -> f32 {
|
||
// xorshift32
|
||
self.0 ^= self.0 << 13;
|
||
self.0 ^= self.0 >> 17;
|
||
self.0 ^= self.0 << 5;
|
||
(self.0 >> 8) as f32 / (1u32 << 24) as f32
|
||
}
|
||
}
|
||
|
||
/// Shading data at a hit.
|
||
struct Surface {
|
||
pos: Vec3,
|
||
/// Geometric normal facing the incoming ray.
|
||
geo: Vec3,
|
||
n: Vec3,
|
||
/// Anisotropy direction: the mesh tangent turned by the anisotropy angle, orthogonal to `n`.
|
||
tangent: Vec3,
|
||
/// Diffuse albedo and specular reflectance at normal incidence.
|
||
diffuse: Vec3,
|
||
f0: Vec3,
|
||
roughness: f32,
|
||
emissive: Vec3,
|
||
opacity: f32,
|
||
anisotropy: f32,
|
||
coat: f32,
|
||
coat_roughness: f32,
|
||
/// The interpolated mesh normal (the clear coat ignores normal and height channels).
|
||
coat_n: Vec3,
|
||
/// Sheen color × weight.
|
||
sheen: Vec3,
|
||
sheen_roughness: f32,
|
||
scatter: f32,
|
||
/// Transmissive part of the base, its tint (the base color), and whether the ray enters the
|
||
/// mesh here (it hit the outside of the triangle).
|
||
transmission: f32,
|
||
base: Vec3,
|
||
front: bool,
|
||
}
|
||
|
||
fn lerp3(a: Vec3, b: Vec3, c: Vec3, u: f32, v: f32) -> Vec3 {
|
||
a * (1.0 - u - v) + b * u + c * v
|
||
}
|
||
|
||
/// Tangent-space normal blending (reoriented normal mapping), as in the viewport shader.
|
||
fn rnm(base: Vec3, detail: Vec3) -> Vec3 {
|
||
let t = base + Vec3::Z;
|
||
let u = detail * Vec3::new(-1.0, -1.0, 1.0);
|
||
(t * t.dot(u) - u * t.z).normalize_or(Vec3::Z)
|
||
}
|
||
|
||
fn surface(scene: &TraceScene, tri: u32, u: f32, v: f32, o: Vec3, d: Vec3, t: f32) -> Option<Surface> {
|
||
let m = &scene.mesh;
|
||
let i = tri as usize * 3;
|
||
let idx = [*m.indices.get(i)? as usize, *m.indices.get(i + 1)? as usize, *m.indices.get(i + 2)? as usize];
|
||
let p = idx.map(|k| m.positions.get(k).copied().unwrap_or(Vec3::ZERO));
|
||
let mut geo = (p[1] - p[0]).cross(p[2] - p[0]).normalize_or(Vec3::Y);
|
||
let nrm = idx.map(|k| m.normals.get(k).copied().unwrap_or(geo));
|
||
let mut n_geo = lerp3(nrm[0], nrm[1], nrm[2], u, v).normalize_or(geo);
|
||
let front = geo.dot(d) <= 0.0;
|
||
if !front {
|
||
geo = -geo;
|
||
}
|
||
if n_geo.dot(geo) < 0.0 {
|
||
n_geo = -n_geo;
|
||
}
|
||
let uvs = idx.map(|k| m.uvs.get(k).copied().unwrap_or(Vec2::ZERO));
|
||
let uv = uvs[0] * (1.0 - u - v) + uvs[1] * u + uvs[2] * v;
|
||
let tan = idx.map(|k| m.tangents.get(k).copied().unwrap_or(texturecraft_geom::glam::Vec4::X));
|
||
let tw = lerp3(tan[0].truncate(), tan[1].truncate(), tan[2].truncate(), u, v);
|
||
let sign = if tan[0].w < 0.0 { -1.0 } else { 1.0 };
|
||
|
||
let set = scene.tri_set.get(tri as usize).and_then(|s| scene.sets.get(*s));
|
||
// The composite texel at offset (dx, dy) from the hit.
|
||
let texel = |s: &TraceSet, dx: i32, dy: i32| {
|
||
let (w, h) = (s.composite.resolution.max(1) as i32, s.composite.height.max(1) as i32);
|
||
(((uv.x * w as f32).floor() as i32 + dx).rem_euclid(w) as u32, ((uv.y * h as f32).floor() as i32 + dy).rem_euclid(h) as u32)
|
||
};
|
||
let ch = |c: Channel, dx: i32, dy: i32| -> [f32; 3] {
|
||
let Some(s) = set else { return c.default_value() };
|
||
let (x, y) = texel(s, dx, dy);
|
||
s.composite.value(c, x, y)
|
||
};
|
||
let base = Vec3::from(ch(Channel::BaseColor, 0, 0));
|
||
// A UV tile smaller than its atlas block has fewer texels per UV unit: slopes per texel shrink.
|
||
let k = set.map_or(0.0, |s| {
|
||
let (x, y) = texel(s, 0, 0);
|
||
s.height_strength * s.composite.resolution as f32 / 16.0 * s.composite.block_scales.at(x, y)
|
||
});
|
||
let n_height = if k != 0.0 {
|
||
let h = |dx, dy| ch(Channel::Height, dx, dy)[0];
|
||
Vec3::new(-(h(1, 0) - h(-1, 0)) * 0.5 * k, (h(0, 1) - h(0, -1)) * 0.5 * k, 1.0).normalize_or(Vec3::Z)
|
||
} else {
|
||
Vec3::Z
|
||
};
|
||
let detail = (Vec3::from(ch(Channel::Normal, 0, 0)) * 2.0 - Vec3::ONE).normalize_or(Vec3::Z);
|
||
let n_ts = rnm(n_height, detail);
|
||
let tt = (tw - n_geo * n_geo.dot(tw)).normalize_or(n_geo.any_orthonormal_vector());
|
||
let b = n_geo.cross(tt) * sign;
|
||
let mut n = (tt * n_ts.x + b * n_ts.y + n_geo * n_ts.z).normalize_or(n_geo);
|
||
if n.dot(-d) <= 0.0 {
|
||
n = n_geo;
|
||
}
|
||
let scalar = |c: Channel| ch(c, 0, 0)[0].clamp(0.0, 1.0);
|
||
let (sin, cos) = (scalar(Channel::AnisotropyAngle) * PI).sin_cos();
|
||
let turned = tt * cos + b * sin;
|
||
let tangent = (turned - n * n.dot(turned)).normalize_or(n.any_orthonormal_vector());
|
||
// Glossiness replaces roughness wherever a set has it (as in the viewport).
|
||
let roughness = match set {
|
||
Some(s) if s.composite.channels.contains_key(&Channel::Glossiness) => 1.0 - ch(Channel::Glossiness, 0, 0)[0],
|
||
_ => ch(Channel::Roughness, 0, 0)[0],
|
||
};
|
||
let (diffuse, f0, metallic) = if scene.spec_gloss {
|
||
let f0 = Vec3::from(ch(Channel::Specular, 0, 0)).clamp(Vec3::ZERO, Vec3::ONE);
|
||
(base * (1.0 - f0.max_element()), f0, 0.0)
|
||
} else {
|
||
let metallic = ch(Channel::Metallic, 0, 0)[0].clamp(0.0, 1.0);
|
||
let level = ch(Channel::SpecularLevel, 0, 0)[0].clamp(0.0, 1.0);
|
||
(base * (1.0 - metallic), Vec3::splat(0.08 * level).lerp(base, metallic), metallic)
|
||
};
|
||
let coat_base = if n_geo.dot(-d) > 0.0 { n_geo } else { geo };
|
||
let coat_n = match set {
|
||
Some(s) if s.composite.channels.contains_key(&Channel::CoatNormal) => {
|
||
let c = (Vec3::from(ch(Channel::CoatNormal, 0, 0)) * 2.0 - Vec3::ONE).normalize_or(Vec3::Z);
|
||
let turned = (tt * c.x + b * c.y + coat_base * c.z).normalize_or(coat_base);
|
||
if turned.dot(-d) > 0.0 { turned } else { coat_base }
|
||
}
|
||
_ => coat_base,
|
||
};
|
||
Some(Surface {
|
||
pos: o + d * t,
|
||
geo,
|
||
n,
|
||
tangent,
|
||
diffuse,
|
||
f0,
|
||
roughness: roughness.clamp(0.045, 1.0),
|
||
emissive: Vec3::from(ch(Channel::Emissive, 0, 0)),
|
||
opacity: ch(Channel::Opacity, 0, 0)[0].clamp(0.0, 1.0),
|
||
anisotropy: scalar(Channel::AnisotropyLevel),
|
||
coat: scalar(Channel::CoatWeight),
|
||
coat_roughness: scalar(Channel::CoatRoughness).max(0.045),
|
||
coat_n,
|
||
sheen: Vec3::from(ch(Channel::SheenColor, 0, 0)).clamp(Vec3::ZERO, Vec3::ONE) * scalar(Channel::SheenWeight),
|
||
sheen_roughness: scalar(Channel::SheenRoughness).max(0.07),
|
||
scatter: scalar(Channel::ScatterWeight),
|
||
transmission: scalar(Channel::Transmission) * (1.0 - metallic),
|
||
base: base.clamp(Vec3::ZERO, Vec3::ONE),
|
||
front,
|
||
})
|
||
}
|
||
|
||
fn luminance(c: Vec3) -> f32 {
|
||
c.dot(Vec3::new(0.2126, 0.7152, 0.0722))
|
||
}
|
||
|
||
fn schlick(f0: Vec3, cos: f32) -> Vec3 {
|
||
f0 + (Vec3::ONE - f0) * (1.0 - cos.clamp(0.0, 1.0)).powi(5)
|
||
}
|
||
|
||
/// Fresnel of the clear coat (IOR 1.5).
|
||
fn coat_fresnel(cos: f32) -> f32 {
|
||
schlick(Vec3::splat(0.04), cos).x
|
||
}
|
||
|
||
/// Cosine-weighted direction around local +z.
|
||
fn cosine_local(u1: f32, u2: f32) -> Vec3 {
|
||
let r = u1.sqrt();
|
||
let phi = TAU * u2;
|
||
Vec3::new(r * phi.cos(), r * phi.sin(), (1.0 - u1).max(0.0).sqrt())
|
||
}
|
||
|
||
/// Cosine-weighted world direction around `n`.
|
||
fn cosine_around(n: Vec3, rng: &mut Rng) -> Vec3 {
|
||
let (t, b) = n.any_orthonormal_pair();
|
||
let l = cosine_local(rng.next(), rng.next());
|
||
t * l.x + b * l.y + n * l.z
|
||
}
|
||
|
||
/// Smith GGX masking for one direction (local frame, z = normal), anisotropic alphas.
|
||
fn smith_g1(w: Vec3, at: f32, ab: f32) -> f32 {
|
||
let z = w.z.max(1e-6);
|
||
2.0 * z / (z + (at * at * w.x * w.x + ab * ab * w.y * w.y + z * z).sqrt())
|
||
}
|
||
|
||
/// GGX visible-normal sampling (Heitz 2018; local frame, z = normal), anisotropic alphas.
|
||
fn sample_vndf(ve: Vec3, at: f32, ab: f32, u1: f32, u2: f32) -> Vec3 {
|
||
let vh = Vec3::new(at * ve.x, ab * ve.y, ve.z).normalize_or(Vec3::Z);
|
||
let len2 = vh.x * vh.x + vh.y * vh.y;
|
||
let t1 = if len2 > 0.0 { Vec3::new(-vh.y, vh.x, 0.0) / len2.sqrt() } else { Vec3::X };
|
||
let t2 = vh.cross(t1);
|
||
let r = u1.sqrt();
|
||
let phi = TAU * u2;
|
||
let p1 = r * phi.cos();
|
||
let s = 0.5 * (1.0 + vh.z);
|
||
let p2 = (1.0 - s) * (1.0 - p1 * p1).max(0.0).sqrt() + s * r * phi.sin();
|
||
let nh = t1 * p1 + t2 * p2 + vh * (1.0 - p1 * p1 - p2 * p2).max(0.0).sqrt();
|
||
Vec3::new(at * nh.x, ab * nh.y, nh.z.max(1e-6)).normalize_or(Vec3::Z)
|
||
}
|
||
|
||
/// A GGX microfacet lobe in its own frame (z = normal, x = the direction of `at`).
|
||
struct Ggx {
|
||
t: Vec3,
|
||
b: Vec3,
|
||
n: Vec3,
|
||
/// View direction, local.
|
||
v: Vec3,
|
||
at: f32,
|
||
ab: f32,
|
||
}
|
||
|
||
impl Ggx {
|
||
fn new(t: Vec3, n: Vec3, v: Vec3, at: f32, ab: f32) -> Ggx {
|
||
let b = n.cross(t);
|
||
Ggx { t, b, n, v: Vec3::new(v.dot(t), v.dot(b), v.dot(n).max(1e-4)), at: at.max(1e-3), ab: ab.max(1e-3) }
|
||
}
|
||
|
||
fn local(&self, w: Vec3) -> Vec3 {
|
||
Vec3::new(w.dot(self.t), w.dot(self.b), w.dot(self.n))
|
||
}
|
||
|
||
fn d(&self, h: Vec3) -> f32 {
|
||
let k = (h.x / self.at).powi(2) + (h.y / self.ab).powi(2) + h.z * h.z;
|
||
1.0 / (PI * self.at * self.ab * k * k).max(1e-12)
|
||
}
|
||
|
||
/// D·G / (4 cos θv) toward world direction `w` (the BRDF × cos θl without Fresnel), the
|
||
/// density of [`Self::sample`] picking `w`, and cos(l, h) for the Fresnel term.
|
||
fn eval(&self, w: Vec3) -> Option<(f32, f32, f32)> {
|
||
let l = self.local(w);
|
||
if l.z <= 0.0 {
|
||
return None;
|
||
}
|
||
let h = (l + self.v).normalize_or(Vec3::Z);
|
||
let d = self.d(h);
|
||
let g1v = smith_g1(self.v, self.at, self.ab);
|
||
let pdf = g1v * d / (4.0 * self.v.z);
|
||
Some((pdf * smith_g1(l, self.at, self.ab), pdf, l.dot(h)))
|
||
}
|
||
|
||
/// A world direction reflected off a visible normal.
|
||
fn sample(&self, u1: f32, u2: f32) -> Option<Vec3> {
|
||
let h = sample_vndf(self.v, self.at, self.ab, u1, u2);
|
||
let l = h * 2.0 * self.v.dot(h) - self.v;
|
||
(l.z > 0.0).then(|| self.t * l.x + self.b * l.y + self.n * l.z)
|
||
}
|
||
}
|
||
|
||
/// Sheen distribution ("Charlie"), alpha = sheen roughness².
|
||
fn d_charlie(a: f32, noh: f32) -> f32 {
|
||
let inv = 1.0 / a;
|
||
(2.0 + inv) * (1.0 - noh * noh).max(1e-4).powf(inv * 0.5) / TAU
|
||
}
|
||
|
||
/// Estevez & Kulla's fitted Λ of the sheen visibility ("Production Friendly Microfacet Sheen
|
||
/// BRDF", 2017).
|
||
fn sheen_lambda(cos: f32, a: f32) -> f32 {
|
||
let o = (1.0 - a) * (1.0 - a);
|
||
let mix = |x: f32, y: f32| x + (y - x) * o;
|
||
let l = |x: f32| {
|
||
mix(21.5473, 25.3245) / (1.0 + mix(3.82987, 3.32435) * x.max(1e-4).powf(mix(0.19823, 0.16801))) + mix(-1.97760, -1.27393) * x + mix(-4.32054, -4.85967)
|
||
};
|
||
if cos < 0.5 { l(cos).exp() } else { (2.0 * l(0.5) - l(1.0 - cos)).exp() }
|
||
}
|
||
|
||
fn sheen_vis(nov: f32, nol: f32, a: f32) -> f32 {
|
||
(1.0 / ((1.0 + sheen_lambda(nov, a) + sheen_lambda(nol, a)) * 4.0 * nov * nol.max(1e-4))).clamp(0.0, 1.0)
|
||
}
|
||
|
||
/// Directional albedo of the sheen lobe at sheen roughness `r` (the viewport's fit, see
|
||
/// `sheen_albedo` in mesh.wgsl).
|
||
fn sheen_albedo(nov: f32, r: f32) -> f32 {
|
||
let a = 1.2416 - 1.7580 * r + 1.7164 * r * r;
|
||
let b = 6.2757 / (r + 0.2077) - 8.6381 + 4.4979 * r;
|
||
let q = 1.2287 - 0.5161 * r;
|
||
let c = 0.1121 * r - 0.3840 * r * r;
|
||
(a * (-b * nov.max(0.0).powf(q)).exp() + c).clamp(0.0, 1.0)
|
||
}
|
||
|
||
/// The surface's BRDF at one hit: anisotropic GGX specular and Lambert diffuse, under a sheen
|
||
/// and a clear coat. The scattering part of the diffuse light is not in it: see
|
||
/// [`Bsdf::walk_albedo`].
|
||
struct Bsdf {
|
||
spec: Ggx,
|
||
coat: Ggx,
|
||
f0: Vec3,
|
||
/// Diffuse albedo that reflects at the surface.
|
||
diffuse: Vec3,
|
||
/// Fresnel at the view angle.
|
||
fv: Vec3,
|
||
coat_weight: f32,
|
||
/// Energy the coat lets through toward the view.
|
||
coat_t: f32,
|
||
sheen: Vec3,
|
||
sheen_a: f32,
|
||
sheen_r: f32,
|
||
/// Sheen albedo toward the view.
|
||
sheen_ev: f32,
|
||
/// Probabilities of sampling the specular, diffuse, sheen and coat lobes.
|
||
p: [f32; 4],
|
||
/// Albedo of the diffuse light that scatters under the surface, and the probability of
|
||
/// following it with a random walk instead of sampling this BRDF.
|
||
walk_albedo: Vec3,
|
||
p_walk: f32,
|
||
}
|
||
|
||
impl Bsdf {
|
||
fn new(s: &Surface, v: Vec3) -> Bsdf {
|
||
let a = (s.roughness * s.roughness).max(1e-3);
|
||
let spec = Ggx::new(s.tangent, s.n, v, a * (1.0 + s.anisotropy), a * (1.0 - s.anisotropy));
|
||
let coat_a = s.coat_roughness * s.coat_roughness;
|
||
let coat = Ggx::new(s.coat_n.any_orthonormal_vector(), s.coat_n, v, coat_a, coat_a);
|
||
let fv = schlick(s.f0, spec.v.z);
|
||
let coat_t = 1.0 - s.coat * coat_fresnel(coat.v.z);
|
||
let sheen_ev = sheen_albedo(spec.v.z, s.sheen_roughness);
|
||
let base = coat_t * (1.0 - s.sheen.max_element() * sheen_ev);
|
||
let diffuse = s.diffuse * (1.0 - s.scatter);
|
||
let walk_albedo = s.diffuse * s.scatter * (Vec3::ONE - fv) * base;
|
||
let w = [luminance(fv) * base, luminance(diffuse * (Vec3::ONE - fv)) * base, luminance(s.sheen) * sheen_ev * coat_t, s.coat * coat_fresnel(coat.v.z)];
|
||
let sum: f32 = w.iter().sum();
|
||
let w = w.map(|x| if x > 1e-5 { x.max(0.1 * sum) } else { 0.0 });
|
||
let total: f32 = w.iter().sum();
|
||
let p = if total > 0.0 { w.map(|x| x / total) } else { [1.0, 0.0, 0.0, 0.0] };
|
||
let walk = luminance(walk_albedo);
|
||
let p_walk = if walk > 1e-5 { (walk / (walk + sum)).clamp(0.05, 0.95) } else { 0.0 };
|
||
Bsdf {
|
||
spec,
|
||
coat,
|
||
f0: s.f0,
|
||
diffuse,
|
||
fv,
|
||
coat_weight: s.coat,
|
||
coat_t,
|
||
sheen: s.sheen,
|
||
sheen_a: s.sheen_roughness * s.sheen_roughness,
|
||
sheen_r: s.sheen_roughness,
|
||
sheen_ev,
|
||
p,
|
||
walk_albedo,
|
||
p_walk,
|
||
}
|
||
}
|
||
|
||
/// BRDF times cos(theta) toward world direction `w`, and the density of [`Self::sample`]
|
||
/// picking it.
|
||
fn eval(&self, w: Vec3) -> (Vec3, f32) {
|
||
let (mut f, mut pdf) = (Vec3::ZERO, 0.0);
|
||
let l = self.spec.local(w);
|
||
if l.z > 0.0 {
|
||
// Sheen albedo scaling (the glTF sheen convention): energy the sheen reflects
|
||
// toward the view or the light never reaches the base.
|
||
let m = self.sheen.max_element();
|
||
let base = self.coat_t * if m > 0.0 { (1.0 - m * self.sheen_ev).min(1.0 - m * sheen_albedo(l.z, self.sheen_r)) } else { 1.0 };
|
||
if let Some((g, p, cos_lh)) = self.spec.eval(w) {
|
||
f += schlick(self.f0, cos_lh) * g * base;
|
||
pdf += self.p[0] * p;
|
||
}
|
||
f += self.diffuse * (Vec3::ONE - self.fv) * (l.z / PI * base);
|
||
pdf += (self.p[1] + self.p[2]) * l.z / PI;
|
||
if m > 0.0 {
|
||
let h = (l + self.spec.v).normalize_or(Vec3::Z);
|
||
f += self.sheen * (d_charlie(self.sheen_a, h.z) * sheen_vis(self.spec.v.z, l.z, self.sheen_a) * l.z * self.coat_t);
|
||
}
|
||
}
|
||
if self.coat_weight > 0.0
|
||
&& let Some((g, p, cos_lh)) = self.coat.eval(w)
|
||
{
|
||
f += Vec3::splat(self.coat_weight * coat_fresnel(cos_lh) * g);
|
||
pdf += self.p[3] * p;
|
||
}
|
||
(f, pdf)
|
||
}
|
||
|
||
/// A world direction from the BRDF lobes (specular lobes by visible normals, diffuse and
|
||
/// sheen by cosine).
|
||
fn sample(&self, rng: &mut Rng) -> Option<Vec3> {
|
||
let (u0, u1, u2) = (rng.next(), rng.next(), rng.next());
|
||
let [ps, pd, pz, _] = self.p;
|
||
if u0 < ps {
|
||
self.spec.sample(u1, u2)
|
||
} else if u0 < ps + pd + pz {
|
||
let l = cosine_local(u1, u2);
|
||
Some(self.spec.t * l.x + self.spec.b * l.y + self.spec.n * l.z)
|
||
} else {
|
||
self.coat.sample(u1, u2)
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Unpolarized Fresnel reflectance of a dielectric interface; `eta` = n(incident) / n(other side).
|
||
fn fresnel_dielectric(cos_i: f32, eta: f32) -> f32 {
|
||
let sin2_t = eta * eta * (1.0 - cos_i * cos_i).max(0.0);
|
||
if sin2_t >= 1.0 {
|
||
return 1.0;
|
||
}
|
||
let cos_t = (1.0 - sin2_t).sqrt();
|
||
let rs = (eta * cos_i - cos_t) / (eta * cos_i + cos_t);
|
||
let rp = (cos_i - eta * cos_t) / (cos_i + eta * cos_t);
|
||
0.5 * (rs * rs + rp * rp)
|
||
}
|
||
|
||
/// Sampling density standing in for a lobe that next-event estimation never samples (its
|
||
/// environment hits take the full MIS weight).
|
||
const UNSAMPLED_PDF: f32 = 1e15;
|
||
|
||
/// The transmissive base as a rough dielectric interface (GGX, visible normals): reflect with
|
||
/// the Fresnel at `ior`, else refract into (or out of) the mesh. Returns the new direction and the
|
||
/// path weight (G1 of the new direction; the base color tints light entering the mesh).
|
||
/// shortcut: radiance is not scaled by the squared IOR ratio at each crossing (the factors cancel
|
||
/// for paths that leave the mesh again).
|
||
fn dielectric(s: &Surface, v: Vec3, ior: f32, rng: &mut Rng) -> Option<(Vec3, Vec3)> {
|
||
let a = (s.roughness * s.roughness).max(1e-3);
|
||
let lobe = Ggx::new(s.tangent, s.n, v, a, a);
|
||
let hl = sample_vndf(lobe.v, a, a, rng.next(), rng.next());
|
||
let h = lobe.t * hl.x + lobe.b * hl.y + lobe.n * hl.z;
|
||
let cos_i = v.dot(h).max(1e-6);
|
||
let eta = if s.front { 1.0 / ior.max(1.0) } else { ior.max(1.0) };
|
||
if rng.next() < fresnel_dielectric(cos_i, eta) {
|
||
let l = h * 2.0 * cos_i - v;
|
||
let ll = lobe.local(l);
|
||
return (l.dot(s.geo) > 0.0 && ll.z > 0.0).then(|| (l, Vec3::splat(smith_g1(ll, a, a))));
|
||
}
|
||
let cos_t = (1.0 - eta * eta * (1.0 - cos_i * cos_i)).max(0.0).sqrt();
|
||
let l = (h * (eta * cos_i - cos_t) - v * eta).normalize_or(-v);
|
||
let ll = lobe.local(l);
|
||
let tint = if s.front { s.base } else { Vec3::ONE };
|
||
(l.dot(s.geo) < 0.0 && ll.z < 0.0).then(|| (l, tint * smith_g1(-ll, a, a)))
|
||
}
|
||
|
||
/// Most scattering events a subsurface random walk takes before giving up.
|
||
const WALK_STEPS: usize = 48;
|
||
|
||
/// Follow light under the surface at `s`: enter by a cosine-weighted direction, then fly
|
||
/// exponential distances (one color channel's extinction picked per step, weighted by the
|
||
/// average density over the channels) and scatter isotropically until the path leaves the
|
||
/// mesh. Returns the exit point, the outward geometric normal there and the per-channel weight.
|
||
fn random_walk(scene: &TraceScene, s: &Surface, rng: &mut Rng) -> Option<(Vec3, Vec3, Vec3)> {
|
||
let sigma = scene.scatter_sigma;
|
||
let mean = |v: Vec3| (v.x + v.y + v.z) / 3.0;
|
||
let mut p = s.pos - s.geo * scene.eps;
|
||
let mut d = cosine_around(-s.geo, rng);
|
||
let mut w = Vec3::ONE;
|
||
for _ in 0..WALK_STEPS {
|
||
let c = ((rng.next() * 3.0) as usize).min(2);
|
||
let t = -(1.0 - rng.next()).max(1e-12).ln() / sigma[c];
|
||
if let Some(hit) = scene.bvh.closest(p, d, t) {
|
||
let tr = (-sigma * hit.t).exp();
|
||
w *= tr / mean(tr).max(1e-30);
|
||
let m = &scene.mesh;
|
||
let i = hit.tri as usize * 3;
|
||
let q = [m.indices.get(i)?, m.indices.get(i + 1)?, m.indices.get(i + 2)?].map(|k| m.positions.get(*k as usize).copied().unwrap_or(Vec3::ZERO));
|
||
let n = (q[1] - q[0]).cross(q[2] - q[0]).normalize_or(-d);
|
||
let out = if n.dot(d) > 0.0 { n } else { -n };
|
||
return w.is_finite().then_some((p + d * hit.t, out, w));
|
||
}
|
||
let tr = (-sigma * t).exp();
|
||
w *= sigma * tr / mean(sigma * tr).max(1e-30);
|
||
p += d * t;
|
||
let z = 1.0 - 2.0 * rng.next();
|
||
let phi = TAU * rng.next();
|
||
let r = (1.0 - z * z).max(0.0).sqrt();
|
||
d = Vec3::new(r * phi.cos(), r * phi.sin(), z);
|
||
}
|
||
None
|
||
}
|
||
|
||
/// Power-heuristic MIS weight of a strategy with density `a` against one with density `b`.
|
||
fn mis(a: f32, b: f32) -> f32 {
|
||
let (a2, b2) = (a * a, b * b);
|
||
if a2 + b2 > 0.0 { a2 / (a2 + b2) } else { 0.0 }
|
||
}
|
||
|
||
/// Clamp rare, very bright indirect contributions (fireflies) to keep progressive renders calm.
|
||
fn clamp_firefly(c: Vec3) -> Vec3 {
|
||
let lum = luminance(c);
|
||
if lum > 32.0 { c * (32.0 / lum) } else { c }
|
||
}
|
||
|
||
/// Next-event estimation toward the environment from `pos` (geometric normal `geo`): `eval`
|
||
/// gives the BRDF × cos toward a direction and the density of the path's own sampling of it.
|
||
fn next_event(scene: &TraceScene, pos: Vec3, geo: Vec3, thr: Vec3, rng: &mut Rng, eval: impl Fn(Vec3) -> (Vec3, f32)) -> Vec3 {
|
||
let Some((wl, pdf_env)) = scene.sample_env(rng) else { return Vec3::ZERO };
|
||
if wl.dot(geo) <= 0.0 {
|
||
return Vec3::ZERO;
|
||
}
|
||
let (f, pdf_brdf) = eval(wl);
|
||
if f.max_element() <= 0.0 || scene.bvh.occluded(pos + geo * scene.eps, wl, f32::MAX) {
|
||
return Vec3::ZERO;
|
||
}
|
||
clamp_firefly(thr * f * scene.env(wl) * (mis(pdf_env, pdf_brdf) / pdf_env))
|
||
}
|
||
|
||
/// Radiance along a camera ray; None when it misses the mesh. Environment light is gathered
|
||
/// both by sampling it directly (next-event estimation) and by BRDF sampling, combined with MIS.
|
||
fn trace(scene: &TraceScene, mut o: Vec3, mut d: Vec3, settings: &TraceSettings, rng: &mut Rng) -> Option<Sample> {
|
||
let origin = o;
|
||
let mut first: Option<(Vec3, Vec3, f32)> = None;
|
||
let mut thr = Vec3::ONE;
|
||
let mut l = Vec3::ZERO;
|
||
let mut bounce = 0u32;
|
||
// Density of the BRDF sample that produced `d` (None for the camera ray).
|
||
let mut brdf_pdf: Option<f32> = None;
|
||
// Cutout surfaces don't count as bounces; cap them so a stack of cards can't loop forever.
|
||
for _ in 0..settings.bounces + 24 {
|
||
let Some(hit) = scene.bvh.closest(o, d, f32::MAX) else {
|
||
let pdf = brdf_pdf?;
|
||
let w = if scene.light.is_some() { mis(pdf, scene.env_pdf(d)) } else { 1.0 };
|
||
l += clamp_firefly(thr * scene.env(d) * w);
|
||
break;
|
||
};
|
||
let Some(s) = surface(scene, hit.tri, hit.u, hit.v, o, d, hit.t) else { break };
|
||
if rng.next() > s.opacity {
|
||
o = s.pos - s.geo * scene.eps;
|
||
continue;
|
||
}
|
||
if first.is_none() {
|
||
first = Some(((s.diffuse + s.f0).min(Vec3::ONE), s.n, (s.pos - origin).length()));
|
||
}
|
||
l += thr * s.emissive;
|
||
if bounce >= settings.bounces {
|
||
break;
|
||
}
|
||
// Transmission is picked by its weight (a glass event, without next-event estimation);
|
||
// otherwise the surface shades as if it had none.
|
||
let glass = s.transmission > 0.0 && rng.next() < s.transmission;
|
||
let bsdf = Bsdf::new(&s, -d);
|
||
// The BRDF is sampled with probability 1 − p_walk (densities below include that).
|
||
let keep = 1.0 - bsdf.p_walk;
|
||
if !glass {
|
||
l += next_event(scene, s.pos, s.geo, thr, rng, |wl| {
|
||
let (f, pdf) = bsdf.eval(wl);
|
||
(f, pdf * keep)
|
||
});
|
||
}
|
||
let (wi, geo) = if glass {
|
||
let Some((wi, w)) = dielectric(&s, -d, scene.ior, rng) else { break };
|
||
thr *= w;
|
||
brdf_pdf = Some(UNSAMPLED_PDF);
|
||
o = s.pos;
|
||
(wi, s.geo)
|
||
} else if bsdf.p_walk > 0.0 && rng.next() < bsdf.p_walk {
|
||
let Some((exit, out, w)) = random_walk(scene, &s, rng) else { break };
|
||
thr *= bsdf.walk_albedo * w / bsdf.p_walk;
|
||
// The light leaves the exit point like a Lambertian emitter.
|
||
l += next_event(scene, exit, out, thr, rng, |wl| {
|
||
let c = wl.dot(out).max(0.0) / PI;
|
||
(Vec3::splat(c), c)
|
||
});
|
||
let wi = cosine_around(out, rng);
|
||
brdf_pdf = Some(wi.dot(out).max(1e-6) / PI);
|
||
o = exit;
|
||
(wi, out)
|
||
} else {
|
||
let Some(wi) = bsdf.sample(rng) else { break };
|
||
let (f, pdf) = bsdf.eval(wi);
|
||
if pdf <= 0.0 {
|
||
break;
|
||
}
|
||
thr *= f / (pdf * keep);
|
||
brdf_pdf = Some(pdf * keep);
|
||
o = s.pos;
|
||
(wi, s.geo)
|
||
};
|
||
if bounce >= 2 {
|
||
let p = thr.max_element().clamp(0.05, 0.95);
|
||
if rng.next() > p {
|
||
break;
|
||
}
|
||
thr /= p;
|
||
}
|
||
let side = if wi.dot(geo) >= 0.0 { 1.0 } else { -1.0 };
|
||
o += geo * scene.eps * side;
|
||
d = wi;
|
||
bounce += 1;
|
||
}
|
||
let (albedo, normal, depth) = first?;
|
||
Some(Sample { radiance: if l.is_finite() { l } else { Vec3::ZERO }, albedo, normal, depth })
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use texturecraft_geom::primitives;
|
||
|
||
fn scene(env: &str) -> TraceScene {
|
||
let mesh = Arc::new(primitives::sphere(1.0, 32, 16));
|
||
let bvh = Arc::new(Bvh::new(&mesh));
|
||
let env = Arc::new(crate::ibl::environment(env, 128));
|
||
TraceScene::new(mesh, bvh, Vec::new(), env, 0.0)
|
||
}
|
||
|
||
fn camera() -> OrbitCamera {
|
||
let mut cam = OrbitCamera::default();
|
||
cam.target = Vec3::ZERO;
|
||
cam.distance = 4.0;
|
||
cam
|
||
}
|
||
|
||
#[test]
|
||
fn renders_the_mesh_over_the_backdrop_and_converges() {
|
||
let s = scene("Studio Soft");
|
||
let mut tr = Tracer::new(48, 32);
|
||
for _ in 0..8 {
|
||
tr.pass(&s, &camera(), &TraceSettings::default());
|
||
}
|
||
assert_eq!(tr.samples, 8);
|
||
let d = TraceDisplay { exposure: 1.0, aces: true, env_opacity: 0.0, denoise: false };
|
||
let img = tr.rgba8(&d);
|
||
assert_eq!(img.len(), 48 * 32 * 4);
|
||
let px = |x: usize, y: usize| &img[(y * 48 + x) * 4..(y * 48 + x) * 4 + 3];
|
||
// The sphere (default material, lit by the studio) is brighter than the dark backdrop corner.
|
||
let center: u32 = px(24, 16).iter().map(|v| *v as u32).sum();
|
||
let corner: u32 = px(0, 0).iter().map(|v| *v as u32).sum();
|
||
assert!(center > corner + 60, "center {center} corner {corner}");
|
||
assert!(tr.acc.iter().all(|p| p.hit.is_finite() && p.env.is_finite()));
|
||
}
|
||
|
||
#[test]
|
||
fn environment_shows_behind_the_mesh_with_opacity() {
|
||
let s = scene("Overcast");
|
||
let mut tr = Tracer::new(16, 8);
|
||
tr.pass(&s, &camera(), &TraceSettings::default());
|
||
let corner = |opacity: f32| tr.rgba8(&TraceDisplay { exposure: 1.0, aces: true, env_opacity: opacity, denoise: false })[0];
|
||
assert!(corner(1.0) > corner(0.0) + 40);
|
||
}
|
||
|
||
#[test]
|
||
fn light_sampling_matches_brdf_sampling_on_average() {
|
||
let lit = scene("Studio Soft");
|
||
let unlit = TraceScene { light: None, ..lit.clone() };
|
||
let mean = |s: &TraceScene| {
|
||
let mut rng = Rng::new(9, 9, 9);
|
||
let n = 40_000;
|
||
let mut sum = Vec3::ZERO;
|
||
for _ in 0..n {
|
||
sum += trace(s, Vec3::new(0.3, 0.4, 4.0), Vec3::new(-0.07, -0.1, -1.0).normalize(), &TraceSettings { bounces: 3 }, &mut rng)
|
||
.map_or(Vec3::ZERO, |s| s.radiance);
|
||
}
|
||
sum / n as f32
|
||
};
|
||
let (a, b) = (mean(&lit), mean(&unlit));
|
||
assert!((a - b).length() < 0.05 * b.length().max(0.05), "with light sampling {a}, without {b}");
|
||
}
|
||
|
||
#[test]
|
||
fn passes_split_into_row_slices_match_whole_passes() {
|
||
let s = scene("Studio Soft");
|
||
let (mut whole, mut sliced) = (Tracer::new(40, 30), Tracer::new(40, 30));
|
||
let d = TraceDisplay { exposure: 1.0, aces: true, env_opacity: 0.0, denoise: false };
|
||
for _ in 0..2 {
|
||
whole.pass(&s, &camera(), &TraceSettings::default());
|
||
let mut done = false;
|
||
while !done {
|
||
done = sliced.pass_rows(&s, &camera(), &TraceSettings::default(), 7);
|
||
}
|
||
}
|
||
assert_eq!(sliced.samples, 2);
|
||
assert_eq!(whole.rgba8(&d), sliced.rgba8(&d));
|
||
}
|
||
|
||
#[test]
|
||
fn denoising_lowers_noise_and_keeps_the_mean() {
|
||
let s = scene("Studio Contrast");
|
||
let mut tr = Tracer::new(64, 48);
|
||
for _ in 0..4 {
|
||
tr.pass(&s, &camera(), &TraceSettings::default());
|
||
}
|
||
let raw = tr.rgba8(&TraceDisplay { exposure: 1.0, aces: true, env_opacity: 0.0, denoise: false });
|
||
let clean = tr.rgba8(&TraceDisplay { exposure: 1.0, aces: true, env_opacity: 0.0, denoise: true });
|
||
// Neighbour differences inside the ball (rows 18..30, columns 26..38) drop; the mean stays.
|
||
let stats = |img: &[u8]| {
|
||
let px = |x: usize, y: usize| img[(y * 64 + x) * 4] as f32;
|
||
let (mut diff, mut sum, mut n) = (0.0, 0.0, 0.0);
|
||
for y in 18..30 {
|
||
for x in 26..38 {
|
||
diff += (px(x, y) - px(x + 1, y)).abs();
|
||
sum += px(x, y);
|
||
n += 1.0;
|
||
}
|
||
}
|
||
(diff / n, sum / n)
|
||
};
|
||
let ((d_raw, m_raw), (d_clean, m_clean)) = (stats(&raw), stats(&clean));
|
||
assert!(d_clean < d_raw * 0.6, "noise {d_raw} -> {d_clean}");
|
||
assert!((m_raw - m_clean).abs() < 0.08 * m_raw.max(1.0), "mean {m_raw} -> {m_clean}");
|
||
}
|
||
|
||
type Values = Vec<(Channel, [f32; 3])>;
|
||
|
||
/// A sphere whose texture set holds the uniform channel `values`.
|
||
fn material_scene(env: Arc<EnvImage>, values: &[(Channel, [f32; 3])]) -> TraceScene {
|
||
let mesh = Arc::new(primitives::sphere(1.0, 32, 16));
|
||
let bvh = Arc::new(Bvh::new(&mesh));
|
||
let chans: Vec<Channel> = values.iter().map(|(c, _)| *c).collect();
|
||
let mut composite = Composite::new(&chans, 64);
|
||
for (c, v) in values {
|
||
let raw: Vec<u16> = v[..c.components()].iter().map(|x| texturecraft_texel::to_u16(*x)).collect();
|
||
let img = composite.channels.get_mut(c).unwrap();
|
||
for y in 0..64 {
|
||
for x in 0..64 {
|
||
img.set(x, y, &raw);
|
||
}
|
||
}
|
||
}
|
||
TraceScene::new(mesh, bvh, vec![TraceSet { material: 0, composite, height_strength: 0.0 }], env, 0.0)
|
||
}
|
||
|
||
/// Mean radiance of parallel rays over the whole disc of the sphere (grazing hits included)
|
||
/// in a uniform white environment.
|
||
fn furnace(values: &[(Channel, [f32; 3])]) -> Vec3 {
|
||
let env = Arc::new(EnvImage { width: 8, height: 4, data: vec![[1.0; 3]; 32] });
|
||
let s = material_scene(env, values);
|
||
let mut rng = Rng::new(4, 5, 6);
|
||
let (mut sum, mut n) = (Vec3::ZERO, 0);
|
||
while n < 6000 {
|
||
let (x, y) = (rng.next() * 2.0 - 1.0, rng.next() * 2.0 - 1.0);
|
||
if x * x + y * y > 0.97 {
|
||
continue;
|
||
}
|
||
sum += trace(&s, Vec3::new(x, y, 4.0), Vec3::NEG_Z, &TraceSettings { bounces: 8 }, &mut rng).map_or(Vec3::ZERO, |s| s.radiance);
|
||
n += 1;
|
||
}
|
||
sum / n as f32
|
||
}
|
||
|
||
const WHITE: [(Channel, [f32; 3]); 3] = [(Channel::BaseColor, [1.0; 3]), (Channel::Metallic, [0.0; 3]), (Channel::Roughness, [0.5; 3])];
|
||
|
||
#[test]
|
||
fn white_furnace_with_each_lobe_at_full_weight_stays_bounded() {
|
||
use Channel::*;
|
||
let lobes: [(&str, Values); 5] = [
|
||
("coat", vec![(CoatWeight, [1.0; 3]), (CoatRoughness, [0.2; 3])]),
|
||
("sheen", vec![(SheenWeight, [1.0; 3]), (SheenColor, [1.0; 3]), (SheenRoughness, [0.5; 3])]),
|
||
("anisotropic metal", vec![(AnisotropyLevel, [1.0; 3]), (AnisotropyAngle, [0.3; 3]), (Metallic, [1.0; 3]), (Roughness, [0.4; 3])]),
|
||
("scattering", vec![(ScatterWeight, [1.0; 3])]),
|
||
("everything", vec![(CoatWeight, [1.0; 3]), (SheenWeight, [1.0; 3]), (AnisotropyLevel, [1.0; 3]), (ScatterWeight, [1.0; 3])]),
|
||
];
|
||
for (name, extra) in lobes {
|
||
// Later values of a channel win (the anisotropic metal's metallic and roughness).
|
||
let mut values: Values = WHITE.into_iter().filter(|(c, _)| !extra.iter().any(|(e, _)| e == c)).collect();
|
||
values.extend(extra);
|
||
let avg = furnace(&values);
|
||
assert!(avg.max_element() <= 1.05 && avg.min_element() > 0.5, "{name}: {avg}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn lobes_sample_and_evaluate_consistently() {
|
||
// Light sampling and BRDF sampling (MIS) against BRDF sampling alone: equal means only
|
||
// when every lobe's density matches what it samples.
|
||
use Channel::*;
|
||
let env = Arc::new(crate::ibl::environment("Studio Soft", 128));
|
||
let lit = material_scene(
|
||
env,
|
||
&[
|
||
(BaseColor, [0.8, 0.5, 0.3]),
|
||
(Roughness, [0.35; 3]),
|
||
(CoatWeight, [0.8; 3]),
|
||
(CoatRoughness, [0.15; 3]),
|
||
(SheenWeight, [0.6; 3]),
|
||
(SheenColor, [0.4, 0.6, 1.0]),
|
||
(AnisotropyLevel, [0.8; 3]),
|
||
(AnisotropyAngle, [0.2; 3]),
|
||
(ScatterWeight, [0.7; 3]),
|
||
],
|
||
);
|
||
let unlit = TraceScene { light: None, ..lit.clone() };
|
||
let mean = |s: &TraceScene| {
|
||
let mut rng = Rng::new(9, 9, 9);
|
||
let n = 100_000;
|
||
let mut sum = Vec3::ZERO;
|
||
for _ in 0..n {
|
||
sum += trace(s, Vec3::new(0.3, 0.4, 4.0), Vec3::new(-0.07, -0.1, -1.0).normalize(), &TraceSettings { bounces: 3 }, &mut rng)
|
||
.map_or(Vec3::ZERO, |s| s.radiance);
|
||
}
|
||
sum / n as f32
|
||
};
|
||
let (a, b) = (mean(&lit), mean(&unlit));
|
||
assert!((a - b).length() < 0.05 * b.length().max(0.05), "with light sampling {a}, without {b}");
|
||
}
|
||
|
||
#[test]
|
||
fn sheen_albedo_fit_matches_the_integral() {
|
||
for r in [0.25f32, 0.5, 0.75, 1.0] {
|
||
let a = r * r;
|
||
for nov in [0.2f32, 0.5, 0.8, 1.0] {
|
||
let v = Vec3::new((1.0 - nov * nov).sqrt(), 0.0, nov);
|
||
let (nt, np) = (128, 256);
|
||
let mut e = 0.0;
|
||
for i in 0..nt {
|
||
let th = (i as f32 + 0.5) / nt as f32 * PI / 2.0;
|
||
for j in 0..np {
|
||
let ph = (j as f32 + 0.5) / np as f32 * TAU;
|
||
let l = Vec3::new(th.sin() * ph.cos(), th.sin() * ph.sin(), th.cos());
|
||
let h = (l + v).normalize();
|
||
e += d_charlie(a, h.z) * sheen_vis(nov, l.z, a) * l.z * th.sin();
|
||
}
|
||
}
|
||
e *= (PI / 2.0 / nt as f32) * (TAU / np as f32);
|
||
let fit = sheen_albedo(nov, r);
|
||
assert!((fit - e).abs() < 0.04, "r {r} cos {nov}: integral {e}, fit {fit}");
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn white_furnace_keeps_energy_bounded() {
|
||
// A uniform white environment: a white diffuse sphere must not exceed the environment.
|
||
let mesh = Arc::new(primitives::sphere(1.0, 24, 12));
|
||
let bvh = Arc::new(Bvh::new(&mesh));
|
||
let env = Arc::new(EnvImage { width: 8, height: 4, data: vec![[1.0; 3]; 32] });
|
||
let s = TraceScene::new(mesh, bvh, Vec::new(), env, 0.0);
|
||
let mut rng = Rng::new(1, 2, 3);
|
||
let mut sum = Vec3::ZERO;
|
||
let n = 4000;
|
||
for _ in 0..n {
|
||
sum += trace(&s, Vec3::new(0.0, 0.0, 4.0), Vec3::NEG_Z, &TraceSettings { bounces: 8 }, &mut rng).map_or(Vec3::ZERO, |s| s.radiance);
|
||
}
|
||
let avg = sum / n as f32;
|
||
assert!(avg.max_element() <= 1.05 && avg.min_element() > 0.3, "{avg}");
|
||
}
|
||
|
||
#[test]
|
||
fn glass_white_furnace_stays_bounded() {
|
||
for rough in [0.0, 0.3, 0.7] {
|
||
let avg = furnace(&[(Channel::BaseColor, [1.0; 3]), (Channel::Roughness, [rough; 3]), (Channel::Transmission, [1.0; 3])]);
|
||
assert!(avg.max_element() <= 1.05 && avg.min_element() > 0.5, "roughness {rough}: {avg}");
|
||
}
|
||
}
|
||
|
||
/// Mean radiance of the center ray from +z at the unit sphere, with an environment that is
|
||
/// bright only behind the sphere (toward -z).
|
||
fn behind_mean(values: &[(Channel, [f32; 3])]) -> Vec3 {
|
||
let (w, h) = (64u32, 32u32);
|
||
let data = (0..w * h)
|
||
.map(|i| if crate::ibl::dir_of(((i % w) as f32 + 0.5) / w as f32, ((i / w) as f32 + 0.5) / h as f32).z < -0.7 { [5.0; 3] } else { [0.01; 3] })
|
||
.collect();
|
||
let s = material_scene(Arc::new(EnvImage { width: w, height: h, data }), values);
|
||
let mut rng = Rng::new(3, 1, 4);
|
||
let n = 2000;
|
||
(0..n).map(|_| trace(&s, Vec3::new(0.0, 0.0, 4.0), Vec3::NEG_Z, &TraceSettings::default(), &mut rng).map_or(Vec3::ZERO, |s| s.radiance)).sum::<Vec3>()
|
||
/ n as f32
|
||
}
|
||
|
||
#[test]
|
||
fn transmission_shows_the_environment_behind_the_mesh() {
|
||
let white = [(Channel::BaseColor, [1.0; 3]), (Channel::Roughness, [0.05; 3])];
|
||
let opaque = behind_mean(&white);
|
||
let glass = behind_mean(&[white[0], white[1], (Channel::Transmission, [1.0; 3])]);
|
||
assert!(glass.x > 2.0 && glass.x > 10.0 * opaque.x, "through the glass {glass}, opaque {opaque}");
|
||
// The base color tints the light going through.
|
||
let tinted = behind_mean(&[(Channel::BaseColor, [1.0, 0.2, 0.2]), white[1], (Channel::Transmission, [1.0; 3])]);
|
||
assert!(tinted.x > 3.0 * tinted.y, "{tinted}");
|
||
}
|
||
|
||
#[test]
|
||
fn thin_lens_blurs_away_from_the_focus_plane() {
|
||
// Pixels between the sphere and the backdrop: how soft the silhouette is.
|
||
let soft_edge = |lens: Option<[f32; 2]>| {
|
||
let s = TraceScene { lens, ..scene("Studio Soft") };
|
||
let mut tr = Tracer::new(64, 48);
|
||
for _ in 0..24 {
|
||
tr.pass(&s, &camera(), &TraceSettings { bounces: 1 });
|
||
}
|
||
tr.acc.iter().filter(|p| p.hits > 2.0 && p.hits < tr.samples as f32 - 2.0).count()
|
||
};
|
||
let (pinhole, focused, blurred) = (soft_edge(None), soft_edge(Some([4.0 - 0.25, 0.1])), soft_edge(Some([20.0, 0.1])));
|
||
assert!(blurred > 3 * pinhole.max(10), "out of focus: {pinhole} -> {blurred} edge pixels");
|
||
assert!(focused < pinhole + pinhole / 2 + 10, "the silhouette (about the focus depth) stays sharp: {pinhole} -> {focused}");
|
||
}
|
||
}
|