use std::cell::{Cell, RefCell};
use std::rc::{Rc, Weak};
use crate::cameras::PerspectiveCamera;
use crate::materials::MeshBasicNodeMaterial;
use crate::math::Color;
use crate::nodes::frame::register_texture_update;
use crate::nodes::node::{LiveValue, SettableValue, Type, UniformGroup, UniformSource};
use crate::nodes::tsl::{
block, depth_aware_blur, discard, dot, float, get_screen_position_from_clip, get_view_position,
if_then, int, interleaved_gradient_noise, loop_options, max, pass_depth_texture_uv, pi2,
screen_coordinate, texture_uv, texture_with_uv, to_var, uniform, uniform_settable, uv,
vec4_join, vogel_disk_sample,
};
use crate::nodes::{NodeRef, NodeUpdate, NodeUpdateType};
use crate::objects::QuadMesh;
use crate::renderer::{RenderTarget, RenderTargetOptions, Renderer};
use crate::textures::{DepthTexture, Texture, TextureFilter, TextureType};
use super::SampleFn;
pub fn ssao(
depth: &DepthTexture,
normal: SampleFn,
camera: &Rc<RefCell<PerspectiveCamera>>,
) -> SsaoNode {
SsaoNode::new(depth, normal, camera)
}
pub struct SsaoNode {
pub radius: SettableValue,
pub intensity: SettableValue,
pub bias: SettableValue,
pub samples: SettableValue,
pub blur_sharpness: SettableValue,
state: Rc<SsaoState>,
}
struct SsaoState {
depth: DepthTexture,
ao_target: RenderTarget,
blur_target: RenderTarget,
ao_quad: QuadMesh,
blur_horizontal_quad: QuadMesh,
blur_vertical_quad: QuadMesh,
blur_direction_horizontal: SettableValue,
blur_direction_vertical: SettableValue,
node: NodeRef,
resolution_scale: Cell<f64>,
blur_enabled: Cell<bool>,
}
struct Uniforms {
radius: NodeRef,
intensity: NodeRef,
bias: NodeRef,
samples: NodeRef,
projection: NodeRef,
projection_inverse: NodeRef,
}
fn red_target() -> RenderTarget {
RenderTarget::new_with_options(
1,
1,
RenderTargetOptions {
texture_type: TextureType::UnsignedByte,
samples: 0,
depth_buffer: false,
min_filter: TextureFilter::Linear,
mag_filter: TextureFilter::Linear,
},
)
.expect("three-rs: the SSAO targets are a colour type")
}
fn camera_matrix(
camera: &Rc<RefCell<PerspectiveCamera>>,
read: fn(&PerspectiveCamera) -> Vec<f64>,
) -> NodeRef {
let camera: Weak<RefCell<PerspectiveCamera>> = Rc::downgrade(camera);
uniform(
UniformSource::Live(LiveValue::new(move || {
let camera = camera
.upgrade()
.expect("three-rs: an SSAONode outlived its camera");
let value = read(&camera.borrow());
value
})),
Type::Mat4,
UniformGroup::Object,
None,
)
}
impl SsaoNode {
pub fn new(
depth: &DepthTexture,
normal: SampleFn,
camera: &Rc<RefCell<PerspectiveCamera>>,
) -> Self {
let ao_target = red_target();
let blur_target = red_target();
let (radius, radius_value) = uniform_settable(Type::F32, vec![0.5]);
let (intensity, intensity_value) = uniform_settable(Type::F32, vec![1.0]);
let (bias, bias_value) = uniform_settable(Type::F32, vec![0.025]);
let (samples, samples_value) = uniform_settable(Type::F32, vec![16.0]);
let (blur_sharpness, blur_sharpness_value) = uniform_settable(Type::F32, vec![2.0]);
let (direction_h, direction_h_value) = uniform_settable(Type::Vec2, vec![0.0, 0.0]);
let (direction_v, direction_v_value) = uniform_settable(Type::Vec2, vec![0.0, 0.0]);
let uniforms = Uniforms {
radius: radius.clone(),
intensity,
bias,
samples,
projection: camera_matrix(camera, |c| c.projection_matrix.elements.to_vec()),
projection_inverse: camera_matrix(camera, |c| {
c.projection_matrix_inverse.elements.to_vec()
}),
};
let mut ao_material = MeshBasicNodeMaterial::new();
ao_material.name = "SSAO.AO";
ao_material.fragment_node = Some(ao_node(depth, &normal, &uniforms));
let blur_material = |input: &Texture, direction: NodeRef| {
let mut material = MeshBasicNodeMaterial::new();
material.name = "SSAO.Blur";
let input = input.clone();
material.fragment_node = Some(depth_aware_blur(
move |coord| texture_with_uv(&input, coord),
depth,
direction,
camera,
blur_sharpness.clone(),
radius.clone(),
));
material
};
let blur_horizontal = blur_material(&ao_target.texture(), direction_h);
let blur_vertical = blur_material(&blur_target.texture(), direction_v);
let node = to_var(None, texture_uv(&ao_target.texture(), uv()));
let state = Rc::new(SsaoState {
depth: depth.clone(),
ao_target,
blur_target,
ao_quad: QuadMesh::new(ao_material),
blur_horizontal_quad: QuadMesh::new(blur_horizontal),
blur_vertical_quad: QuadMesh::new(blur_vertical),
blur_direction_horizontal: direction_h_value,
blur_direction_vertical: direction_v_value,
node,
resolution_scale: Cell::new(0.5),
blur_enabled: Cell::new(true),
});
register_texture_update(state.ao_target.texture().id(), &state);
Self {
radius: radius_value,
intensity: intensity_value,
bias: bias_value,
samples: samples_value,
blur_sharpness: blur_sharpness_value,
state,
}
}
pub fn node(&self) -> NodeRef {
self.state.node.clone()
}
pub fn sample(&self, coord: NodeRef) -> NodeRef {
texture_uv(&self.state.ao_target.texture(), coord)
}
pub fn texture(&self) -> Texture {
self.state.ao_target.texture()
}
pub fn set_resolution_scale(&self, scale: f64) {
self.state.resolution_scale.set(scale);
}
pub fn set_blur_enabled(&self, on: bool) {
self.state.blur_enabled.set(on);
}
#[doc(hidden)]
pub fn quad_material(&self) -> MeshBasicNodeMaterial {
self.state.ao_quad.material.clone()
}
#[doc(hidden)]
pub fn blur_quad_material(&self) -> MeshBasicNodeMaterial {
self.state.blur_horizontal_quad.material.clone()
}
}
#[inline(never)]
fn ao_node(depth: &DepthTexture, normal: &SampleFn, u: &Uniforms) -> NodeRef {
let uv_node = uv();
let sample_depth = |coord: NodeRef| pass_depth_texture_uv(depth, coord);
let depth_value = to_var(None, sample_depth(uv_node.clone()));
let discard_far = if_then(depth_value.greater_than_equal(1.0), vec![discard()]);
let view_position = to_var(
None,
get_view_position(
uv_node.clone(),
depth_value.clone(),
u.projection_inverse.clone(),
),
);
let view_normal = to_var(None, normal(uv_node).rgb().normalize());
let phi = to_var(
None,
interleaved_gradient_noise(screen_coordinate()).mul(pi2()),
);
let samples = u.samples.clone();
let clip_position = to_var(
None,
u.projection
.mul(vec4_join(vec![view_position.clone(), float(1.0)])),
);
let occlusion = to_var(None, float(0.0));
let taps = loop_options("i", Type::I32, int(0), samples.clone(), "<", |i| {
let offset =
vogel_disk_sample(i.clone(), samples.clone(), phi.clone()).mul(u.radius.clone());
let clip_offset = u
.projection
.mul(vec4_join(vec![offset, float(0.0), float(0.0)]));
let sample_uv = get_screen_position_from_clip(clip_position.add(clip_offset));
let sample_view_position = get_view_position(
sample_uv.clone(),
sample_depth(sample_uv),
u.projection_inverse.clone(),
);
let v = to_var(None, sample_view_position.sub(view_position.clone()));
let dist = to_var(None, v.length());
let cos_angle = dot(v.clone(), view_normal.clone()).div(max(dist.clone(), float(0.0001)));
let falloff = u.radius.div(u.radius.add(dist.clone()));
vec![
v,
dist,
occlusion.add_assign(max(cos_angle.sub(u.bias.clone()), 0.0).mul(falloff)),
]
});
block(
vec![
depth_value,
discard_far,
view_position,
view_normal,
phi,
clip_position,
occlusion.clone(),
taps,
],
occlusion
.div(samples)
.mul(u.intensity.clone())
.one_minus()
.clamp(0.0, 1.0),
)
}
impl NodeUpdate for SsaoState {
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.depth.id()) {
let outer_ao = renderer.context_ao.take();
renderer.update_before_node(&pass);
renderer.context_ao = outer_ao;
}
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.auto_clear = true;
let (width, height) = renderer.drawing_buffer_size();
let scale = self.resolution_scale.get();
let width = ((scale * f64::from(width)).round() as u32).max(1);
let height = ((scale * f64::from(height)).round() as u32).max(1);
for target in [&self.ao_target, &self.blur_target] {
if target.size() != (width, height) {
target.set_size(width, height);
}
}
renderer.set_clear_color(Color::new(1.0, 1.0, 1.0), 1.0);
renderer.set_render_target(Some(self.ao_target.clone()));
renderer.render_quad(&self.ao_quad);
if self.blur_enabled.get() {
self.blur_direction_horizontal
.set(vec![1.0 / f64::from(width), 0.0]);
renderer.set_render_target(Some(self.blur_target.clone()));
renderer.render_quad(&self.blur_horizontal_quad);
self.blur_direction_vertical
.set(vec![0.0, 1.0 / f64::from(height)]);
renderer.set_render_target(Some(self.ao_target.clone()));
renderer.render_quad(&self.blur_vertical_quad);
}
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;
true
}
}