use super::{
AnimationTime, Interpolate, Interpolation, Keyframe, TangentKeyframe, TrackValue, ValueKeyframe,
};
use crate::model::mdl::{Parser, TokenKind, Writer};
use crate::model::IoError;
use crate::model::{mdl, mdx};
use crate::model::{Cursor, Encoder, ValueError};
use std::io::Write as IoWrite;
use std::ops::RangeInclusive;
#[derive(Clone, Debug, PartialEq)]
enum Keyframes<T> {
Step(Vec<ValueKeyframe<T>>),
Linear(Vec<ValueKeyframe<T>>),
Hermite(Vec<TangentKeyframe<T>>),
Bezier(Vec<TangentKeyframe<T>>),
}
#[derive(Clone, Debug, PartialEq)]
pub struct Track<T: TrackValue> {
global_sequence_id: Option<u32>,
keyframes: Keyframes<T>,
}
impl<T: TrackValue> Track<T> {
pub fn constant(value: T) -> Self {
Self::step(vec![ValueKeyframe { frame: 0, value }], None)
.expect("one key without a global sequence is valid")
}
pub fn step(
keys: Vec<ValueKeyframe<T>>,
global_sequence_id: Option<u32>,
) -> Result<Self, ValueError> {
Self::new(Keyframes::Step(keys), global_sequence_id)
}
pub fn linear(
keys: Vec<ValueKeyframe<T>>,
global_sequence_id: Option<u32>,
) -> Result<Self, ValueError> {
Self::new(Keyframes::Linear(keys), global_sequence_id)
}
pub fn hermite(
keys: Vec<TangentKeyframe<T>>,
global_sequence_id: Option<u32>,
) -> Result<Self, ValueError> {
Self::new(Keyframes::Hermite(keys), global_sequence_id)
}
pub fn bezier(
keys: Vec<TangentKeyframe<T>>,
global_sequence_id: Option<u32>,
) -> Result<Self, ValueError> {
Self::new(Keyframes::Bezier(keys), global_sequence_id)
}
fn new(keyframes: Keyframes<T>, global_sequence_id: Option<u32>) -> Result<Self, ValueError> {
if keyframes.len() > u32::MAX as usize {
return Err(ValueError::CountTooLarge {
tag: *b"TRAK",
count: keyframes.len(),
});
}
if global_sequence_id == Some(u32::MAX) {
return Err(ValueError::InvalidGlobalSequenceId { id: u32::MAX });
}
Ok(Self {
global_sequence_id,
keyframes: keyframes.into_sorted(),
})
}
pub fn global_sequence_id(&self) -> Option<u32> {
self.global_sequence_id
}
pub fn interpolation(&self) -> Interpolation {
match self.keyframes {
Keyframes::Step(_) => Interpolation::Step,
Keyframes::Linear(_) => Interpolation::Linear,
Keyframes::Hermite(_) => Interpolation::Hermite,
Keyframes::Bezier(_) => Interpolation::Bezier,
}
}
pub fn step_keys(&self) -> Option<&[ValueKeyframe<T>]> {
match &self.keyframes {
Keyframes::Step(keys) => Some(keys),
_ => None,
}
}
pub fn linear_keys(&self) -> Option<&[ValueKeyframe<T>]> {
match &self.keyframes {
Keyframes::Linear(keys) => Some(keys),
_ => None,
}
}
pub fn hermite_keys(&self) -> Option<&[TangentKeyframe<T>]> {
match &self.keyframes {
Keyframes::Hermite(keys) => Some(keys),
_ => None,
}
}
pub fn bezier_keys(&self) -> Option<&[TangentKeyframe<T>]> {
match &self.keyframes {
Keyframes::Bezier(keys) => Some(keys),
_ => None,
}
}
}
impl<T> Keyframes<T> {
fn into_sorted(mut self) -> Self {
match &mut self {
Self::Step(keys) | Self::Linear(keys) => keys.sort_by_key(Keyframe::frame),
Self::Hermite(keys) | Self::Bezier(keys) => keys.sort_by_key(Keyframe::frame),
}
self
}
fn len(&self) -> usize {
match self {
Self::Step(v) | Self::Linear(v) => v.len(),
Self::Hermite(v) | Self::Bezier(v) => v.len(),
}
}
fn interpolation(&self) -> u32 {
match self {
Self::Step(_) => 0,
Self::Linear(_) => 1,
Self::Hermite(_) => 2,
Self::Bezier(_) => 3,
}
}
}
impl<T: TrackValue> mdx::Read for Track<T> {
fn read_mdx(cursor: &mut Cursor<'_>) -> Result<Self, mdx::ReadError> {
let mut next = *cursor;
let offset = next.absolute_position();
let overflow = || mdx::ReadError::new(offset, mdx::ReadErrorKind::SizeOverflow);
let count = next.read::<u32>()? as usize;
let interpolation = next.read::<u32>()?;
if interpolation > 3 {
return Err(mdx::ReadError::new(
offset + 4,
mdx::ReadErrorKind::UnknownEnumValue {
enum_name: "Interpolation",
value: interpolation,
},
));
}
let sequence = next.read::<u32>()?;
let components = T::COMPONENTS;
let vector_count = if interpolation >= 2 { 3usize } else { 1usize };
let key_size = components
.checked_mul(vector_count)
.and_then(|n| n.checked_mul(4))
.and_then(|n| n.checked_add(4))
.ok_or_else(overflow)?;
let body_size = count.checked_mul(key_size).ok_or_else(overflow)?;
let mut body = next.subcursor(body_size)?;
let keyframes = match interpolation {
0 | 1 => {
let mut keys = Vec::with_capacity(count);
for _ in 0..count {
keys.push(body.read::<ValueKeyframe<T>>()?);
}
if interpolation == 0 {
Keyframes::Step(keys)
} else {
Keyframes::Linear(keys)
}
}
2 | 3 => {
let mut keys = Vec::with_capacity(count);
for _ in 0..count {
keys.push(body.read::<TangentKeyframe<T>>()?);
}
if interpolation == 2 {
Keyframes::Hermite(keys)
} else {
Keyframes::Bezier(keys)
}
}
_ => unreachable!(),
};
*cursor = next;
Ok(Self {
global_sequence_id: (sequence != u32::MAX).then_some(sequence),
keyframes: keyframes.into_sorted(),
})
}
}
impl<T: TrackValue> mdx::Write for Track<T> {
fn write_mdx(&self, encoder: &mut Encoder<'_>) -> Result<(), mdx::WriteError> {
encoder.write(&(self.keyframes.len() as u32))?;
encoder.write(&(self.keyframes.interpolation()))?;
encoder.write(&(self.global_sequence_id.unwrap_or(u32::MAX)))?;
match &self.keyframes {
Keyframes::Step(keys) | Keyframes::Linear(keys) => {
for key in keys {
encoder.write(key)?;
}
}
Keyframes::Hermite(keys) | Keyframes::Bezier(keys) => {
for key in keys {
encoder.write(key)?;
}
}
}
Ok(())
}
}
impl<T: TrackValue> mdl::Read for Track<T>
where
T: mdl::Read,
{
fn read_mdl(parser: &mut Parser<'_>) -> Result<Self, mdl::ReadError> {
parser.expect_ident("Track")?;
Self::read_mdl_payload(parser)
}
}
impl<T: TrackValue> Track<T>
where
T: mdl::Read,
{
pub fn read_mdl_named(
parser: &mut Parser<'_>,
name: &'static str,
) -> Result<Self, mdl::ReadError> {
parser.expect_ident(name)?;
Self::read_mdl_payload(parser)
}
pub fn read_mdl_payload(parser: &mut Parser<'_>) -> Result<Self, mdl::ReadError> {
let count = parser.read::<u32>()? as usize;
parser.expect(TokenKind::OpenBrace)?;
let mut interpolation = None;
let mut sequence = None;
while let Some(token) = parser.peek()? {
let TokenKind::Ident(name) = token.kind else {
break;
};
if name == "GlobalSeqId" {
parser.next_token()?;
if sequence.is_some() {
return Err(mdl::ReadError::new(
token.span,
mdl::ReadErrorKind::DuplicateField,
));
}
parser.peek()?;
let span = parser
.error(mdl::ReadErrorKind::InvalidNumber("global sequence ID"))
.span;
let id = parser.read_property::<u32>()?;
if id == u32::MAX {
return Err(mdl::ReadError::new(
span,
mdl::ReadErrorKind::InvalidNumber("global sequence ID"),
));
}
sequence = Some(id);
} else {
let mode = parser.read::<Interpolation>()?;
if interpolation.replace(mode).is_some() {
return Err(mdl::ReadError::new(
token.span,
mdl::ReadErrorKind::DuplicateField,
));
}
parser.expect(TokenKind::Comma)?;
}
}
let interpolation = interpolation
.ok_or_else(|| parser.error(mdl::ReadErrorKind::MissingField("interpolation")))?;
let mut values = Vec::new();
let mut tangents = Vec::new();
let mut actual = 0;
loop {
if let Some(token) = parser.peek()? {
if token.kind == TokenKind::CloseBrace {
if actual != count {
return Err(mdl::ReadError::new(
token.span,
mdl::ReadErrorKind::CountMismatch {
expected: count,
actual,
},
));
}
parser.next_token()?;
break;
}
}
if actual == count {
return Err(parser.error(mdl::ReadErrorKind::CountMismatch {
expected: count,
actual: actual + 1,
}));
}
let frame = parser.read::<i32>()?;
parser.expect(TokenKind::Colon)?;
let value = parser.read_property::<T>()?;
if matches!(
interpolation,
Interpolation::Hermite | Interpolation::Bezier
) {
parser.expect_ident("InTan")?;
let in_tangent = parser.read_property()?;
parser.expect_ident("OutTan")?;
let out_tangent = parser.read_property()?;
tangents.push(TangentKeyframe {
frame,
value,
in_tangent,
out_tangent,
});
} else {
values.push(ValueKeyframe { frame, value });
}
actual += 1;
}
let keyframes = match interpolation {
Interpolation::Step => Keyframes::Step(values),
Interpolation::Linear => Keyframes::Linear(values),
Interpolation::Hermite => Keyframes::Hermite(tangents),
Interpolation::Bezier => Keyframes::Bezier(tangents),
};
Ok(Self {
global_sequence_id: sequence,
keyframes: keyframes.into_sorted(),
})
}
}
impl<T: TrackValue> mdl::Write for Track<T>
where
T: mdl::Write,
{
fn write_mdl<W: IoWrite>(
&self,
writer: &mut Writer<W>,
) -> Result<(), IoError<mdl::WriteError>> {
self.write_mdl_named(writer, "Track")
}
}
impl<T: TrackValue> Track<T>
where
T: mdl::Write,
{
pub fn write_mdl_named<W: IoWrite>(
&self,
writer: &mut Writer<W>,
name: &str,
) -> Result<(), IoError<mdl::WriteError>> {
writer.begin_counted_block(name, self.keyframes.len())?;
writer.indent()?;
writer.write(&self.interpolation())?;
writer.raw(",\n")?;
if let Some(sequence) = self.global_sequence_id {
writer.property("GlobalSeqId", &sequence)?;
}
match &self.keyframes {
Keyframes::Step(keys) | Keyframes::Linear(keys) => {
for key in keys {
write_key(writer, key.frame, &key.value)?;
}
}
Keyframes::Hermite(keys) | Keyframes::Bezier(keys) => {
for key in keys {
write_key(writer, key.frame, &key.value)?;
write_tangent(writer, "InTan", &key.in_tangent)?;
write_tangent(writer, "OutTan", &key.out_tangent)?;
}
}
}
writer.end_block()
}
}
fn write_key<W: IoWrite, T: mdl::Write>(
writer: &mut Writer<W>,
frame: i32,
value: &T,
) -> Result<(), IoError<mdl::WriteError>> {
writer.indent()?;
writer.write(&frame)?;
writer.raw(": ")?;
writer.write(value)?;
writer.raw(",\n")
}
fn write_tangent<W: IoWrite, T: mdl::Write>(
writer: &mut Writer<W>,
name: &str,
value: &T,
) -> Result<(), IoError<mdl::WriteError>> {
writer.indent()?;
writer.raw("\t")?;
writer.identifier(name)?;
writer.raw(" ")?;
writer.write(value)?;
writer.raw(",\n")
}
impl<T: TrackValue> Track<T> {
pub fn key_frame_at_or_before(&self, time_ms: f64) -> Option<i32> {
self.key_frame_at_or_before_in(time_ms, i32::MIN..=i32::MAX)
}
pub fn key_frame_at_or_before_in(
&self,
time_ms: f64,
interval: RangeInclusive<i32>,
) -> Option<i32> {
if !time_ms.is_finite() || interval.is_empty() {
return None;
}
match &self.keyframes {
Keyframes::Step(keys) | Keyframes::Linear(keys) => {
latest_frame(keys, time_ms, &interval)
}
Keyframes::Hermite(keys) | Keyframes::Bezier(keys) => {
latest_frame(keys, time_ms, &interval)
}
}
}
}
fn latest_frame<K: Keyframe>(
keys: &[K],
time_ms: f64,
interval: &RangeInclusive<i32>,
) -> Option<i32> {
let keys = keys_in(keys, interval);
let end = keys.partition_point(|key| f64::from(key.frame()) <= time_ms);
end.checked_sub(1).map(|index| keys[index].frame())
}
impl<T: Interpolate> Track<T> {
pub fn sample(&self, time: &AnimationTime<'_>) -> Option<T> {
let (time_ms, interval) = time.track_time(self)?;
self.evaluate_in(time_ms, interval)
}
pub fn evaluate(&self, time_ms: f64) -> Option<T> {
self.evaluate_in(time_ms, i32::MIN..=i32::MAX)
}
pub fn evaluate_in(&self, time_ms: f64, interval: RangeInclusive<i32>) -> Option<T> {
if !time_ms.is_finite() || interval.is_empty() {
return None;
}
match &self.keyframes {
Keyframes::Step(keys) | Keyframes::Linear(keys) => {
let (a, b) = surrounding(keys, time_ms, &interval)?;
if a.frame == b.frame || matches!(self.keyframes, Keyframes::Step(_)) {
return Some(a.value);
}
let t = ((time_ms - f64::from(a.frame)) / (f64::from(b.frame) - f64::from(a.frame)))
as f32;
Some(T::linear(a.value, b.value, t))
}
Keyframes::Hermite(keys) | Keyframes::Bezier(keys) => {
let (a, b) = surrounding(keys, time_ms, &interval)?;
if a.frame == b.frame {
return Some(a.value);
}
let t = ((time_ms - f64::from(a.frame)) / (f64::from(b.frame) - f64::from(a.frame)))
as f32;
Some(if matches!(self.keyframes, Keyframes::Hermite(_)) {
T::hermite(a.value, a.out_tangent, b.in_tangent, b.value, t)
} else {
T::bezier(a.value, a.out_tangent, b.in_tangent, b.value, t)
})
}
}
}
}
fn surrounding<'a, K: Keyframe>(
keys: &'a [K],
time: f64,
interval: &RangeInclusive<i32>,
) -> Option<(&'a K, &'a K)> {
let keys = keys_in(keys, interval);
let end = keys.partition_point(|key| f64::from(key.frame()) <= time);
let left = end.checked_sub(1).map(|index| &keys[index]);
let right = if left.is_some_and(|key| f64::from(key.frame()) == time) {
left
} else {
keys.get(end).map(|first| {
let after = keys.partition_point(|key| key.frame() <= first.frame());
&keys[after - 1]
})
};
Some((left.or(right)?, right.or(left)?))
}
fn keys_in<'a, K: Keyframe>(keys: &'a [K], interval: &RangeInclusive<i32>) -> &'a [K] {
let start = keys.partition_point(|key| key.frame() < *interval.start());
let end = keys.partition_point(|key| key.frame() <= *interval.end());
&keys[start..end]
}
#[cfg(test)]
mod key_lookup_tests {
use super::*;
#[test]
fn lookup_respects_time_and_sequence_for_unordered_keys() {
let track = Track::step(
vec![
ValueKeyframe {
frame: 200,
value: 1.0,
},
ValueKeyframe {
frame: 50,
value: 2.0,
},
ValueKeyframe {
frame: 150,
value: 3.0,
},
],
None,
)
.unwrap();
assert_eq!(track.key_frame_at_or_before(175.0), Some(150));
assert_eq!(track.key_frame_at_or_before(25.0), None);
assert_eq!(track.key_frame_at_or_before_in(125.0, 100..=200), None);
assert_eq!(track.key_frame_at_or_before_in(250.0, 100..=175), Some(150));
assert_eq!(track.key_frame_at_or_before(f64::NAN), None);
}
}