use std::cell::{Cell, RefCell};
use std::collections::HashMap;
use std::rc::Rc;
use crate::animation::binding_target::{BindingTarget, TargetResolver};
use crate::animation::property_binding::ParsedTrackName;
fn generate_uuid() -> String {
use std::sync::atomic::{AtomicU64, Ordering};
static COUNTER: AtomicU64 = AtomicU64::new(0);
let nanos = (crate::utils::time::real_date_now_ms() * 1e6) as u64;
let counter = COUNTER.fetch_add(1, Ordering::Relaxed);
let mut state = nanos ^ (counter.wrapping_mul(0x9E37_79B9_7F4A_7C15) | 1);
let mut next = move || {
state ^= state >> 12;
state ^= state << 25;
state ^= state >> 27;
state.wrapping_mul(0x2545_F491_4F6C_DD1D)
};
let mut bytes = [0u8; 16];
for chunk in bytes.chunks_mut(8) {
let v = next().to_le_bytes();
chunk.copy_from_slice(&v[..chunk.len()]);
}
bytes[6] = (bytes[6] & 0x0f) | 0x40;
bytes[8] = (bytes[8] & 0x3f) | 0x80;
let hex: Vec<String> = bytes.iter().map(|b| format!("{b:02x}")).collect();
format!(
"{}-{}-{}-{}-{}",
hex[0..4].concat(),
hex[4..6].concat(),
hex[6..8].concat(),
hex[8..10].concat(),
hex[10..16].concat()
)
}
pub trait GroupMember: TargetResolver {
fn uuid(&self) -> String;
}
pub type MemberRef<M> = Rc<RefCell<M>>;
pub type BindingsForPath<M> = Rc<RefCell<Vec<Option<MemberBinding<M>>>>>;
pub struct MemberBinding<M: GroupMember> {
member: MemberRef<M>,
path: String,
parsed_path: ParsedTrackName,
target: Option<Box<dyn BindingTarget>>,
resolve_failed: bool,
}
impl<M: GroupMember> MemberBinding<M> {
fn new(member: MemberRef<M>, path: &str, parsed_path: &ParsedTrackName) -> Self {
Self {
member,
path: path.to_string(),
parsed_path: parsed_path.clone(),
target: None,
resolve_failed: false,
}
}
pub fn path(&self) -> &str {
&self.path
}
pub fn parsed_path(&self) -> &ParsedTrackName {
&self.parsed_path
}
pub fn member(&self) -> &MemberRef<M> {
&self.member
}
pub fn member_uuid(&self) -> String {
self.member.borrow().uuid()
}
pub fn bind(&mut self) -> bool {
if self.target.is_some() {
return true;
}
if self.resolve_failed {
return false;
}
match self.member.borrow_mut().resolve(&self.parsed_path) {
Some(target) => {
self.target = Some(target);
true
}
None => {
self.resolve_failed = true;
false
}
}
}
pub fn unbind(&mut self) {
self.target = None;
self.resolve_failed = false;
}
pub fn get_value(&mut self, buffer: &mut [f64], offset: usize) {
if self.bind() {
self.target
.as_ref()
.expect("three-rs: bind() returned true, so the target resolved")
.get_value(buffer, offset);
}
}
pub fn set_value(&mut self, buffer: &[f64], offset: usize) {
if self.bind() {
self.target
.as_mut()
.expect("three-rs: bind() returned true, so the target resolved")
.set_value(buffer, offset);
}
}
pub fn value_size(&mut self) -> usize {
if self.bind() {
self.target
.as_ref()
.expect("three-rs: bind() returned true, so the target resolved")
.value_size()
} else {
0
}
}
}
pub struct Composite<M: GroupMember> {
bindings: BindingsForPath<M>,
n_cached_objects: Rc<Cell<usize>>,
}
impl<M: GroupMember> Composite<M> {
pub(crate) fn new(bindings: BindingsForPath<M>, n_cached_objects: Rc<Cell<usize>>) -> Self {
Self {
bindings,
n_cached_objects,
}
}
}
impl<M: GroupMember + 'static> BindingTarget for Composite<M> {
fn get_value(&self, buffer: &mut [f64], offset: usize) {
let first = self.n_cached_objects.get();
let mut bindings = self.bindings.borrow_mut();
if let Some(Some(binding)) = bindings.get_mut(first) {
binding.get_value(buffer, offset);
}
}
fn set_value(&mut self, buffer: &[f64], offset: usize) {
let first = self.n_cached_objects.get();
let mut bindings = self.bindings.borrow_mut();
let n = bindings.len();
for i in first..n {
if let Some(binding) = bindings[i].as_mut() {
binding.set_value(buffer, offset);
}
}
}
fn value_size(&self) -> usize {
let first = self.n_cached_objects.get();
let mut bindings = self.bindings.borrow_mut();
match bindings.get_mut(first) {
Some(Some(binding)) => binding.value_size(),
_ => 0,
}
}
fn bind(&mut self) {
let first = self.n_cached_objects.get();
let mut bindings = self.bindings.borrow_mut();
let n = bindings.len();
for i in first..n {
if let Some(binding) = bindings[i].as_mut() {
binding.bind();
}
}
}
fn unbind(&mut self) {
let first = self.n_cached_objects.get();
let mut bindings = self.bindings.borrow_mut();
let n = bindings.len();
for i in first..n {
if let Some(binding) = bindings[i].as_mut() {
binding.unbind();
}
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct StatsObjects {
pub total: usize,
pub in_use: usize,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Stats {
pub objects: StatsObjects,
pub bindings_per_object: usize,
}
pub struct AnimationObjectGroup<M: GroupMember> {
pub uuid: String,
objects: Vec<MemberRef<M>>,
indices_by_uuid: HashMap<String, usize>,
n_cached_objects: Rc<Cell<usize>>,
paths: Vec<String>,
parsed_paths: Vec<ParsedTrackName>,
bindings: Vec<BindingsForPath<M>>,
bindings_indices_by_path: HashMap<String, usize>,
}
impl<M: GroupMember> Default for AnimationObjectGroup<M> {
fn default() -> Self {
Self::new()
}
}
impl<M: GroupMember> AnimationObjectGroup<M> {
pub fn new() -> Self {
Self {
uuid: generate_uuid(),
objects: Vec::new(),
indices_by_uuid: HashMap::new(),
n_cached_objects: Rc::new(Cell::new(0)),
paths: Vec::new(),
parsed_paths: Vec::new(),
bindings: Vec::new(),
bindings_indices_by_path: HashMap::new(),
}
}
pub fn with_members(members: &[MemberRef<M>]) -> Self {
let mut group = Self::new();
for (i, member) in members.iter().enumerate() {
group.indices_by_uuid.insert(member.borrow().uuid(), i);
group.objects.push(Rc::clone(member));
}
group
}
pub fn is_animation_object_group(&self) -> bool {
true
}
pub fn n_cached_objects(&self) -> usize {
self.n_cached_objects.get()
}
pub(crate) fn n_cached_objects_handle(&self) -> Rc<Cell<usize>> {
Rc::clone(&self.n_cached_objects)
}
pub fn objects(&self) -> &[MemberRef<M>] {
&self.objects
}
pub fn stats(&self) -> Stats {
let total = self.objects.len();
Stats {
objects: StatsObjects {
total,
in_use: total - self.n_cached_objects.get(),
},
bindings_per_object: self.bindings.len(),
}
}
pub fn add(&mut self, members: &[MemberRef<M>]) {
let n_bindings = self.bindings.len();
let mut known_object: Option<MemberRef<M>> = None;
let mut n_objects = self.objects.len();
let mut n_cached_objects = self.n_cached_objects.get();
for member in members {
let uuid = member.borrow().uuid();
let index = self.indices_by_uuid.get(&uuid).copied();
match index {
None => {
let index = n_objects;
n_objects += 1;
self.indices_by_uuid.insert(uuid, index);
self.objects.push(Rc::clone(member));
for j in 0..n_bindings {
self.bindings[j].borrow_mut().push(Some(MemberBinding::new(
Rc::clone(member),
&self.paths[j],
&self.parsed_paths[j],
)));
}
}
Some(index) if index < n_cached_objects => {
known_object = Some(Rc::clone(&self.objects[index]));
n_cached_objects -= 1;
let first_active_index = n_cached_objects;
let last_cached_object = Rc::clone(&self.objects[first_active_index]);
let last_cached_uuid = last_cached_object.borrow().uuid();
self.indices_by_uuid.insert(last_cached_uuid, index);
self.objects[index] = last_cached_object;
self.indices_by_uuid.insert(uuid, first_active_index);
self.objects[first_active_index] = Rc::clone(member);
for j in 0..n_bindings {
let mut bindings_for_path = self.bindings[j].borrow_mut();
if index == first_active_index {
let binding = bindings_for_path[index].take().unwrap_or_else(|| {
MemberBinding::new(
Rc::clone(member),
&self.paths[j],
&self.parsed_paths[j],
)
});
bindings_for_path[index] = Some(binding);
continue;
}
let last_cached = bindings_for_path[first_active_index].take();
let binding = bindings_for_path[index].take();
bindings_for_path[index] = last_cached;
let binding = binding.unwrap_or_else(|| {
MemberBinding::new(
Rc::clone(member),
&self.paths[j],
&self.parsed_paths[j],
)
});
bindings_for_path[first_active_index] = Some(binding);
}
}
Some(index) => {
let same = known_object
.as_ref()
.is_some_and(|known| Rc::ptr_eq(&self.objects[index], known));
if !same && !Rc::ptr_eq(&self.objects[index], member) {
eprintln!(
"AnimationObjectGroup: Different objects with the same UUID \
detected. Clean the caches or recreate your infrastructure \
when reloading scenes."
);
}
}
}
}
self.n_cached_objects.set(n_cached_objects);
}
pub fn add_one(&mut self, member: &MemberRef<M>) {
self.add(std::slice::from_ref(member));
}
pub fn remove(&mut self, members: &[MemberRef<M>]) {
let n_bindings = self.bindings.len();
let mut n_cached_objects = self.n_cached_objects.get();
for member in members {
let uuid = member.borrow().uuid();
let index = self.indices_by_uuid.get(&uuid).copied();
if let Some(index) = index {
if index >= n_cached_objects {
let last_cached_index = n_cached_objects;
n_cached_objects += 1;
let first_active_object = Rc::clone(&self.objects[last_cached_index]);
let first_active_uuid = first_active_object.borrow().uuid();
self.indices_by_uuid.insert(first_active_uuid, index);
self.objects[index] = first_active_object;
self.indices_by_uuid.insert(uuid, last_cached_index);
self.objects[last_cached_index] = Rc::clone(member);
if index != last_cached_index {
for j in 0..n_bindings {
let mut bindings_for_path = self.bindings[j].borrow_mut();
let first_active = bindings_for_path[last_cached_index].take();
let binding = bindings_for_path[index].take();
bindings_for_path[index] = first_active;
bindings_for_path[last_cached_index] = binding;
}
}
}
}
}
self.n_cached_objects.set(n_cached_objects);
}
pub fn remove_one(&mut self, member: &MemberRef<M>) {
self.remove(std::slice::from_ref(member));
}
pub fn uncache(&mut self, members: &[MemberRef<M>]) {
let n_bindings = self.bindings.len();
let mut n_cached_objects = self.n_cached_objects.get();
let mut n_objects = self.objects.len();
for member in members {
let uuid = member.borrow().uuid();
let index = self.indices_by_uuid.get(&uuid).copied();
if let Some(index) = index {
self.indices_by_uuid.remove(&uuid);
if index < n_cached_objects {
n_cached_objects -= 1;
let first_active_index = n_cached_objects;
let last_cached_object = Rc::clone(&self.objects[first_active_index]);
n_objects -= 1;
let last_index = n_objects;
let last_object = Rc::clone(&self.objects[last_index]);
if index != first_active_index {
let last_cached_uuid = last_cached_object.borrow().uuid();
self.indices_by_uuid.insert(last_cached_uuid, index);
}
self.objects[index] = last_cached_object;
if first_active_index != last_index {
let last_uuid = last_object.borrow().uuid();
self.indices_by_uuid.insert(last_uuid, first_active_index);
}
self.objects[first_active_index] = last_object;
self.objects.pop();
for j in 0..n_bindings {
let mut bindings_for_path = self.bindings[j].borrow_mut();
if first_active_index == last_index {
let v = bindings_for_path[first_active_index].take();
if index != first_active_index {
bindings_for_path[index] = v;
}
bindings_for_path.pop();
continue;
}
let last_cached = bindings_for_path[first_active_index].take();
let last = bindings_for_path[last_index].take();
bindings_for_path[index] = last_cached;
bindings_for_path[first_active_index] = last;
bindings_for_path.pop();
}
} else {
n_objects -= 1;
let last_index = n_objects;
let last_object = Rc::clone(&self.objects[last_index]);
if index != last_index {
let last_uuid = last_object.borrow().uuid();
self.indices_by_uuid.insert(last_uuid, index);
}
self.objects[index] = last_object;
self.objects.pop();
for j in 0..n_bindings {
let mut bindings_for_path = self.bindings[j].borrow_mut();
let last = bindings_for_path[last_index].take();
bindings_for_path[index] = last;
bindings_for_path.pop();
}
}
}
}
self.n_cached_objects.set(n_cached_objects);
}
pub fn uncache_one(&mut self, member: &MemberRef<M>) {
self.uncache(std::slice::from_ref(member));
}
#[allow(non_snake_case)]
#[doc(hidden)]
pub fn subscribe_(&mut self, path: &str, parsed_path: &ParsedTrackName) -> BindingsForPath<M> {
if let Some(&index) = self.bindings_indices_by_path.get(path) {
return Rc::clone(&self.bindings[index]);
}
let n_objects = self.objects.len();
let n_cached_objects = self.n_cached_objects.get();
let bindings_for_path: BindingsForPath<M> = Rc::new(RefCell::new(
(0..n_objects).map(|_| None).collect::<Vec<_>>(),
));
let index = self.bindings.len();
self.bindings_indices_by_path
.insert(path.to_string(), index);
self.paths.push(path.to_string());
self.parsed_paths.push(parsed_path.clone());
self.bindings.push(Rc::clone(&bindings_for_path));
{
let mut row = bindings_for_path.borrow_mut();
for i in n_cached_objects..n_objects {
row[i] = Some(MemberBinding::new(
Rc::clone(&self.objects[i]),
path,
parsed_path,
));
}
}
bindings_for_path
}
#[allow(non_snake_case)]
#[doc(hidden)]
pub fn unsubscribe_(&mut self, path: &str) {
let Some(index) = self.bindings_indices_by_path.remove(path) else {
return;
};
let last_bindings_index = self.bindings.len() - 1;
let last_bindings_path = self.paths[last_bindings_index].clone();
self.bindings_indices_by_path
.insert(last_bindings_path, index);
let last_bindings = self.bindings.pop().expect("three-rs: non-empty bindings");
let last_parsed = self
.parsed_paths
.pop()
.expect("three-rs: non-empty parsedPaths");
let last_path = self.paths.pop().expect("three-rs: non-empty paths");
if index != last_bindings_index {
self.bindings[index] = last_bindings;
self.parsed_paths[index] = last_parsed;
self.paths[index] = last_path;
}
}
}
fn parsed_path_key(parsed: &ParsedTrackName) -> String {
format!(
"{}/{}/{}/{}/{}",
parsed.node_name.as_deref().unwrap_or(""),
parsed.object_name.as_deref().unwrap_or(""),
parsed.object_index.as_deref().unwrap_or(""),
parsed.property_name,
parsed.property_index.as_deref().unwrap_or("")
)
}
impl<M: GroupMember + 'static> TargetResolver for AnimationObjectGroup<M> {
fn resolve(&mut self, parsed: &ParsedTrackName) -> Option<Box<dyn BindingTarget>> {
let key = parsed_path_key(parsed);
let bindings = self.subscribe_(&key, parsed);
Some(Box::new(Composite::new(
bindings,
self.n_cached_objects_handle(),
)))
}
}