use std::cell::RefCell;
use std::ops::Deref;
use std::rc::{Rc, Weak};
use crate::core::Object3D;
use crate::math::{Matrix4, Quaternion, Vector3};
#[derive(Clone)]
pub struct Node(Rc<RefCell<Object3D>>);
#[derive(Clone, Default)]
pub struct WeakNode(Weak<RefCell<Object3D>>);
impl Deref for Node {
type Target = RefCell<Object3D>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl std::fmt::Debug for Node {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
self.0.fmt(f)
}
}
impl std::fmt::Debug for WeakNode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
self.0.fmt(f)
}
}
impl WeakNode {
pub fn new() -> Self {
Self(Weak::new())
}
pub fn upgrade(&self) -> Option<Node> {
self.0.upgrade().map(Node)
}
}
impl Node {
pub fn new(object: Object3D) -> Self {
Self(Rc::new(RefCell::new(object)))
}
pub fn ptr_eq(a: &Node, b: &Node) -> bool {
Rc::ptr_eq(&a.0, &b.0)
}
pub fn downgrade(&self) -> WeakNode {
WeakNode(Rc::downgrade(&self.0))
}
pub fn as_ptr(&self) -> *const RefCell<Object3D> {
Rc::as_ptr(&self.0)
}
pub fn parent(&self) -> Option<Node> {
self.borrow().parent.as_ref().and_then(WeakNode::upgrade)
}
pub fn children(&self) -> Vec<Node> {
self.borrow().children.clone()
}
pub fn add(&self, object: &Node) -> &Self {
if Node::ptr_eq(self, object) {
return self;
}
object.remove_from_parent();
object.borrow_mut().parent = Some(self.downgrade());
self.borrow_mut().children.push(object.clone());
self
}
pub fn remove(&self, object: &Node) -> &Self {
let index = self
.borrow()
.children
.iter()
.position(|child| Node::ptr_eq(child, object));
if let Some(index) = index {
object.borrow_mut().parent = None;
self.borrow_mut().children.remove(index);
}
self
}
pub fn remove_from_parent(&self) -> &Self {
if let Some(parent) = self.parent() {
parent.remove(self);
}
self
}
pub fn clear(&self) -> &Self {
for child in self.children() {
self.remove(&child);
}
self
}
pub fn attach(&self, object: &Node) -> &Self {
self.update_world_matrix(true, false);
let mut m1 = self.borrow().matrix_world;
m1.invert();
if let Some(object_parent) = object.parent() {
object_parent.update_world_matrix(true, false);
let parent_matrix_world = object_parent.borrow().matrix_world;
m1.multiply(&parent_matrix_world);
}
object.apply_matrix4(&m1);
object.remove_from_parent();
object.borrow_mut().parent = Some(self.downgrade());
self.borrow_mut().children.push(object.clone());
object.update_world_matrix(false, true);
self
}
pub fn get_object_by_id(&self, id: u32) -> Option<Node> {
self.get_object_by_property(&|object| object.id == id)
}
pub fn get_object_by_name(&self, name: &str) -> Option<Node> {
self.get_object_by_property(&|object| object.name == name)
}
pub fn get_object_by_property(&self, test: &dyn Fn(&Object3D) -> bool) -> Option<Node> {
if test(&self.borrow()) {
return Some(self.clone());
}
for child in self.children() {
if let Some(object) = child.get_object_by_property(test) {
return Some(object);
}
}
None
}
pub fn get_objects_by_property(&self, test: &dyn Fn(&Object3D) -> bool) -> Vec<Node> {
let mut result = Vec::new();
if test(&self.borrow()) {
result.push(self.clone());
}
for child in self.children() {
result.extend(child.get_objects_by_property(test));
}
result
}
pub fn traverse(&self, callback: &mut dyn FnMut(&Node)) {
callback(self);
for child in self.children() {
child.traverse(callback);
}
}
pub fn traverse_visible(&self, callback: &mut dyn FnMut(&Node)) {
if !self.borrow().visible {
return;
}
callback(self);
for child in self.children() {
child.traverse_visible(callback);
}
}
pub fn traverse_ancestors(&self, callback: &mut dyn FnMut(&Node)) {
if let Some(parent) = self.parent() {
callback(&parent);
parent.traverse_ancestors(callback);
}
}
pub fn update_matrix_world(&self, force: bool) {
let force = update_own_matrix_world(self, force);
for child in self.children() {
child.update_matrix_world(force);
}
}
pub fn update_world_matrix(&self, update_parents: bool, update_children: bool) {
if update_parents {
if let Some(parent) = self.parent() {
parent.update_world_matrix(true, false);
}
}
let force = update_own_matrix_world(self, false);
if update_children {
for child in self.children() {
update_children_world_matrix(&child, force);
}
}
}
pub fn get_world_position(&self) -> Vector3 {
self.update_world_matrix(true, false);
let mut target = Vector3::ZERO;
target.set_from_matrix_position(&self.borrow().matrix_world);
target
}
pub fn get_world_quaternion(&self) -> Quaternion {
self.update_world_matrix(true, false);
let mut position = Vector3::ZERO;
let mut target = Quaternion::default();
let mut scale = Vector3::ZERO;
self.borrow()
.matrix_world
.decompose(&mut position, &mut target, &mut scale);
target
}
pub fn get_world_scale(&self) -> Vector3 {
self.update_world_matrix(true, false);
let mut position = Vector3::ZERO;
let mut quaternion = Quaternion::default();
let mut target = Vector3::ZERO;
self.borrow()
.matrix_world
.decompose(&mut position, &mut quaternion, &mut target);
target
}
pub fn get_world_direction(&self) -> Vector3 {
self.update_world_matrix(true, false);
let object = self.borrow();
let e = &object.matrix_world.elements;
let mut target = Vector3::new(e[8], e[9], e[10]);
target.normalize();
target
}
pub fn local_to_world(&self, vector: &mut Vector3) {
self.update_world_matrix(true, false);
vector.apply_matrix4(&self.borrow().matrix_world);
}
pub fn world_to_local(&self, vector: &mut Vector3) {
self.update_world_matrix(true, false);
let mut m1 = self.borrow().matrix_world;
m1.invert();
vector.apply_matrix4(&m1);
}
pub fn look_at(&self, target: &Vector3) {
let parent = self.parent();
self.update_world_matrix(true, false);
let mut position = Vector3::ZERO;
position.set_from_matrix_position(&self.borrow().matrix_world);
let mut m1 = Matrix4::identity();
let up = self.borrow().up;
if self.borrow().is_camera || self.borrow().is_light {
m1.look_at(&position, target, &up);
} else {
m1.look_at(target, &position, &up);
}
self.borrow_mut().quaternion.set_from_rotation_matrix(&m1);
if let Some(parent) = parent {
m1.extract_rotation(&parent.borrow().matrix_world);
let mut q1 = Quaternion::default();
q1.set_from_rotation_matrix(&m1);
q1.invert();
self.borrow_mut().quaternion.premultiply(&q1);
}
self.borrow_mut().sync_rotation_from_quaternion();
}
pub fn apply_matrix4(&self, m: &Matrix4) {
self.borrow_mut().apply_matrix4(m);
}
}
fn update_own_matrix_world(node: &Node, force: bool) -> bool {
if node.borrow().matrix_auto_update {
node.borrow_mut().update_matrix();
}
let alias = node
.borrow()
.matrix_alias
.as_ref()
.and_then(WeakNode::upgrade);
if let Some(source) = alias {
let matrix_world = source.borrow().matrix_world;
node.borrow_mut().matrix = matrix_world;
}
let (needs_update, world_auto_update) = {
let object = node.borrow();
(
object.matrix_world_needs_update,
object.matrix_world_auto_update,
)
};
if needs_update || force {
if world_auto_update {
let parent_matrix_world = node.parent().map(|parent| parent.borrow().matrix_world);
let mut object = node.borrow_mut();
match parent_matrix_world {
None => object.matrix_world = object.matrix,
Some(parent) => {
let matrix = object.matrix;
object.matrix_world.multiply_matrices(&parent, &matrix);
}
}
}
node.borrow_mut().matrix_world_needs_update = false;
update_bind_matrix_inverse(node);
return true;
}
update_bind_matrix_inverse(node);
force
}
fn update_bind_matrix_inverse(node: &Node) {
let mut object = node.borrow_mut();
if !object.payload.is_skinned_mesh() {
return;
}
let matrix_world = object.matrix_world;
if let Some(skin) = object.payload.skinned_mesh_mut() {
skin.update_bind_matrix_inverse(&matrix_world);
}
}
fn update_children_world_matrix(node: &Node, force: bool) {
let force = update_own_matrix_world(node, force);
for child in node.children() {
update_children_world_matrix(&child, force);
}
}