use std::cell::RefCell;
use crate::nodes::node::{CustomNode, SampleMode, TextureSource, Type};
use crate::nodes::tsl::{custom, linear_depth, linear_depth_of, screen_uv, texture_node};
use crate::nodes::{NodeBuilder, NodeRef, NodeUpdateType};
use crate::renderer::Renderer;
use crate::textures::{DepthTexture, MinFilter, Texture, TextureFilter};
thread_local! {
static SHARED_FRAMEBUFFER: RefCell<Option<Texture>> = const { RefCell::new(None) };
static SHARED_DEPTHBUFFER: RefCell<Option<DepthTexture>> = const { RefCell::new(None) };
}
fn framebuffer_texture() -> Texture {
let texture = Texture::render_target(1, 1, wgpu::TextureFormat::Rgba8Unorm);
texture.set_min_filter(MinFilter::Nearest);
texture.set_mag_filter(TextureFilter::Nearest);
texture
}
enum Framebuffer {
Color(Texture),
Depth(DepthTexture),
}
struct ViewportTextureNode {
name: &'static str,
framebuffer: Framebuffer,
uv: NodeRef,
}
impl CustomNode for ViewportTextureNode {
fn type_name(&self) -> &'static str {
self.name
}
fn node_type(&self) -> Type {
match self.framebuffer {
Framebuffer::Color(_) => Type::Vec4,
Framebuffer::Depth(_) => Type::F32,
}
}
fn setup(&self, _builder: &NodeBuilder) -> NodeRef {
match &self.framebuffer {
Framebuffer::Color(texture) => {
let mode = if texture.is_unfilterable() {
SampleMode::Load
} else {
SampleMode::Sample
};
texture_node(
TextureSource::Texture2D(texture.clone()),
self.uv.clone(),
mode,
Type::Vec4,
)
}
Framebuffer::Depth(depth) => texture_node(
TextureSource::Depth(depth.clone()),
self.uv.clone(),
SampleMode::Load,
Type::F32,
),
}
}
fn update_before_type(&self) -> NodeUpdateType {
NodeUpdateType::Render
}
fn update_before(&self, renderer: &mut Renderer) -> bool {
match &self.framebuffer {
Framebuffer::Color(texture) => renderer.copy_framebuffer_to_texture(texture),
Framebuffer::Depth(depth) => renderer.copy_framebuffer_to_depth_texture(depth),
}
true
}
}
pub fn viewport_shared_texture() -> NodeRef {
viewport_shared_texture_at(screen_uv())
}
pub fn viewport_shared_texture_at(uv: impl Into<NodeRef>) -> NodeRef {
let texture = SHARED_FRAMEBUFFER.with(|shared| {
shared
.borrow_mut()
.get_or_insert_with(framebuffer_texture)
.clone()
});
custom(ViewportTextureNode {
name: "ViewportSharedTextureNode",
framebuffer: Framebuffer::Color(texture),
uv: uv.into(),
})
}
pub fn viewport_texture() -> NodeRef {
viewport_texture_at(screen_uv())
}
pub fn viewport_texture_at(uv: impl Into<NodeRef>) -> NodeRef {
let texture = framebuffer_texture();
texture.set_min_filter(MinFilter::LinearMipmapLinear);
custom(ViewportTextureNode {
name: "ViewportTextureNode",
framebuffer: Framebuffer::Color(texture),
uv: uv.into(),
})
}
pub fn viewport_depth_texture() -> NodeRef {
viewport_depth_texture_at(screen_uv())
}
pub fn viewport_depth_texture_at(uv: impl Into<NodeRef>) -> NodeRef {
custom(ViewportTextureNode {
name: "ViewportDepthTextureNode",
framebuffer: Framebuffer::Depth(SHARED_DEPTHBUFFER.with(|shared| {
shared
.borrow_mut()
.get_or_insert_with(DepthTexture::new)
.clone()
})),
uv: uv.into(),
})
}
pub fn viewport_linear_depth() -> NodeRef {
linear_depth_of(viewport_depth_texture())
}
pub fn viewport_safe_uv(uv: impl Into<NodeRef>) -> NodeRef {
let uv = uv.into();
let depth = linear_depth();
let depth_diff = linear_depth_of(viewport_depth_texture_at(uv.clone())).sub(depth);
depth_diff.less_than(0.0).select(screen_uv(), uv)
}