use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
use crate::cameras::PerspectiveCamera;
use crate::core::{Node, Object3D};
use crate::nodes::tsl::{screen_uv, texture_uv};
use crate::nodes::NodeRef;
use crate::renderer::RenderTarget;
use crate::textures::Texture;
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct ReflectorParameters {
pub target: Option<Node>,
pub resolution_scale: f64,
pub bounces: bool,
pub samples: u32,
}
impl Default for ReflectorParameters {
fn default() -> Self {
Self {
target: None,
resolution_scale: 1.0,
bounces: true,
samples: 0,
}
}
}
pub struct ReflectorBase {
pub target: Node,
pub resolution_scale: f64,
pub bounces: bool,
pub samples: u32,
pub force_update: bool,
pub has_output: bool,
pub(crate) virtual_cameras: HashMap<u32, PerspectiveCamera>,
pub(crate) render_targets: HashMap<u32, RenderTarget>,
pub(crate) default_render_target: RenderTarget,
pub(crate) value: Texture,
}
impl std::fmt::Debug for ReflectorBase {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ReflectorBase")
.field("resolution_scale", &self.resolution_scale)
.field("bounces", &self.bounces)
.field("samples", &self.samples)
.field("virtual_cameras", &self.virtual_cameras.len())
.finish_non_exhaustive()
}
}
#[derive(Clone, Debug)]
pub struct Reflector(Rc<RefCell<ReflectorBase>>);
impl Reflector {
pub fn borrow(&self) -> std::cell::Ref<'_, ReflectorBase> {
self.0.borrow()
}
pub fn borrow_mut(&self) -> std::cell::RefMut<'_, ReflectorBase> {
self.0.borrow_mut()
}
pub(crate) fn key(&self) -> usize {
Rc::as_ptr(&self.0) as *const u8 as usize
}
pub(crate) fn default_texture_id(&self) -> usize {
self.0.borrow().default_render_target.texture().id()
}
pub fn value(&self) -> Texture {
self.0.borrow().value.clone()
}
}
thread_local! {
static REGISTRY: RefCell<HashMap<usize, Rc<RefCell<ReflectorBase>>>> =
RefCell::new(HashMap::new());
static DEFAULT_UV: NodeRef = screen_uv().flip_x();
}
impl ReflectorBase {
fn is_sampled(&self) -> bool {
let texture = self.default_render_target.texture();
let own = 2 + usize::from(self.value.id() == texture.id());
texture.handle_count() > own
}
}
fn prune(registry: &mut HashMap<usize, Rc<RefCell<ReflectorBase>>>) {
registry.retain(|_, base| base.try_borrow().map_or(true, |base| base.is_sampled()));
}
pub(crate) fn lookup(texture_id: usize) -> Option<Reflector> {
REGISTRY.with(|registry| registry.borrow().get(&texture_id).cloned().map(Reflector))
}
pub(crate) fn any() -> bool {
REGISTRY.with(|registry| {
let mut registry = registry.borrow_mut();
prune(&mut registry);
!registry.is_empty()
})
}
#[derive(Clone, Debug)]
pub struct ReflectorNode {
pub uv_node: NodeRef,
reflector: Reflector,
}
impl ReflectorNode {
pub fn reflector(&self) -> &Reflector {
&self.reflector
}
pub fn target(&self) -> Node {
self.reflector.0.borrow().target.clone()
}
pub fn node(&self) -> NodeRef {
let texture = self.reflector.0.borrow().default_render_target.texture();
texture_uv(&texture, self.uv_node.clone())
}
}
impl From<&ReflectorNode> for NodeRef {
fn from(node: &ReflectorNode) -> Self {
node.node()
}
}
pub fn reflector(parameters: ReflectorParameters) -> ReflectorNode {
let default_render_target = RenderTarget::new(1, 1);
let value = default_render_target.texture();
let texture_id = value.id();
let base = Rc::new(RefCell::new(ReflectorBase {
target: parameters
.target
.unwrap_or_else(|| Object3D::default().into_node()),
resolution_scale: parameters.resolution_scale,
bounces: parameters.bounces,
samples: parameters.samples,
force_update: false,
has_output: false,
virtual_cameras: HashMap::new(),
render_targets: HashMap::new(),
default_render_target,
value,
}));
REGISTRY.with(|registry| {
registry.borrow_mut().insert(texture_id, base.clone());
});
ReflectorNode {
uv_node: DEFAULT_UV.with(|uv| uv.clone()),
reflector: Reflector(base),
}
}