use crate::materials::MeshBasicNodeMaterial;
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)
}
struct Owned {
node: NodeRef,
_owner: RttNode,
}
impl crate::nodes::CustomNode for Owned {
fn type_name(&self) -> &'static str {
"RTTNode"
}
fn node_type(&self) -> crate::nodes::Type {
self.node.ty()
}
fn setup(&self, _builder: &crate::nodes::NodeBuilder) -> NodeRef {
self.node.clone()
}
}
pub(crate) fn owned_by(node: NodeRef, owner: RttNode) -> NodeRef {
crate::nodes::tsl::custom(Owned {
node,
_owner: owner,
})
}
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 mut renderer = renderer.reset_state();
renderer.set_render_target(Some(self.render_target.clone()));
renderer.render_quad(&self.quad);
drop(renderer);
}
}
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);
}
}