pub fn get_keyframe_order(times: &[f64]) -> Vec<usize> {
let n = times.len();
let mut result: Vec<usize> = (0..n).collect();
result.sort_by(|&i, &j| {
(times[i] - times[j])
.partial_cmp(&0.0)
.unwrap_or(std::cmp::Ordering::Equal)
});
result
}
pub fn sorted_array(values: &[f64], stride: usize, order: &[usize]) -> Vec<f64> {
let n_values = values.len();
let mut result = vec![0.0; n_values];
let mut dst_offset = 0;
let mut i = 0;
while dst_offset != n_values {
let src_offset = order[i] * stride;
for j in 0..stride {
result[dst_offset] = values[src_offset + j];
dst_offset += 1;
}
i += 1;
}
result
}
pub fn flatten_json(
json_keys: &[serde_json::Value],
times: &mut Vec<f64>,
values: &mut Vec<f64>,
value_property_name: &str,
) {
let number = |v: &serde_json::Value| v.as_f64().unwrap_or(f64::NAN);
let mut i = 1;
let mut key = json_keys.first();
while let Some(k) = key {
if k.get(value_property_name).is_some() {
break;
}
key = json_keys.get(i);
i += 1;
}
let Some(first) = key else {
return; };
let value = &first[value_property_name];
if value.is_array() {
while let Some(k) = key {
if let Some(value) = k.get(value_property_name) {
times.push(number(&k["time"]));
values.extend(value.as_array().into_iter().flatten().map(number));
}
key = json_keys.get(i);
i += 1;
}
} else {
while let Some(k) = key {
if let Some(value) = k.get(value_property_name) {
times.push(number(&k["time"]));
values.push(number(value));
}
key = json_keys.get(i);
i += 1;
}
}
}
use crate::math::Quaternion;
use super::animation_clip::{AnimationBlendMode, AnimationClip};
use super::keyframe_track::{KeyframeTrack, TrackValueType};
pub fn subclip(
source_clip: &AnimationClip,
name: &str,
start_frame: f64,
end_frame: f64,
fps: f64,
) -> AnimationClip {
let mut clip = source_clip.clone_clip();
clip.name = name.to_string();
let mut tracks: Vec<KeyframeTrack> = Vec::new();
for track in clip.tracks.iter_mut() {
let value_size = track.get_value_size();
let mut times = Vec::new();
let mut values = Vec::new();
for j in 0..track.times.len() {
let frame = track.times[j] * fps;
if frame < start_frame || frame >= end_frame {
continue;
}
times.push(track.times[j]);
for k in 0..value_size {
values.push(track.values[j * value_size + k]);
}
}
if times.is_empty() {
continue;
}
track.times = times;
track.values = values;
tracks.push(track.clone_track());
}
clip.tracks = tracks;
let mut min_start_time = f64::INFINITY;
for track in &clip.tracks {
if min_start_time > track.times[0] {
min_start_time = track.times[0];
}
}
for track in clip.tracks.iter_mut() {
track.shift(-min_start_time);
}
clip.reset_duration();
clip
}
pub fn make_clip_additive(
target_clip: &mut AnimationClip,
reference_frame: f64,
reference_clip: Option<&AnimationClip>,
fps: f64,
) {
let mut fps = fps;
if fps <= 0.0 {
fps = 30.0;
}
let reference_snapshot: AnimationClip;
let reference: &AnimationClip = match reference_clip {
Some(clip) => clip,
None => {
reference_snapshot = target_clip.clone_clip();
&reference_snapshot
}
};
let num_tracks = reference.tracks.len();
let reference_time = reference_frame / fps;
for i in 0..num_tracks {
let reference_track = &reference.tracks[i];
let reference_track_type = reference_track.value_type();
if reference_track_type == TrackValueType::Bool
|| reference_track_type == TrackValueType::String
{
continue;
}
let Some(target_index) = target_clip.tracks.iter().position(|track| {
track.name == reference_track.name && track.value_type() == reference_track_type
}) else {
continue;
};
let reference_offset = 0usize;
let reference_value_size = reference_track.get_value_size();
let target_offset = 0usize;
let target_value_size = target_clip.tracks[target_index].get_value_size();
let last_index = reference_track.times.len() - 1;
let mut reference_value: Vec<f64>;
if reference_time <= reference_track.times[0] {
let start_index = reference_offset;
let end_index = reference_value_size - reference_offset;
reference_value = reference_track.values[start_index..end_index].to_vec();
} else if reference_time >= reference_track.times[last_index] {
let start_index = last_index * reference_value_size + reference_offset;
let end_index = start_index + reference_value_size - reference_offset;
reference_value = reference_track.values[start_index..end_index].to_vec();
} else {
let start_index = reference_offset;
let end_index = reference_value_size - reference_offset;
reference_value = match reference_track.create_interpolant(None) {
Some(mut interpolant) => {
interpolant.evaluate(reference_time);
interpolant.result_buffer()[start_index..end_index].to_vec()
}
None => reference_track.values[start_index..end_index].to_vec(),
};
}
if reference_track_type == TrackValueType::Quaternion {
let mut reference_quat = Quaternion::default();
reference_quat.from_array(&reference_value, 0);
reference_quat.normalize().conjugate();
reference_value[..4].copy_from_slice(&reference_quat.to_array());
}
let target_track = &mut target_clip.tracks[target_index];
let num_times = target_track.times.len();
for j in 0..num_times {
let value_start = j * target_value_size + target_offset;
if reference_track_type == TrackValueType::Quaternion {
let (x, y, z, w) = (
target_track.values[value_start],
target_track.values[value_start + 1],
target_track.values[value_start + 2],
target_track.values[value_start + 3],
);
let src0 = [x, y, z, w];
Quaternion::multiply_quaternions_flat(
&mut target_track.values,
value_start,
&src0,
0,
&reference_value,
0,
);
} else {
let value_end = target_value_size - target_offset * 2;
for (t, r) in target_track.values[value_start..value_start + value_end]
.iter_mut()
.zip(reference_value.iter())
{
*t -= *r;
}
}
}
}
target_clip.blend_mode = AnimationBlendMode::Additive;
}