use crate::materials::MeshBasicNodeMaterial;
use crate::math::Color;
use crate::nodes::tsl::{block, float, max, sign, texture_uv, to_const, to_var, uv};
use crate::nodes::NodeRef;
use crate::objects::QuadMesh;
use crate::renderer::{RenderTarget, RenderTargetOptions, Renderer, OUTPUT_ATTACHMENT};
use crate::textures::{Texture, TextureFilter, TextureType};
pub struct AfterImageNode {
target: RenderTarget,
quad: QuadMesh,
node: NodeRef,
}
pub fn after_image(map: &Texture, damp: NodeRef) -> AfterImageNode {
AfterImageNode::new(map, damp)
}
impl AfterImageNode {
pub fn new(map: &Texture, damp: NodeRef) -> Self {
let texture_type = match map.format() {
wgpu::TextureFormat::Rgba16Float => TextureType::HalfFloat,
_ => TextureType::UnsignedByte,
};
let target = RenderTarget::new_with_options(
1,
1,
RenderTargetOptions {
texture_type,
samples: 0,
depth_buffer: false,
min_filter: TextureFilter::Linear,
mag_filter: TextureFilter::Linear,
},
)
.expect("three-rs: an after-image target is a colour type");
let old = target.add_previous_texture(OUTPUT_ATTACHMENT);
let texel_old = to_var(None, texture_uv(&old, uv()));
let texel_new = to_var(None, texture_uv(map, uv()));
let threshold = to_const(None, float(0.1));
let m = max(sign(texel_old.clone().sub(threshold)), 0.0);
let fragment = block(
vec![
texel_old.clone(),
texel_new.clone(),
texel_old.mul_assign(damp.mul(m)),
],
max(texel_new, texel_old),
);
let mut material = MeshBasicNodeMaterial::new();
material.name = "AfterImage";
material.fragment_node = Some(fragment);
let node = to_var(None, texture_uv(&target.texture(), uv()));
Self {
target,
quad: QuadMesh::new(material),
node,
}
}
pub fn node(&self) -> NodeRef {
self.node.clone()
}
#[doc(hidden)]
pub fn quad_material(&self) -> &MeshBasicNodeMaterial {
&self.quad.material
}
pub fn render(&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.target.set_size(width, height);
self.target.toggle_texture(OUTPUT_ATTACHMENT);
renderer.set_render_target(Some(self.target.clone()));
renderer.render_quad(&self.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;
}
}