use std::rc::Rc;
use crate::materials::MeshBasicNodeMaterial;
use crate::nodes::frame::register_texture_update;
use crate::nodes::node::{Node, Type};
use crate::nodes::tsl::{
block, distance, float, fract, int, loop_options, texture_uv, to_var, uv, vec2, vec3, vec4,
};
use crate::nodes::{NodeRef, NodeUpdate, NodeUpdateType};
use crate::objects::QuadMesh;
use crate::renderer::{RenderTarget, RenderTargetOptions, Renderer};
use crate::textures::{Texture, TextureFilter, TextureType};
#[derive(Clone)]
#[non_exhaustive]
pub struct LensflareParams {
pub ghost_tint: NodeRef,
pub threshold: NodeRef,
pub ghost_samples: NodeRef,
pub ghost_spacing: NodeRef,
pub ghost_attenuation_factor: NodeRef,
pub down_sample_ratio: f64,
}
impl Default for LensflareParams {
fn default() -> Self {
Self {
ghost_tint: vec3(1.0, 1.0, 1.0),
threshold: float(0.5),
ghost_samples: float(4.0),
ghost_spacing: float(0.25),
ghost_attenuation_factor: float(25.0),
down_sample_ratio: 4.0,
}
}
}
pub fn lensflare(map: &Texture, params: LensflareParams) -> LensflareNode {
LensflareNode::new(map, params)
}
pub struct LensflareNode(Rc<LensflareState>);
pub(crate) struct LensflareState {
target: RenderTarget,
quad: QuadMesh,
down_sample_ratio: f64,
node: NodeRef,
}
impl LensflareNode {
pub fn new(map: &Texture, params: LensflareParams) -> Self {
let target = 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 lensflare target is a colour type");
let mut material = MeshBasicNodeMaterial::new();
material.name = "LensflareNode";
material.fragment_node = Some(lensflare_fragment(map, ¶ms));
let node = to_var(None, texture_uv(&target.texture(), uv()));
let state = Rc::new(LensflareState {
target,
quad: QuadMesh::new(material),
down_sample_ratio: params.down_sample_ratio,
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()
}
#[doc(hidden)]
pub fn quad_material(&self) -> &MeshBasicNodeMaterial {
&self.0.quad.material
}
pub fn set_size(&self, width: u32, height: u32) {
self.0.set_size(width, height);
}
}
fn down_sampled(size: u32, ratio: f64) -> u32 {
((size as f64 / ratio).round() as u32).max(1)
}
impl LensflareState {
fn set_size(&self, width: u32, height: u32) {
self.target.set_size(
down_sampled(width, self.down_sample_ratio),
down_sampled(height, self.down_sample_ratio),
);
}
}
impl NodeUpdate for LensflareState {
fn update_before_type(&self) -> NodeUpdateType {
NodeUpdateType::Frame
}
fn update_before(&self, renderer: &mut Renderer) -> bool {
let (width, height) = renderer.drawing_buffer_size();
self.set_size(width, height);
let mut renderer = renderer.reset_state();
renderer.set_render_target(Some(self.target.clone()));
renderer.render_quad(&self.quad);
drop(renderer);
true
}
}
fn lensflare_fragment(map: &Texture, params: &LensflareParams) -> NodeRef {
let tex_coord = to_var(None, uv().one_minus());
let ghost_vec = to_var(
None,
vec2(0.5, 0.5)
.sub(tex_coord.clone())
.mul(params.ghost_spacing.clone()),
);
let result = to_var(None, vec4(0.0, 0.0, 0.0, 1.0));
let end = match params.ghost_samples.node() {
Node::Const { values, .. } => int(values[0] as i64),
_ => params.ghost_samples.to(Type::I32),
};
let ghosts = loop_options("i", Type::I32, int(0), end, "<", |i| {
let sample_uv = to_var(None, fract(tex_coord.add(ghost_vec.mul(i.to(Type::F32)))));
let d = distance(sample_uv.clone(), vec2(0.5, 0.5));
let weight = d.one_minus().pow(params.ghost_attenuation_factor.clone());
let sample = to_var(None, texture_uv(map, sample_uv)).xyz();
let sample = sample
.sub(params.threshold.clone())
.max(vec3(0.0, 0.0, 0.0))
.mul(params.ghost_tint.clone());
vec![result.add_assign(sample.mul(weight))]
});
block(vec![tex_coord, ghost_vec, result.clone(), ghosts], result)
}