use crate::animation::binding_target::BindingTarget;
use crate::animation::keyframe_track::TrackValueType;
use crate::math::Quaternion;
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub(crate) enum MixKind {
Quaternion,
Select,
Lerp,
}
impl MixKind {
pub fn for_value_type(type_name: TrackValueType) -> Self {
match type_name {
TrackValueType::Quaternion => Self::Quaternion,
TrackValueType::Bool | TrackValueType::String => Self::Select,
TrackValueType::Color | TrackValueType::Number | TrackValueType::Vector => Self::Lerp,
}
}
}
pub struct PropertyMixer {
pub binding: Box<dyn BindingTarget>,
pub value_size: usize,
pub buffer: Vec<f64>,
mix_kind: MixKind,
orig_index: usize,
add_index: usize,
work_index: usize,
pub cumulative_weight: f64,
pub cumulative_weight_additive: f64,
pub use_count: usize,
pub reference_count: usize,
}
impl PropertyMixer {
pub fn new(
binding: Box<dyn BindingTarget>,
type_name: TrackValueType,
value_size: usize,
) -> Self {
let mix_kind = MixKind::for_value_type(type_name);
let regions = match mix_kind {
MixKind::Quaternion => 6,
_ => 5,
};
Self {
binding,
value_size,
buffer: vec![0.0; value_size * regions],
mix_kind,
orig_index: 3,
add_index: 4,
work_index: 5,
cumulative_weight: 0.0,
cumulative_weight_additive: 0.0,
use_count: 0,
reference_count: 0,
}
}
pub fn accumulate(&mut self, accu_index: usize, weight: f64) {
let stride = self.value_size;
let offset = accu_index * stride + stride;
let mut current_weight = self.cumulative_weight;
if current_weight == 0.0 {
for i in 0..stride {
self.buffer[offset + i] = self.buffer[i];
}
current_weight = weight;
} else {
current_weight += weight;
let mix = weight / current_weight;
self.mix_buffer_region(offset, 0, mix, stride);
}
self.cumulative_weight = current_weight;
}
pub fn accumulate_additive(&mut self, weight: f64) {
let stride = self.value_size;
let offset = stride * self.add_index;
if self.cumulative_weight_additive == 0.0 {
self.set_identity();
}
self.mix_buffer_region_additive(offset, 0, weight, stride);
self.cumulative_weight_additive += weight;
}
pub fn apply(&mut self, accu_index: usize) {
let stride = self.value_size;
let offset = accu_index * stride + stride;
let weight = self.cumulative_weight;
let weight_additive = self.cumulative_weight_additive;
self.cumulative_weight = 0.0;
self.cumulative_weight_additive = 0.0;
if weight < 1.0 {
let original_value_offset = stride * self.orig_index;
self.mix_buffer_region(offset, original_value_offset, 1.0 - weight, stride);
}
if weight_additive > 0.0 {
self.mix_buffer_region_additive(offset, self.add_index * stride, 1.0, stride);
}
for i in stride..(stride + stride) {
if self.buffer[i] != self.buffer[i + stride] {
self.binding.set_value(&self.buffer, offset);
break;
}
}
}
pub fn save_original_state(&mut self) {
let stride = self.value_size;
let original_value_offset = stride * self.orig_index;
self.binding
.get_value(&mut self.buffer, original_value_offset);
for i in stride..original_value_offset {
self.buffer[i] = self.buffer[original_value_offset + (i % stride)];
}
self.set_identity();
self.cumulative_weight = 0.0;
self.cumulative_weight_additive = 0.0;
}
pub fn restore_original_state(&mut self) {
let original_value_offset = self.value_size * 3;
self.binding.set_value(&self.buffer, original_value_offset);
}
fn set_identity(&mut self) {
match self.mix_kind {
MixKind::Quaternion => self.set_additive_identity_quaternion(),
MixKind::Select => self.set_additive_identity_other(),
MixKind::Lerp => self.set_additive_identity_numeric(),
}
}
fn set_additive_identity_numeric(&mut self) {
let start_index = self.add_index * self.value_size;
let end_index = start_index + self.value_size;
for i in start_index..end_index {
self.buffer[i] = 0.0;
}
}
fn set_additive_identity_quaternion(&mut self) {
self.set_additive_identity_numeric();
self.buffer[self.add_index * self.value_size + 3] = 1.0;
}
fn set_additive_identity_other(&mut self) {
let start_index = self.orig_index * self.value_size;
let target_index = self.add_index * self.value_size;
for i in 0..self.value_size {
self.buffer[target_index + i] = self.buffer[start_index + i];
}
}
fn mix_buffer_region(&mut self, dst_offset: usize, src_offset: usize, t: f64, stride: usize) {
match self.mix_kind {
MixKind::Quaternion => Self::slerp(&mut self.buffer, dst_offset, src_offset, t),
MixKind::Select => Self::select(&mut self.buffer, dst_offset, src_offset, t, stride),
MixKind::Lerp => Self::lerp(&mut self.buffer, dst_offset, src_offset, t, stride),
}
}
fn mix_buffer_region_additive(
&mut self,
dst_offset: usize,
src_offset: usize,
t: f64,
stride: usize,
) {
match self.mix_kind {
MixKind::Quaternion => {
let work_offset = self.work_index * stride;
Self::slerp_additive(&mut self.buffer, dst_offset, src_offset, t, work_offset);
}
MixKind::Select => Self::select(&mut self.buffer, dst_offset, src_offset, t, stride),
MixKind::Lerp => {
Self::lerp_additive(&mut self.buffer, dst_offset, src_offset, t, stride);
}
}
}
fn select(buffer: &mut [f64], dst_offset: usize, src_offset: usize, t: f64, stride: usize) {
if t >= 0.5 {
for i in 0..stride {
buffer[dst_offset + i] = buffer[src_offset + i];
}
}
}
fn slerp(buffer: &mut [f64], dst_offset: usize, src_offset: usize, t: f64) {
let mut src0 = [0.0; 4];
let mut src1 = [0.0; 4];
src0.copy_from_slice(&buffer[dst_offset..dst_offset + 4]);
src1.copy_from_slice(&buffer[src_offset..src_offset + 4]);
Quaternion::slerp_flat(buffer, dst_offset, &src0, 0, &src1, 0, t);
}
fn slerp_additive(
buffer: &mut [f64],
dst_offset: usize,
src_offset: usize,
t: f64,
work_offset: usize,
) {
let mut src0 = [0.0; 4];
let mut src1 = [0.0; 4];
src0.copy_from_slice(&buffer[dst_offset..dst_offset + 4]);
src1.copy_from_slice(&buffer[src_offset..src_offset + 4]);
Quaternion::multiply_quaternions_flat(buffer, work_offset, &src0, 0, &src1, 0);
Self::slerp(buffer, dst_offset, work_offset, t);
}
fn lerp(buffer: &mut [f64], dst_offset: usize, src_offset: usize, t: f64, stride: usize) {
let s = 1.0 - t;
for i in 0..stride {
let j = dst_offset + i;
buffer[j] = buffer[j] * s + buffer[src_offset + i] * t;
}
}
fn lerp_additive(
buffer: &mut [f64],
dst_offset: usize,
src_offset: usize,
t: f64,
stride: usize,
) {
for i in 0..stride {
let j = dst_offset + i;
buffer[j] += buffer[src_offset + i] * t;
}
}
}