use crate::materials::MeshBasicNodeMaterial;
use crate::math::Color;
use crate::nodes::tsl::{texture_uv, uv};
use std::cell::Cell;
use std::rc::Rc;
use crate::nodes::{NodeRef, NodeUpdate, NodeUpdateType};
use crate::objects::QuadMesh;
use crate::renderer::{RenderTarget, RenderTargetOptions, Renderer};
use crate::textures::{Texture, TextureFilter, TextureType, Wrapping};
#[derive(Clone)]
pub struct RttNode(Rc<RttState>);
impl std::ops::Deref for RttNode {
type Target = RttState;
fn deref(&self) -> &RttState {
&self.0
}
}
pub struct RttState {
render_target: RenderTarget,
quad: QuadMesh,
size: Cell<Option<(u32, u32)>>,
resolution_scale: Cell<f64>,
}
pub fn rtt(node: NodeRef) -> RttNode {
RttNode::new(node)
}
pub fn convert_to_texture(node: NodeRef) -> RttNode {
rtt(node)
}
impl RttNode {
pub fn new(node: NodeRef) -> Self {
let render_target = RenderTarget::new_with_options(
1,
1,
RenderTargetOptions {
texture_type: TextureType::HalfFloat,
samples: 0,
depth_buffer: true,
min_filter: TextureFilter::Linear,
mag_filter: TextureFilter::Linear,
},
)
.expect("three-rs: an rtt() render target is a HalfFloat colour type");
let mut material = MeshBasicNodeMaterial::new();
material.name = "RTT";
material.fragment_node = Some(node);
let node = Self(Rc::new(RttState {
render_target,
quad: QuadMesh::new(material),
size: Cell::new(None),
resolution_scale: Cell::new(1.0),
}));
crate::nodes::frame::register_texture_update(node.render_target.texture().id(), &node.0);
node
}
pub fn with_size(node: NodeRef, width: u32, height: u32) -> Self {
let node = Self::new(node);
node.size.set(Some((width, height)));
node.set_size(width, height);
node
}
pub fn set_wrapping(&self, wrap_s: Wrapping, wrap_t: Wrapping) {
self.render_target.texture().set_wrapping(wrap_s, wrap_t);
}
pub fn set_resolution_scale(&mut self, resolution_scale: f64) {
self.resolution_scale.set(resolution_scale);
if let Some((width, height)) = self.size.get() {
self.set_size(width, height);
}
}
pub fn resolution_scale(&self) -> f64 {
self.resolution_scale.get()
}
pub fn set_size(&self, width: u32, height: u32) {
self.0.set_size(width, height);
}
pub fn texture(&self) -> Texture {
self.render_target.texture()
}
pub fn node(&self) -> NodeRef {
texture_uv(&self.render_target.texture(), uv())
}
pub fn sample(&self, coord: NodeRef) -> NodeRef {
texture_uv(&self.render_target.texture(), coord)
}
#[doc(hidden)]
pub fn quad_material(&self) -> &MeshBasicNodeMaterial {
&self.quad.material
}
pub fn auto_resize(&self) -> bool {
self.size.get().is_none()
}
}
impl RttState {
fn set_size(&self, width: u32, height: u32) {
self.render_target.set_size(
(width as f64 * self.resolution_scale.get()).floor() as u32,
(height as f64 * self.resolution_scale.get()).floor() as u32,
);
}
fn render_quad(&self, renderer: &mut Renderer) {
if self.size.get().is_none() {
let (width, height) = renderer.drawing_buffer_size();
self.set_size(width, height);
}
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;
renderer.set_render_target(Some(self.render_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;
}
}
impl NodeUpdate for RttState {
fn update_before_type(&self) -> NodeUpdateType {
NodeUpdateType::Frame
}
fn update_before(&self, renderer: &mut Renderer) -> bool {
self.render_quad(renderer);
true
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::nodes::tsl::vec4;
#[test]
fn the_target_size_is_floored_and_scaled() {
let node = RttNode::new(vec4(0.0, 0.0, 0.0, 0.0));
assert!(node.auto_resize());
node.set_size(800, 500);
assert_eq!(node.texture().size(), (800, 500));
let mut node = RttNode::with_size(vec4(0.0, 0.0, 0.0, 0.0), 800, 500);
assert!(!node.auto_resize());
node.set_resolution_scale(0.3);
assert_eq!(node.texture().size(), (240, 150));
}
#[test]
fn the_wrapping_reaches_the_texture() {
let node = RttNode::new(vec4(0.0, 0.0, 0.0, 0.0));
node.set_wrapping(Wrapping::MirroredRepeat, Wrapping::MirroredRepeat);
let texture = node.texture();
let inner = texture.borrow();
assert_eq!(inner.wrap_s, Wrapping::MirroredRepeat);
assert_eq!(inner.wrap_t, Wrapping::MirroredRepeat);
}
}