use std::cell::{Cell, RefCell};
use std::rc::Rc;
use crate::cameras::{PerspectiveCamera, RenderCamera};
use crate::materials::MeshBasicNodeMaterial;
use crate::math::Matrix4;
use crate::nodes::frame::register_texture_update;
use crate::nodes::node::{SettableValue, TextureSource, Type};
use crate::nodes::tsl::{
all, block, call, float, int, ivec2, length, max, mix, shader_fn, struct_get, texture_load,
texture_load_offset, texture_sample, texture_size, texture_uv, to_var, uniform_settable, uv,
vec2,
};
use crate::nodes::{NodeRef, NodeUpdate, NodeUpdateType};
use crate::objects::QuadMesh;
use crate::renderer::{RenderPipeline, RenderTarget, RenderTargetOptions, Renderer};
use crate::textures::{DepthTexture, Texture, TextureFilter, TextureType};
use super::taa_utils::{
clip_aabb, current_depth_struct, flicker_reduction, halton_offsets, mat4_values,
sample_current_depth, sample_previous_depth, JITTER_COUNT,
};
const DEPTH_THRESHOLD: f64 = 0.0005;
const EDGE_DEPTH_DIFF: f64 = 0.001;
const MAX_VELOCITY_LENGTH: f64 = 128.0;
pub fn traa(
beauty: &Texture,
depth: &DepthTexture,
velocity: &Texture,
camera: Rc<RefCell<PerspectiveCamera>>,
) -> TraaNode {
TraaNode::new(beauty, depth, velocity, camera)
}
pub struct TraaNode(Rc<TraaState>);
pub(crate) struct TraaState {
beauty: Texture,
depth: DepthTexture,
camera: Rc<RefCell<PerspectiveCamera>>,
history: RenderTarget,
resolve: RenderTarget,
quad: RefCell<QuadMesh>,
use_subpixel_correction: Cell<bool>,
velocity: Texture,
uniform_nodes: UniformNodes,
node: NodeRef,
jitter_index: Cell<usize>,
near_far: SettableValue,
world: Cell<Matrix4>,
world_inverse: SettableValue,
projection_inverse: Cell<Matrix4>,
previous_world: SettableValue,
previous_projection_inverse: SettableValue,
}
impl TraaNode {
pub fn new(
beauty: &Texture,
depth: &DepthTexture,
velocity: &Texture,
camera: Rc<RefCell<PerspectiveCamera>>,
) -> Self {
let options = || RenderTargetOptions {
texture_type: TextureType::HalfFloat,
samples: 0,
depth_buffer: false,
min_filter: TextureFilter::Linear,
mag_filter: TextureFilter::Linear,
};
let history = RenderTarget::new_with_options(1, 1, options())
.expect("three-rs: the TRAA history target is a colour type");
history.set_depth_texture(DepthTexture::new());
history.set_copy_destination();
let resolve = RenderTarget::new_with_options(1, 1, options())
.expect("three-rs: the TRAA resolve target is a colour type");
depth.set_copyable();
history
.depth_texture()
.expect("three-rs: set just above")
.set_copyable();
let (near_far, near_far_value) = uniform_settable(Type::Vec2, vec![0.0, 0.0]);
let identity = mat4_values(&Matrix4::identity());
let (world_inverse, world_inverse_value) = uniform_settable(Type::Mat4, identity.clone());
let (previous_world, previous_world_value) = uniform_settable(Type::Mat4, identity.clone());
let (previous_projection_inverse, previous_projection_inverse_value) =
uniform_settable(Type::Mat4, identity);
let uniform_nodes = UniformNodes {
near_far,
world_inverse,
previous_world,
previous_projection_inverse,
};
let material = resolve_material(beauty, depth, velocity, &history, &uniform_nodes, true);
let node = to_var(None, texture_uv(&resolve.texture(), uv()));
let state = Rc::new(TraaState {
beauty: beauty.clone(),
depth: depth.clone(),
camera,
history,
resolve,
quad: RefCell::new(QuadMesh::new(material)),
use_subpixel_correction: Cell::new(true),
velocity: velocity.clone(),
uniform_nodes,
node,
jitter_index: Cell::new(0),
near_far: near_far_value,
world: Cell::new(Matrix4::identity()),
world_inverse: world_inverse_value,
projection_inverse: Cell::new(Matrix4::identity()),
previous_world: previous_world_value,
previous_projection_inverse: previous_projection_inverse_value,
});
register_texture_update(state.resolve.texture().id(), &state);
Self(state)
}
pub fn node(&self) -> NodeRef {
self.0.node.clone()
}
#[doc(hidden)]
pub fn quad_material(&self) -> MeshBasicNodeMaterial {
self.0.quad.borrow().material.clone()
}
pub fn set_use_subpixel_correction(&self, on: bool) {
let state = &self.0;
if state.use_subpixel_correction.replace(on) == on {
return;
}
state.quad.borrow_mut().material = resolve_material(
&state.beauty,
&state.depth,
&state.velocity,
&state.history,
&state.uniform_nodes,
on,
);
}
pub fn attach(&self, pipeline: &mut RenderPipeline) {
if !pipeline.claim_view_offset() {
return;
}
let before = self.0.clone();
pipeline.on_before_render(Box::new(move |renderer: &mut Renderer| {
let (width, height) = renderer.drawing_buffer_size();
before.set_view_offset(renderer, width, height);
}));
let after = self.0.clone();
pipeline.on_after_render(Box::new(move |renderer: &mut Renderer| {
after.clear_view_offset(renderer);
}));
}
}
impl TraaState {
fn set_view_offset(&self, renderer: &mut Renderer, width: u32, height: u32) {
let mut camera = self.camera.borrow_mut();
camera.update_projection_matrix();
renderer.set_velocity_projection_matrix(Some(camera.projection_matrix));
let (jitter_x, jitter_y) = halton_offsets()[self.jitter_index.get()];
let (width, height) = (width as f64, height as f64);
camera.set_view_offset(width, height, jitter_x - 0.5, jitter_y - 0.5, width, height);
}
fn clear_view_offset(&self, renderer: &mut Renderer) {
self.camera.borrow_mut().clear_view_offset();
renderer.set_velocity_projection_matrix(None);
self.jitter_index
.set((self.jitter_index.get() + 1) % JITTER_COUNT);
}
fn set_size(&self, width: u32, height: u32) {
self.history.set_size(width, height);
self.resolve.set_size(width, height);
}
}
impl NodeUpdate for TraaState {
fn update_before_type(&self) -> NodeUpdateType {
NodeUpdateType::Frame
}
fn update_before(&self, renderer: &mut Renderer) -> bool {
if let Some(pass) = crate::nodes::frame::texture_update(self.beauty.id()) {
renderer.update_before_node(&pass);
}
self.previous_world.set(mat4_values(&self.world.get()));
self.previous_projection_inverse
.set(mat4_values(&self.projection_inverse.get()));
{
let camera = self.camera.borrow();
self.near_far.set(vec![camera.near, camera.far]);
self.world.set(RenderCamera::matrix_world(&*camera));
self.world_inverse
.set(mat4_values(&camera.matrix_world_inverse));
self.projection_inverse
.set(camera.projection_matrix_inverse);
}
let (width, height) = self.beauty.size();
let mut renderer = renderer.reset_state();
let needs_restart = self.history.size() != (width, height);
self.set_size(width, height);
if needs_restart {
renderer.init_render_target(&self.history);
renderer.init_render_target(&self.resolve);
renderer.copy_render_texture(&self.beauty, &self.history.texture());
}
renderer.set_render_target(Some(self.resolve.clone()));
renderer.render_quad(&self.quad.borrow());
renderer.set_render_target(None);
renderer.copy_render_texture(&self.resolve.texture(), &self.history.texture());
if self.history.size() == renderer.drawing_buffer_size() {
let history_depth = self
.history
.depth_texture()
.expect("three-rs: the history target carries a DepthTexture");
renderer.copy_depth_texture(&self.depth, &history_depth);
}
drop(renderer);
true
}
}
struct UniformNodes {
near_far: NodeRef,
world_inverse: NodeRef,
previous_world: NodeRef,
previous_projection_inverse: NodeRef,
}
fn resolve_material(
beauty: &Texture,
depth: &DepthTexture,
velocity: &Texture,
history: &RenderTarget,
uniforms: &UniformNodes,
use_subpixel_correction: bool,
) -> MeshBasicNodeMaterial {
let fragment = resolve_node(&ResolveInputs {
beauty,
depth,
velocity,
history: &history.texture(),
previous_depth: &history
.depth_texture()
.expect("three-rs: the history target carries a DepthTexture"),
near_far: uniforms.near_far.clone(),
world_inverse: uniforms.world_inverse.clone(),
previous_world: uniforms.previous_world.clone(),
previous_projection_inverse: uniforms.previous_projection_inverse.clone(),
use_subpixel_correction,
});
let mut material = MeshBasicNodeMaterial::new();
material.name = "TRAA.resolve";
material.color_node = Some(fragment);
material
}
struct ResolveInputs<'a> {
beauty: &'a Texture,
depth: &'a DepthTexture,
velocity: &'a Texture,
history: &'a Texture,
previous_depth: &'a DepthTexture,
near_far: NodeRef,
world_inverse: NodeRef,
previous_world: NodeRef,
previous_projection_inverse: NodeRef,
use_subpixel_correction: bool,
}
fn resolve_node(inputs: &ResolveInputs) -> NodeRef {
let uv_node = uv();
let texture_size = texture_size(TextureSource::Texture2D(inputs.beauty.clone()), int(0));
let position_texel = uv_node.mul(texture_size.clone());
let layout = current_depth_struct();
let current_depth = sample_current_depth(inputs.depth, &position_texel, &layout);
let closest_depth = struct_get(¤t_depth, &layout, "closestDepth");
let closest_position_texel = struct_get(¤t_depth, &layout, "closestPositionTexel");
let farthest_depth = struct_get(¤t_depth, &layout, "farthestDepth");
let offset_uv = texture_load(inputs.velocity, closest_position_texel)
.xy()
.mul(vec2(0.5, -0.5));
let history_uv = uv_node.sub(offset_uv.clone());
let previous_depth = sample_previous_depth(
inputs.previous_depth,
&history_uv,
&inputs.previous_projection_inverse,
&inputs.previous_world,
&inputs.world_inverse,
&inputs.near_far,
);
let is_valid_uv =
all(history_uv.greater_than_equal(0.0)).and(all(history_uv.less_than_equal(1.0)));
let is_edge = farthest_depth
.sub(closest_depth.clone())
.greater_than(EDGE_DEPTH_DIFF);
let is_disocclusion = closest_depth
.sub(previous_depth)
.greater_than(DEPTH_THRESHOLD);
let has_valid_history = is_valid_uv.and(is_edge.or(is_disocclusion.not()));
let current_color = texture_uv(inputs.beauty, uv_node.clone());
let history_color = texture_sample(inputs.history, history_uv.clone());
let motion_factor = length(uv_node.sub(history_uv).mul(texture_size.clone()))
.div(MAX_VELOCITY_LENGTH)
.saturate();
let current_weight = to_var(None, float(0.05));
let mut statements = vec![current_weight.clone()];
if inputs.use_subpixel_correction {
statements.push(
current_weight
.add_assign(call(&subpixel_correction(), vec![offset_uv, texture_size]).mul(0.25)),
);
}
statements.push(current_weight.assign(has_valid_history.select(
current_weight.add(motion_factor.clone()).saturate(),
float(1.0),
)));
let variance_gamma = mix(0.5, 1.0, motion_factor.one_minus().pow2());
let clipped_history_color = variance_clipping(
inputs.beauty,
&position_texel,
¤t_color,
&history_color,
variance_gamma,
);
block(
statements,
call(
&flicker_reduction(),
vec![current_color, clipped_history_color, current_weight],
),
)
}
fn variance_clipping(
beauty: &Texture,
position_texel: &NodeRef,
current_color: &NodeRef,
history_color: &NodeRef,
gamma: NodeRef,
) -> NodeRef {
const OFFSETS: [(i64, i64); 8] = [
(-1, -1),
(-1, 1),
(1, -1),
(1, 1),
(1, 0),
(0, -1),
(0, 1),
(-1, 0),
];
let moment1 = to_var(None, current_color.clone());
let moment2 = to_var(None, current_color.pow2());
let mut statements = vec![moment1.clone(), moment2.clone()];
for (x, y) in OFFSETS {
let neighbor =
texture_load_offset(beauty, position_texel.clone(), ivec2(int(x), int(y))).max(0.0);
statements.push(moment1.add_assign(neighbor.clone()));
statements.push(moment2.add_assign(neighbor.pow2()));
}
let n = float((OFFSETS.len() + 1) as f64);
let mean = moment1.div(n.clone());
let variance = moment2.div(n).sub(mean.pow2()).max(0.0).sqrt().mul(gamma);
let min_color = mean.sub(variance.clone());
let max_color = mean.add(variance);
block(
statements,
call(
&clip_aabb(),
vec![
mean.clamp(min_color.clone(), max_color.clone()),
history_color.clone(),
min_color,
max_color,
],
),
)
}
fn subpixel_correction() -> Rc<crate::nodes::node::FnDef> {
shader_fn(
Some("subpixelCorrection"),
vec![("velocityUV", Type::Vec2), ("textureSize", Type::IVec2)],
Type::F32,
|args| {
let velocity_texel = args[0].mul(args[1].to(Type::Vec2));
let phase = velocity_texel.fract().abs();
let weight = max(phase.clone(), phase.one_minus());
weight.x().mul(weight.y()).one_minus().div(0.75)
},
)
}