use std::cell::Cell;
use std::fmt;
use std::rc::Rc;
use crate::cameras::RenderCamera;
use crate::core::{Group, ObjectRef};
use crate::objects::Scene;
use crate::renderer::{RenderTarget, Renderer};
#[cfg(doc)]
use crate::core::Object3D;
#[derive(Clone, Debug)]
pub enum SceneEvent {
Added,
Removed,
ChildAdded(ObjectRef),
ChildRemoved(ObjectRef),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum SceneEventType {
Added,
Removed,
ChildAdded,
ChildRemoved,
}
impl SceneEvent {
pub fn event_type(&self) -> SceneEventType {
match self {
Self::Added => SceneEventType::Added,
Self::Removed => SceneEventType::Removed,
Self::ChildAdded(_) => SceneEventType::ChildAdded,
Self::ChildRemoved(_) => SceneEventType::ChildRemoved,
}
}
pub fn child(&self) -> Option<&ObjectRef> {
match self {
Self::ChildAdded(child) | Self::ChildRemoved(child) => Some(child),
Self::Added | Self::Removed => None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct ListenerHandle(u64);
impl ListenerHandle {
fn next() -> Self {
thread_local! {
static NEXT: Cell<u64> = const { Cell::new(0) };
}
NEXT.with(|next| {
let value = next.get();
next.set(value + 1);
Self(value)
})
}
}
pub type SceneEventListener = Rc<dyn Fn(&SceneEvent, &ObjectRef)>;
#[derive(Clone, Default)]
pub struct SceneEventListeners {
entries: Vec<(SceneEventType, ListenerHandle, SceneEventListener)>,
}
impl fmt::Debug for SceneEventListeners {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list()
.entries(self.entries.iter().map(|(ty, handle, _)| (ty, handle)))
.finish()
}
}
impl SceneEventListeners {
pub(crate) fn add(
&mut self,
ty: SceneEventType,
listener: SceneEventListener,
) -> ListenerHandle {
let handle = ListenerHandle::next();
self.entries.push((ty, handle, listener));
handle
}
pub(crate) fn has(&self, ty: SceneEventType, handle: ListenerHandle) -> bool {
self.entries
.iter()
.any(|(t, h, _)| *t == ty && *h == handle)
}
pub(crate) fn remove(&mut self, ty: SceneEventType, handle: ListenerHandle) {
if let Some(index) = self
.entries
.iter()
.position(|(t, h, _)| *t == ty && *h == handle)
{
self.entries.remove(index);
}
}
pub(crate) fn snapshot(&self, ty: SceneEventType) -> Vec<SceneEventListener> {
self.entries
.iter()
.filter(|(t, _, _)| *t == ty)
.map(|(_, _, listener)| listener.clone())
.collect()
}
pub(crate) fn is_empty(&self) -> bool {
self.entries.is_empty()
}
}
pub type ObjectRenderHook =
Box<dyn FnMut(&ObjectRef, &Renderer, &Scene, &dyn RenderCamera, Option<&Group>)>;
pub type SceneRenderHook = Box<dyn Fn(&Renderer, &Scene, &dyn RenderCamera, Option<&RenderTarget>)>;