use crate::cameras::PerspectiveCamera;
use crate::materials::{Blending, MeshBasicNodeMaterial};
use crate::math::Color;
use crate::nodes::node::{SettableValue, Type};
use crate::nodes::tsl::{texture, uniform_settable, unpremultiply_alpha};
use crate::nodes::NodeRef;
use crate::objects::{QuadMesh, Scene};
use super::pass::PassNode;
use super::render_target::RenderTarget;
use super::Renderer;
const JITTER_VECTORS: [&[[f64; 2]]; 6] = [
&[[0.0, 0.0]],
&[[4.0, 4.0], [-4.0, -4.0]],
&[[-2.0, -6.0], [6.0, -2.0], [-6.0, 2.0], [2.0, 6.0]],
&[
[1.0, -3.0],
[-1.0, 3.0],
[5.0, 1.0],
[-3.0, -5.0],
[-5.0, 5.0],
[-7.0, -1.0],
[3.0, 7.0],
[7.0, -7.0],
],
&[
[1.0, 1.0],
[-1.0, -3.0],
[-3.0, 2.0],
[4.0, -1.0],
[-5.0, -2.0],
[2.0, 5.0],
[5.0, 3.0],
[3.0, -5.0],
[-2.0, 6.0],
[0.0, -7.0],
[-4.0, -6.0],
[-6.0, 4.0],
[-8.0, 0.0],
[7.0, -4.0],
[6.0, 7.0],
[-7.0, -8.0],
],
&[
[-4.0, -7.0],
[-7.0, -5.0],
[-3.0, -5.0],
[-5.0, -4.0],
[-1.0, -4.0],
[-2.0, -2.0],
[-6.0, -1.0],
[-4.0, 0.0],
[-7.0, 1.0],
[-1.0, 2.0],
[-6.0, 3.0],
[-3.0, 3.0],
[-7.0, 6.0],
[-3.0, 6.0],
[-5.0, 7.0],
[-1.0, 7.0],
[5.0, -7.0],
[1.0, -6.0],
[6.0, -5.0],
[4.0, -4.0],
[2.0, -3.0],
[7.0, -2.0],
[1.0, -1.0],
[4.0, -1.0],
[2.0, 1.0],
[6.0, 2.0],
[0.0, 4.0],
[4.0, 4.0],
[2.0, 5.0],
[7.0, 5.0],
[5.0, 6.0],
[3.0, 7.0],
],
];
const JITTER_SCALE: f64 = 0.0625;
const ROUNDING_RANGE: f64 = 1.0 / 32.0;
pub(crate) fn jitter_vectors(sample_level: usize) -> &'static [[f64; 2]] {
JITTER_VECTORS[sample_level.min(5)]
}
pub(crate) fn sample_weight(i: usize, count: usize, unbiased: bool) -> f64 {
let base = 1.0 / count as f64;
if unbiased {
base + ROUNDING_RANGE * (-0.5 + (i as f64 + 0.5) / count as f64)
} else {
base
}
}
pub struct SsaaPassNode {
pass: PassNode,
sample_render_target: RenderTarget,
quad: QuadMesh,
sample_weight: SettableValue,
pub sample_level: usize,
pub unbiased: bool,
}
impl Default for SsaaPassNode {
fn default() -> Self {
Self::new()
}
}
impl SsaaPassNode {
pub fn new() -> Self {
let pass = PassNode::new();
pass.render_target().set_samples(0);
let sample_render_target = pass.render_target().clone_target();
let (sample_weight_node, sample_weight) = uniform_settable(Type::F32, vec![1.0]);
let mut material = MeshBasicNodeMaterial::new();
material.name = "SSAA";
material.fragment_node = Some(unpremultiply_alpha(
texture(&sample_render_target.texture()).mul(sample_weight_node),
));
material.transparent = true;
material.depth_test = false;
material.depth_write = false;
material.premultiplied_alpha = true;
material.blending = Blending::Additive;
Self {
pass,
sample_render_target,
quad: QuadMesh::new(material),
sample_weight,
sample_level: 4,
unbiased: true,
}
}
pub fn node(&self) -> NodeRef {
self.pass.node()
}
pub fn texture(&self) -> crate::textures::Texture {
self.pass.texture()
}
pub fn render(
&self,
renderer: &mut Renderer,
scene: &mut Scene,
camera: &mut PerspectiveCamera,
) {
let (width, height) = renderer.drawing_buffer_size();
self.pass.render_target().set_size(width, height);
self.sample_render_target.set_size(width, height);
let mut renderer = renderer.save_state();
let previous_clear_color = renderer.clear_color();
let previous_clear_alpha = renderer.clear_alpha();
renderer.set_mrt(self.pass.mrt());
renderer.auto_clear = false;
let jitter = jitter_vectors(self.sample_level);
let count = jitter.len();
let original = camera.view.filter(|view| view.enabled);
let (full_width, full_height, offset_x, offset_y, view_width, view_height) = match original
{
Some(view) => (
view.full_width,
view.full_height,
view.offset_x,
view.offset_y,
view.width,
view.height,
),
None => (
width as f64,
height as f64,
0.0,
0.0,
width as f64,
height as f64,
),
};
for (i, offset) in jitter.iter().enumerate() {
camera.set_view_offset(
full_width,
full_height,
offset_x + offset[0] * JITTER_SCALE,
offset_y + offset[1] * JITTER_SCALE,
view_width,
view_height,
);
self.sample_weight
.set(vec![sample_weight(i, count, self.unbiased)]);
renderer.set_render_target(Some(self.sample_render_target.clone()));
renderer.clear(true, true);
renderer.render(scene, camera);
renderer.set_render_target(Some(self.pass.render_target().clone()));
if i == 0 {
renderer.set_clear_color(Color::new(0.0, 0.0, 0.0), 0.0);
renderer.clear(true, true);
renderer.set_clear_color(previous_clear_color, previous_clear_alpha);
}
renderer.render_quad(&self.quad);
}
camera.set_view_offset(
full_width,
full_height,
offset_x,
offset_y,
view_width,
view_height,
);
if original.is_none() {
camera.clear_view_offset();
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_eight_unbiased_sample_weights() {
let weights: Vec<f64> = (0..8).map(|i| sample_weight(i, 8, true)).collect();
assert_eq!(
weights,
vec![
0.111328125,
0.115234375,
0.119140625,
0.123046875,
0.126953125,
0.130859375,
0.134765625,
0.138671875,
]
);
assert_eq!(weights.iter().sum::<f64>(), 1.0);
}
#[test]
fn the_biased_weights_are_flat() {
for i in 0..8 {
assert_eq!(sample_weight(i, 8, false), 0.125);
}
}
#[test]
fn the_jitter_tables_are_powers_of_two() {
for level in 0..=5 {
assert_eq!(jitter_vectors(level).len(), 1 << level);
}
assert_eq!(jitter_vectors(9).len(), 32);
assert_eq!(
jitter_vectors(3),
&[
[1.0, -3.0],
[-1.0, 3.0],
[5.0, 1.0],
[-3.0, -5.0],
[-5.0, 5.0],
[-7.0, -1.0],
[3.0, 7.0],
[7.0, -7.0],
]
);
}
}