use std::rc::Rc;
use crate::materials::MeshBasicNodeMaterial;
use crate::math::Color;
use crate::nodes::node::{FnDef, Lazy, SettableValue, Type};
use crate::nodes::tsl::{
array_var, call, float, int, loop_n, luminance, mix, shader_fn, smoothstep, texture,
texture_sample, texture_uv, to_var, uniform_array_vec3, uniform_settable, uniform_value, uv,
vec4, vec4_join,
};
use crate::nodes::{NodeRef, NodeUpdate, NodeUpdateType};
use crate::objects::QuadMesh;
use crate::renderer::{RenderTarget, RenderTargetOptions, Renderer};
use crate::textures::{TextureFilter, TextureType};
const N_MIPS: usize = 5;
const KERNEL_SIZES: [usize; N_MIPS] = [6, 10, 14, 18, 22];
pub struct HighPassInput {
pub input: NodeRef,
pub threshold: NodeRef,
pub smooth_width: NodeRef,
}
pub fn luminosity_high_pass(args: HighPassInput) -> NodeRef {
let HighPassInput {
input,
threshold,
smooth_width,
} = args;
let v = luminance(input.rgb());
let alpha = smoothstep(threshold.clone(), threshold.add(smooth_width), v);
mix(vec4(0.0, 0.0, 0.0, 0.0), input, alpha)
}
fn lerp_bloom_factor(factor: NodeRef, radius: NodeRef) -> NodeRef {
thread_local! { static CELL: Lazy<Rc<FnDef>> = const { Lazy::new() }; }
let def = CELL.with(|cell| {
cell.get(|| {
shader_fn(
None,
vec![("factor", Type::F32), ("radius", Type::F32)],
Type::F32,
|args| {
let (factor, radius) = (args[0].clone(), args[1].clone());
let mirror_factor = float(1.2).sub(factor.clone());
mix(factor, mirror_factor, radius)
},
)
})
});
call(&def, vec![factor, radius])
}
fn separable_blur_coefficients(kernel_radius: usize) -> (f64, Vec<f64>, Vec<f64>) {
let sigma = kernel_radius as f64 / 3.0;
let coefficients: Vec<f64> = (0..kernel_radius)
.map(|i| {
let i = i as f64;
0.39894 * (-0.5 * i * i / (sigma * sigma)).exp() / sigma
})
.collect();
let centre_weight = coefficients[0];
let mut offsets = Vec::new();
let mut weights = Vec::new();
let mut i = 1;
while i < kernel_radius {
let wa = coefficients[i];
let wb = if i + 1 < kernel_radius {
coefficients[i + 1]
} else {
0.0
};
let w = wa + wb;
offsets.push((i as f64 * wa + (i + 1) as f64 * wb) / w);
weights.push(w);
i += 2;
}
(centre_weight, offsets, weights)
}
fn mip_sizes(width: u32, height: u32, resolution_scale: f64) -> [(u32, u32); N_MIPS] {
let mut resx = (width as f64 * resolution_scale).floor() as u32;
let mut resy = (height as f64 * resolution_scale).floor() as u32;
let mut sizes = [(0, 0); N_MIPS];
for size in sizes.iter_mut() {
*size = (resx, resy);
resx /= 2;
resy /= 2;
}
sizes
}
struct BlurMip {
horizontal: QuadMesh,
vertical: QuadMesh,
inv_size: SettableValue,
}
#[derive(Clone)]
pub struct BloomNode(Rc<BloomState>);
impl std::ops::Deref for BloomNode {
type Target = BloomState;
fn deref(&self) -> &BloomState {
&self.0
}
}
pub struct BloomState {
bright: RenderTarget,
horizontal: [RenderTarget; N_MIPS],
vertical: [RenderTarget; N_MIPS],
high_pass: QuadMesh,
blur: Vec<BlurMip>,
composite: QuadMesh,
node: NodeRef,
pub strength: SettableValue,
pub radius: SettableValue,
pub threshold: SettableValue,
resolution_scale: std::cell::Cell<f64>,
}
pub fn bloom(input: NodeRef) -> BloomNode {
BloomNode::new(input)
}
impl BloomNode {
pub fn new(input: NodeRef) -> Self {
Self::with_high_pass(input, luminosity_high_pass)
}
pub fn with_high_pass(
input: NodeRef,
high_pass: impl FnOnce(HighPassInput) -> NodeRef,
) -> Self {
let bright = Self::target("UnrealBloomPass.bright");
let horizontal = std::array::from_fn(|_| Self::target("UnrealBloomPass.h"));
let vertical: [RenderTarget; N_MIPS] =
std::array::from_fn(|_| Self::target("UnrealBloomPass.v"));
let (strength_node, strength) = uniform_settable(Type::F32, vec![1.0]);
let (radius_node, radius) = uniform_settable(Type::F32, vec![0.0]);
let (threshold_node, threshold) = uniform_settable(Type::F32, vec![0.0]);
let smooth_width = uniform_value(Type::F32, vec![0.01]);
let mut high_pass_material = MeshBasicNodeMaterial::new();
high_pass_material.name = "Bloom_highPass";
high_pass_material.fragment_node = Some(high_pass(HighPassInput {
input,
threshold: threshold_node,
smooth_width,
}));
let mut blur = Vec::with_capacity(N_MIPS);
for (i, &kernel_radius) in KERNEL_SIZES.iter().enumerate() {
let (inv_size_node, inv_size) = uniform_settable(Type::Vec2, vec![1.0, 1.0]);
let input_target = if i == 0 { &bright } else { &vertical[i - 1] };
blur.push(BlurMip {
horizontal: QuadMesh::new(Self::separable_blur_material(
kernel_radius,
&input_target.texture(),
inv_size_node.clone(),
[1.0, 0.0],
)),
vertical: QuadMesh::new(Self::separable_blur_material(
kernel_radius,
&horizontal[i].texture(),
inv_size_node,
[0.0, 1.0],
)),
inv_size,
});
}
let mut composite_material = MeshBasicNodeMaterial::new();
composite_material.name = "Bloom_comp";
composite_material.fragment_node =
Some(Self::composite_node(&vertical, radius_node, strength_node));
let node = to_var(None, texture_uv(&horizontal[0].texture(), uv()));
let bloom = Self(Rc::new(BloomState {
bright,
horizontal,
vertical,
high_pass: QuadMesh::new(high_pass_material),
blur,
composite: QuadMesh::new(composite_material),
node,
strength,
radius,
threshold,
resolution_scale: std::cell::Cell::new(0.5),
}));
crate::nodes::frame::register_texture_update(bloom.horizontal[0].texture().id(), &bloom.0);
bloom
}
fn target(_name: &str) -> RenderTarget {
RenderTarget::new_with_options(
1,
1,
RenderTargetOptions {
texture_type: TextureType::HalfFloat,
samples: 0,
depth_buffer: false,
min_filter: TextureFilter::Linear,
mag_filter: TextureFilter::Linear,
},
)
.expect("three-rs: a bloom render target is a HalfFloat colour type")
}
fn separable_blur_material(
kernel_radius: usize,
color_texture: &crate::textures::Texture,
inv_size: NodeRef,
direction: [f64; 2],
) -> MeshBasicNodeMaterial {
let (centre_weight, offsets, weights) = separable_blur_coefficients(kernel_radius);
let gaussian_offsets = crate::nodes::tsl::const_array(offsets.clone());
let gaussian_weights = crate::nodes::tsl::const_array(weights);
let direction = uniform_value(Type::Vec2, direction.to_vec());
let uv_node = uv();
let diffuse_sum = to_var(
None,
texture_sample(color_texture, uv_node.clone())
.rgb()
.mul(float(centre_weight)),
);
let body = {
let (diffuse_sum, uv_node, direction, inv_size) =
(diffuse_sum.clone(), uv_node.clone(), direction, inv_size);
let color_texture = color_texture.clone();
move |i: &NodeRef| {
let w = gaussian_weights.element_node(i.clone());
let uv_offset = direction
.mul(inv_size)
.mul(gaussian_offsets.element_node(i.clone()));
let sample1 =
texture_sample(&color_texture, uv_node.clone().add(uv_offset.clone())).rgb();
let sample2 = texture_sample(&color_texture, uv_node.sub(uv_offset)).rgb();
vec![diffuse_sum.add_assign(sample1.add(sample2).mul(w))]
}
};
let mut material = MeshBasicNodeMaterial::new();
material.name = "Bloom_separable";
material.fragment_node = Some(crate::nodes::tsl::block(
vec![
diffuse_sum.clone(),
loop_n("i", int(offsets.len() as i64), body),
],
vec4_join(vec![diffuse_sum, float(1.0)]),
));
material
}
fn composite_node(
vertical: &[RenderTarget; N_MIPS],
radius: NodeRef,
strength: NodeRef,
) -> NodeRef {
let bloom_factors = array_var(vec![1.0, 0.8, 0.6, 0.4, 0.2]);
let tints = uniform_array_vec3(&[[1.0, 1.0, 1.0]; N_MIPS]);
let mut sum: Option<NodeRef> = None;
for (i, mip) in vertical.iter().enumerate() {
let color = lerp_bloom_factor(bloom_factors.element(i), radius.clone())
.mul(vec4_join(vec![tints.element(i), float(1.0)]))
.mul(texture(&mip.texture()));
sum = Some(match sum {
Some(previous) => previous.add(color),
None => color,
});
}
sum.expect("three-rs: the bloom composite sums five mips")
.mul(strength)
}
pub fn node(&self) -> NodeRef {
self.node.clone()
}
#[doc(hidden)]
pub fn quad_materials(&self) -> Vec<&MeshBasicNodeMaterial> {
let mut materials = vec![&self.high_pass.material];
for mip in &self.blur {
materials.push(&mip.horizontal.material);
materials.push(&mip.vertical.material);
}
materials.push(&self.composite.material);
materials
}
pub fn set_resolution_scale(&mut self, resolution_scale: f64) {
self.resolution_scale.set(resolution_scale);
}
pub fn resolution_scale(&self) -> f64 {
self.resolution_scale.get()
}
}
impl BloomState {
pub fn set_size(&self, width: u32, height: u32) {
let sizes = mip_sizes(width, height, self.resolution_scale.get());
let (resx, resy) = sizes[0];
self.bright.set_size(resx, resy);
for (i, &(resx, resy)) in sizes.iter().enumerate() {
self.horizontal[i].set_size(resx, resy);
self.vertical[i].set_size(resx, resy);
self.blur[i]
.inv_size
.set(vec![1.0 / resx as f64, 1.0 / resy as f64]);
}
}
fn render_quads(&self, renderer: &mut Renderer) {
let previous_target = renderer.render_target();
let previous_mrt = renderer.mrt();
let previous_auto_clear = renderer.auto_clear;
let previous_clear_color = renderer.clear_color();
let previous_clear_alpha = renderer.clear_alpha();
renderer.set_mrt(None);
renderer.set_clear_color(Color::new(0.0, 0.0, 0.0), 1.0);
renderer.auto_clear = true;
let (width, height) = renderer.drawing_buffer_size();
self.set_size(width, height);
renderer.set_render_target(Some(self.bright.clone()));
renderer.render_quad(&self.high_pass);
for (i, mip) in self.blur.iter().enumerate() {
renderer.set_render_target(Some(self.horizontal[i].clone()));
renderer.render_quad(&mip.horizontal);
renderer.set_render_target(Some(self.vertical[i].clone()));
renderer.render_quad(&mip.vertical);
}
renderer.set_render_target(Some(self.horizontal[0].clone()));
renderer.render_quad(&self.composite);
renderer.set_render_target(previous_target);
renderer.set_mrt(previous_mrt);
renderer.set_clear_color(previous_clear_color, previous_clear_alpha);
renderer.auto_clear = previous_auto_clear;
}
}
impl NodeUpdate for BloomState {
fn update_before_type(&self) -> NodeUpdateType {
NodeUpdateType::Frame
}
fn update_before(&self, renderer: &mut Renderer) -> bool {
self.render_quads(renderer);
true
}
}
#[cfg(test)]
fn kernel_coefficients() -> Vec<(f64, Vec<f64>, Vec<f64>)> {
KERNEL_SIZES
.iter()
.map(|&radius| separable_blur_coefficients(radius))
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_five_gaussian_kernels_match_the_dumped_coefficients() {
let kernels = kernel_coefficients();
assert_eq!(
kernels.iter().map(|(_, o, _)| o.len()).collect::<Vec<_>>(),
vec![3, 5, 7, 9, 11]
);
assert_eq!(kernels[0].0, 0.19947);
assert_eq!(kernels[0].1, vec![1.40733340004593, 3.294214972162989, 5.0]);
assert_eq!(
kernels[0].2,
vec![
0.2970163278514283,
0.09175375661117716,
0.008764100149861079
]
);
assert_eq!(kernels[1].0, 0.119682);
assert_eq!(
kernels[1].1,
vec![
1.4663011645670991,
3.421894767115691,
5.378716404808932,
7.337378162829917,
9.0
]
);
assert_eq!(
kernels[1].2,
vec![
0.21438250006287293,
0.13808060217496526,
0.06253996870210721,
0.019913324055006204,
0.0031262625741366435
]
);
assert_eq!(kernels[2].0, 0.08548714285714286);
assert_eq!(
kernels[2].1,
vec![
1.4827874165827566,
3.45990768708058,
5.437195705962934,
7.4147440341828155,
9.392640964546707,
11.370969190043434,
13.0
]
);
assert_eq!(
kernels[2].2,
vec![
0.16153278215047456,
0.1287340360249976,
0.08555930154584468,
0.04742132242468507,
0.02191797951110977,
0.008447578271836165,
0.001765199910796836
]
);
assert_eq!(kernels[3].0, 0.06649000000000001);
assert_eq!(
kernels[3].1,
vec![
1.4895848401126355,
3.4757135713665743,
5.4618796740944076,
7.448104232731768,
9.434407974610943,
11.4208111469608,
13.407333400045928,
15.39399367783732,
17.0
]
);
assert_eq!(
kernels[3].2,
vec![
0.1284697562799138,
0.11191824897278832,
0.08731326755905255,
0.06100111134675511,
0.0381655709162591,
0.02138356611366251,
0.010729024104628605,
0.004820686863785114,
0.001201009762281257
]
);
assert_eq!(kernels[4].0, 0.0544009090909091);
assert_eq!(
kernels[4].1,
vec![
1.4930273115580075,
3.483735079616612,
5.474454081211128,
7.465190698953718,
9.455951266953607,
11.446742053599085,
13.437569244721434,
15.42843892723576,
17.419357073349026,
19.410329525419996,
21.0
]
);
assert_eq!(
kernels[4].2,
vec![
0.10631235328115614,
0.09691539802869314,
0.08204439964112456,
0.06449885004133733,
0.04708705604762678,
0.03192252271800665,
0.020097333155365302,
0.011749640609175892,
0.006379034087935798,
0.0032160931712181943,
0.0009013823526604976
]
);
}
#[test]
fn the_last_tap_of_each_kernel_is_unpaired() {
for (radius, (_, offsets, _)) in KERNEL_SIZES.iter().zip(kernel_coefficients()) {
assert_eq!(*offsets.last().unwrap(), (radius - 1) as f64);
}
}
#[test]
fn the_mip_chain_is_floor_halved() {
assert_eq!(
mip_sizes(800, 500, 0.5),
[(400, 250), (200, 125), (100, 62), (50, 31), (25, 15)]
);
}
#[test]
fn the_resolution_scale_scales_the_chain() {
assert_eq!(mip_sizes(800, 500, 1.0)[0], (800, 500));
assert_eq!(mip_sizes(800, 500, 0.25)[0], (200, 125));
assert_eq!(mip_sizes(800, 500, 0.3)[0], (240, 150));
}
}