use std::rc::Rc;
use crate::materials::MeshBasicNodeMaterial;
use crate::nodes::frame::register_texture_update;
use crate::nodes::node::{TextureSource, Type};
use crate::nodes::tsl::{
abs, block, boolean, exp2, float, floor, int, ivec2, max, texture_load, texture_size,
texture_uv, to_const, to_var, uv, vec3, vec4_join,
};
use crate::nodes::{NodeRef, NodeUpdate, NodeUpdateType};
use crate::objects::QuadMesh;
use crate::renderer::{RenderTarget, RenderTargetOptions, Renderer};
use crate::textures::{Texture, TextureFilter, TextureType};
use super::rtt::{convert_to_texture, RttNode};
pub fn sharpen(node: NodeRef, sharpness: impl Into<NodeRef>, denoise: bool) -> SharpenNode {
let input = convert_to_texture(node);
SharpenNode::build(&input.texture(), sharpness.into(), denoise, Some(input))
}
pub struct SharpenNode(Rc<SharpenState>);
pub(crate) struct SharpenState {
_input: Option<RttNode>,
target: RenderTarget,
quad: QuadMesh,
node: NodeRef,
}
impl SharpenNode {
pub fn new(map: &Texture, sharpness: NodeRef, denoise: bool) -> Self {
Self::build(map, sharpness, denoise, None)
}
fn build(map: &Texture, sharpness: NodeRef, denoise: bool, input: Option<RttNode>) -> Self {
let target = 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: the sharpen target is a HalfFloat colour type");
let mut material = MeshBasicNodeMaterial::new();
material.name = "Sharpen_RCAS";
material.fragment_node = Some(rcas(map, sharpness, denoise, false));
let node = to_var(None, texture_uv(&target.texture(), uv()));
let state = Rc::new(SharpenState {
_input: input,
target,
quad: QuadMesh::new(material),
node,
});
register_texture_update(state.target.texture().id(), &state);
Self(state)
}
pub fn node(&self) -> NodeRef {
self.0.node.clone()
}
pub fn texture(&self) -> Texture {
self.0.target.texture()
}
pub fn set_size(&self, width: u32, height: u32) {
self.0.target.set_size(width, height);
}
#[doc(hidden)]
pub fn quad_material(&self) -> &MeshBasicNodeMaterial {
&self.0.quad.material
}
}
impl NodeUpdate for SharpenState {
fn update_before_type(&self) -> NodeUpdateType {
NodeUpdateType::Frame
}
fn update_before(&self, renderer: &mut Renderer) -> bool {
let mut renderer = renderer.reset_state();
let (width, height) = renderer.drawing_buffer_size();
self.target.set_size(width, height);
renderer.set_render_target(Some(self.target.clone()));
renderer.render_quad(&self.quad);
drop(renderer);
true
}
}
fn luma(s: &NodeRef) -> NodeRef {
s.y().add(s.z().add(s.x()).mul(0.5))
}
#[inline(never)]
pub(super) fn rcas(map: &Texture, sharpness: NodeRef, denoise: bool, vec2_size: bool) -> NodeRef {
let target_uv = uv();
let tex_size = || texture_size(TextureSource::Texture2D(map.clone()), int(0));
let mut statements = Vec::new();
let (size_x, size_y) = if vec2_size {
let size = to_const(None, tex_size().to(Type::Vec2));
statements.push(size.clone());
(size.x(), size.y())
} else {
(tex_size().x(), tex_size().y())
};
let p = to_const(
None,
ivec2(
floor(target_uv.x().mul(size_x)).to(Type::I32),
floor(target_uv.y().mul(size_y)).to(Type::I32),
),
);
let e = texture_load(map, p.clone());
let b = texture_load(map, p.add(ivec2(int(0), int(-1))));
let d = texture_load(map, p.add(ivec2(int(-1), int(0))));
let f = texture_load(map, p.add(ivec2(int(1), int(0))));
let h = texture_load(map, p.add(ivec2(int(0), int(1))));
let b_l = luma(&b);
let d_l = luma(&d);
let e_l = luma(&e);
let f_l = luma(&f);
let h_l = luma(&h);
let con = to_const(None, exp2(sharpness.negate()));
let mn4 = to_const(None, b.rgb().min(d.rgb()).min(f.rgb().min(h.rgb())));
let mx4 = to_const(None, max(max(b.rgb(), d.rgb()), max(f.rgb(), h.rgb())));
let rcas_limit = to_const(None, float(0.25 - 1.0 / 16.0));
let hit_min = to_const(None, mn4.min(e.rgb()).div(mx4.mul(4.0)));
let hit_max = to_const(
None,
vec3(1.0, 1.0, 1.0)
.sub(max(mx4.clone(), e.rgb()))
.div(mn4.mul(4.0).sub(4.0)),
);
let lobe_rgb = to_const(None, max(hit_min.negate(), hit_max.clone()));
let lobe = to_const(
None,
max(
rcas_limit.negate(),
max(lobe_rgb.x(), max(lobe_rgb.y(), lobe_rgb.z())).min(float(0.0)),
)
.mul(con.clone()),
);
let nz = to_const(
None,
b_l.add(d_l.clone())
.add(f_l.clone())
.add(h_l.clone())
.mul(0.25)
.sub(e_l.clone()),
);
let nz_range = to_const(
None,
max(
max(b_l.clone(), d_l.clone()),
max(e_l.clone(), max(f_l.clone(), h_l.clone())),
)
.sub(b_l.min(d_l).min(e_l.min(f_l.min(h_l)))),
);
let nz_factor = to_const(
None,
float(1.0).sub(
abs(nz.clone())
.div(max(nz_range.clone(), float(1.0 / 65536.0)))
.saturate()
.mul(0.5),
),
);
let effective_lobe = to_const(
None,
boolean(denoise)
.equal(true)
.select(lobe.mul(nz_factor.clone()), lobe.clone()),
);
let result = to_const(
None,
b.rgb()
.add(d.rgb())
.add(f.rgb())
.add(h.rgb())
.mul(effective_lobe.clone())
.add(e.rgb())
.div(effective_lobe.mul(4.0).add(1.0)),
);
statements.extend([
p,
con,
mn4,
mx4,
rcas_limit,
hit_min,
hit_max,
lobe_rgb,
lobe,
nz,
nz_range,
nz_factor,
effective_lobe,
result.clone(),
]);
block(statements, vec4_join(vec![result, e.a()]))
}