use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
use crate::animation::binding_target::{BindingTarget, TargetResolver};
use crate::animation::property_binding::ParsedTrackName;
use crate::core::ObjectRef;
use crate::objects::Skeleton;
#[derive(Clone, Debug)]
pub(crate) enum NodeProperty {
Position,
Quaternion,
Scale,
MorphTargetInfluences(Rc<RefCell<Vec<f64>>>),
}
pub(crate) struct NodeTarget {
node: ObjectRef,
property: NodeProperty,
}
impl NodeTarget {
pub fn new(node: ObjectRef, property: NodeProperty) -> Self {
Self { node, property }
}
}
impl BindingTarget for NodeTarget {
fn get_value(&self, buffer: &mut [f64], offset: usize) {
let object = self.node.borrow();
match &self.property {
NodeProperty::Position => write(buffer, offset, &object.position.to_array()),
NodeProperty::Quaternion => write(buffer, offset, &object.quaternion.to_array()),
NodeProperty::Scale => write(buffer, offset, &object.scale.to_array()),
NodeProperty::MorphTargetInfluences(influences) => {
write(buffer, offset, &influences.borrow())
}
}
}
fn set_value(&mut self, buffer: &[f64], offset: usize) {
let mut object = self.node.borrow_mut();
match &self.property {
NodeProperty::Position => {
object.position.from_array(buffer, offset);
}
NodeProperty::Quaternion => {
object.quaternion.from_array(buffer, offset);
object.sync_rotation_from_quaternion();
}
NodeProperty::Scale => {
object.scale.from_array(buffer, offset);
}
NodeProperty::MorphTargetInfluences(influences) => {
let mut influences = influences.borrow_mut();
let n = influences.len();
influences.copy_from_slice(&buffer[offset..offset + n]);
}
}
object.matrix_world_needs_update = true;
}
fn value_size(&self) -> usize {
match &self.property {
NodeProperty::Position | NodeProperty::Scale => 3,
NodeProperty::Quaternion => 4,
NodeProperty::MorphTargetInfluences(influences) => influences.borrow().len(),
}
}
}
fn write(buffer: &mut [f64], offset: usize, values: &[f64]) {
buffer[offset..offset + values.len()].copy_from_slice(values);
}
pub struct SceneResolver {
root: ObjectRef,
skeleton: Option<Rc<RefCell<Skeleton>>>,
morph_target_influences: HashMap<u32, Rc<RefCell<Vec<f64>>>>,
}
impl SceneResolver {
pub fn new(root: ObjectRef) -> Self {
Self {
root,
skeleton: None,
morph_target_influences: HashMap::new(),
}
}
pub fn with_skeleton(mut self, skeleton: Rc<RefCell<Skeleton>>) -> Self {
self.skeleton = Some(skeleton);
self
}
pub fn add_morph_target_influences(
&mut self,
node: &ObjectRef,
influences: Rc<RefCell<Vec<f64>>>,
) -> &mut Self {
self.morph_target_influences
.insert(node.borrow().id, influences);
self
}
pub fn find_node(&self, node_name: Option<&str>) -> Option<ObjectRef> {
let name = match node_name {
None | Some("") | Some(".") | Some("-1") => return Some(self.root.clone()),
Some(name) if name == self.root.borrow().name => return Some(self.root.clone()),
Some(name) => name,
};
if let Some(skeleton) = &self.skeleton {
if let Some(bone) = skeleton.borrow().get_bone_by_name(name) {
return Some(bone);
}
}
search_node_subtree(&self.root.children(), name)
}
}
fn search_node_subtree(children: &[ObjectRef], name: &str) -> Option<ObjectRef> {
for child in children {
if child.borrow().name == name {
return Some(child.clone());
}
if let Some(result) = search_node_subtree(&child.children(), name) {
return Some(result);
}
}
None
}
impl TargetResolver for SceneResolver {
fn resolve(&mut self, parsed: &ParsedTrackName) -> Option<Box<dyn BindingTarget>> {
let node = self.find_node(parsed.node_name.as_deref())?;
if parsed.object_name.is_some() {
return None;
}
if parsed.property_index.is_some() {
return None;
}
let property = match parsed.property_name.as_str() {
"position" => NodeProperty::Position,
"quaternion" => NodeProperty::Quaternion,
"scale" => NodeProperty::Scale,
"morphTargetInfluences" => NodeProperty::MorphTargetInfluences(
self.morph_target_influences.get(&node.borrow().id)?.clone(),
),
_ => return None,
};
Some(Box::new(NodeTarget::new(node, property)))
}
}