use std::sync::Arc;
use glam::{Mat4, Quat, Vec3};
use crate::evaluated_material::{EvaluatedMaterial, evaluate_materials};
use crate::expressions::{MaterialColorUpdate, MorphTargetUpdate, TextureTransformUpdate};
use crate::instance::{AvatarInstance, BoneUpdate};
use crate::render::{self, CpuMesh};
use crate::spring_bone::SpringBoneSimulator;
use crate::{
Avatar, CameraMode, HumanBone, MaterialId, NodeId, PrimitiveId, RenderPrimitive, SkinId,
VrmAnimation,
};
#[derive(Debug, thiserror::Error, PartialEq)]
pub enum ControlError {
#[error("unknown expression `{0}`")]
UnknownExpression(String),
#[error("humanoid bone `{0:?}` is not mapped by this asset")]
MissingBone(HumanBone),
#[error("{field} must contain only finite values")]
NonFinite {
field: &'static str,
},
#[error("invalid animation: {0}")]
InvalidAnimation(String),
}
#[derive(Debug, thiserror::Error, PartialEq)]
pub enum RuntimeError {
#[error("delta time must be finite and non-negative")]
InvalidDeltaTime,
#[error("material time would become non-finite")]
MaterialTimeOverflow,
#[error("animation time would become non-finite")]
AnimationTimeOverflow,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RuntimeOptions {
pub enable_constraints: bool,
pub enable_spring_bone: bool,
}
impl Default for RuntimeOptions {
fn default() -> Self {
Self {
enable_constraints: true,
enable_spring_bone: true,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum PlaybackMode {
Once,
#[default]
Loop,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct PlaybackOptions {
pub speed: f32,
pub mode: PlaybackMode,
pub scale_hips_translation: bool,
}
impl Default for PlaybackOptions {
fn default() -> Self {
Self {
speed: 1.0,
mode: PlaybackMode::Loop,
scale_hips_translation: true,
}
}
}
struct AnimationState {
clip: Arc<VrmAnimation>,
time: f32,
speed: f32,
mode: PlaybackMode,
scale_hips_translation: bool,
playing: bool,
}
#[derive(Debug, Clone, PartialEq)]
pub struct SkinningPalette {
pub skin_id: SkinId,
pub joint_matrices: Vec<Mat4>,
}
#[derive(Debug, Clone, Default)]
struct FrameState {
world_matrices: Vec<Mat4>,
skinning_palettes: Vec<SkinningPalette>,
morph_weights: Vec<Vec<f32>>,
morph_updates: Vec<MorphTargetUpdate>,
material_color_updates: Vec<MaterialColorUpdate>,
texture_transform_updates: Vec<TextureTransformUpdate>,
evaluated_materials: Vec<EvaluatedMaterial>,
bone_updates: Vec<BoneUpdate>,
}
impl FrameState {
fn rest(asset: &Avatar) -> Self {
let bone_updates = Vec::new();
let world_matrices = asset.compute_world_matrices(&bone_updates);
let skinning_palettes = asset
.skins()
.iter()
.enumerate()
.map(|(skin_index, skin)| SkinningPalette {
skin_id: SkinId::from_index(skin_index),
joint_matrices: asset.compute_joint_matrices(skin, &bone_updates),
})
.collect();
let morph_weights = asset
.primitives()
.iter()
.map(|primitive| vec![0.0; primitive.morph_targets().len()])
.collect();
let evaluated_materials = evaluate_materials(asset, &[], &[], 0.0);
Self {
world_matrices,
skinning_palettes,
morph_weights,
evaluated_materials,
..Self::default()
}
}
}
pub struct AvatarRuntime {
asset: Arc<Avatar>,
instance: AvatarInstance,
spring_simulator: SpringBoneSimulator,
options: RuntimeOptions,
animation: Option<AnimationState>,
material_time: f32,
frame: FrameState,
}
impl AvatarRuntime {
pub fn new(asset: impl Into<Arc<Avatar>>) -> Self {
let asset = asset.into();
let frame = FrameState::rest(&asset);
Self {
asset,
instance: AvatarInstance::default(),
spring_simulator: SpringBoneSimulator::new(),
options: RuntimeOptions::default(),
animation: None,
material_time: 0.0,
frame,
}
}
pub fn asset(&self) -> &Avatar {
&self.asset
}
pub fn shared_asset(&self) -> Arc<Avatar> {
Arc::clone(&self.asset)
}
pub fn options(&self) -> RuntimeOptions {
self.options
}
pub fn set_constraints_enabled(&mut self, enabled: bool) {
self.options.enable_constraints = enabled;
}
pub fn set_spring_bone_enabled(&mut self, enabled: bool) {
self.options.enable_spring_bone = enabled;
}
pub fn set_expression(&mut self, name: &str, weight: f32) -> Result<(), ControlError> {
if !weight.is_finite() {
return Err(ControlError::NonFinite {
field: "expression weight",
});
}
if self.asset.expressions().get(name).is_none() {
return Err(ControlError::UnknownExpression(name.to_string()));
}
self.instance.set_expression(name, weight);
Ok(())
}
pub fn clear_expression(&mut self, name: &str) -> Result<(), ControlError> {
if self.asset.expressions().get(name).is_none() {
return Err(ControlError::UnknownExpression(name.to_string()));
}
self.instance.clear_expression(name);
Ok(())
}
pub fn clear_expressions(&mut self) {
self.instance.clear_expressions();
}
pub fn expression_weight(&self, name: &str) -> Result<f32, ControlError> {
if self.asset.expressions().get(name).is_none() {
return Err(ControlError::UnknownExpression(name.to_string()));
}
Ok(self.instance.expression_weight(name))
}
pub fn set_bone_rotation(
&mut self,
bone: HumanBone,
rotation: Quat,
) -> Result<(), ControlError> {
if !rotation.is_finite() {
return Err(ControlError::NonFinite {
field: "bone rotation",
});
}
if self.asset.humanoid().bone(bone).is_none() {
return Err(ControlError::MissingBone(bone));
}
let normalized = if rotation.length_squared() > f32::EPSILON {
rotation.normalize()
} else {
Quat::IDENTITY
};
self.instance.set_bone_rotation(bone, normalized);
Ok(())
}
pub fn clear_bone_rotation(&mut self, bone: HumanBone) -> Result<(), ControlError> {
if self.asset.humanoid().bone(bone).is_none() {
return Err(ControlError::MissingBone(bone));
}
self.instance.clear_bone_rotation(bone);
Ok(())
}
pub fn clear_bone_rotations(&mut self) {
self.instance.clear_bone_rotations();
}
pub fn set_bone_translation(
&mut self,
bone: HumanBone,
translation: Vec3,
) -> Result<(), ControlError> {
if !translation.is_finite() {
return Err(ControlError::NonFinite {
field: "bone translation",
});
}
if self.asset.humanoid().bone(bone).is_none() {
return Err(ControlError::MissingBone(bone));
}
self.instance.set_bone_translation(bone, translation);
Ok(())
}
pub fn clear_bone_translation(&mut self, bone: HumanBone) -> Result<(), ControlError> {
if self.asset.humanoid().bone(bone).is_none() {
return Err(ControlError::MissingBone(bone));
}
self.instance.clear_bone_translation(bone);
Ok(())
}
pub fn clear_bone_translations(&mut self) {
self.instance.clear_bone_translations();
}
pub fn set_look_at_target(&mut self, target: Option<Vec3>) -> Result<(), ControlError> {
if target.is_some_and(|target| !target.is_finite()) {
return Err(ControlError::NonFinite {
field: "look-at target",
});
}
self.instance.set_look_at_target(target);
Ok(())
}
pub fn clear_look_at_target(&mut self) {
self.instance.set_look_at_target(None);
}
pub fn play(
&mut self,
clip: impl Into<Arc<VrmAnimation>>,
options: PlaybackOptions,
) -> Result<(), ControlError> {
let clip = clip.into();
clip.validate().map_err(ControlError::InvalidAnimation)?;
if !options.speed.is_finite() || options.speed < 0.0 {
return Err(ControlError::InvalidAnimation(
"playback speed must be finite and non-negative".to_string(),
));
}
self.animation = Some(AnimationState {
clip,
time: 0.0,
speed: options.speed,
mode: options.mode,
scale_hips_translation: options.scale_hips_translation,
playing: true,
});
Ok(())
}
pub fn pause(&mut self) {
if let Some(animation) = &mut self.animation {
animation.playing = false;
}
}
pub fn resume(&mut self) {
if let Some(animation) = &mut self.animation {
animation.playing = true;
}
}
pub fn set_playback_speed(&mut self, speed: f32) -> Result<(), ControlError> {
if !speed.is_finite() || speed < 0.0 {
return Err(ControlError::InvalidAnimation(
"playback speed must be finite and non-negative".to_string(),
));
}
if let Some(animation) = &mut self.animation {
animation.speed = speed;
}
Ok(())
}
pub fn seek(&mut self, time: f32) -> Result<(), ControlError> {
if !time.is_finite() || time < 0.0 {
return Err(ControlError::NonFinite {
field: "animation time",
});
}
if let Some(animation) = &mut self.animation {
animation.time = time.min(animation.clip.duration().max(0.0));
}
Ok(())
}
pub fn stop(&mut self) {
self.animation = None;
}
pub fn playback_time(&self) -> Option<f32> {
self.animation.as_ref().map(|animation| animation.time)
}
pub fn is_playing(&self) -> bool {
self.animation
.as_ref()
.is_some_and(|animation| animation.playing)
}
pub fn update(&mut self, dt: f32) -> Result<FrameView<'_>, RuntimeError> {
if !dt.is_finite() || dt < 0.0 {
return Err(RuntimeError::InvalidDeltaTime);
}
let next_material_time = self.material_time + dt;
if !next_material_time.is_finite() {
return Err(RuntimeError::MaterialTimeOverflow);
}
let next_animation_time = if let Some(animation) = &self.animation
&& animation.playing
{
let advance = dt * animation.speed;
let next_time = animation.time + advance;
if !advance.is_finite() || !next_time.is_finite() {
return Err(RuntimeError::AnimationTimeOverflow);
}
Some(next_time)
} else {
None
};
self.material_time = next_material_time;
if let Some(animation) = &mut self.animation
&& let Some(next_time) = next_animation_time
{
animation.time = next_time;
if animation.clip.duration() <= 0.0 {
animation.time = 0.0;
if animation.mode == PlaybackMode::Once {
animation.playing = false;
}
} else if animation.time >= animation.clip.duration() {
match animation.mode {
PlaybackMode::Loop => animation.time %= animation.clip.duration(),
PlaybackMode::Once => {
animation.time = animation.clip.duration();
animation.playing = false;
}
}
}
}
let mut frame_instance = AvatarInstance::default();
if let Some(animation) = &self.animation {
frame_instance.apply_animation_with_options(
&animation.clip,
animation.time,
&self.asset,
animation.scale_hips_translation,
);
}
frame_instance.overlay(&self.instance);
let evaluation = frame_instance.evaluate(&self.asset);
let mut bone_updates = evaluation.bone_updates;
if self.options.enable_constraints {
let world = self.asset.compute_world_matrices(&bone_updates);
bone_updates.extend(crate::constraint::solve_constraints(&self.asset, &world));
}
if self.options.enable_spring_bone {
let world = self.asset.compute_world_matrices(&bone_updates);
bone_updates.extend(self.spring_simulator.update(&self.asset, &world, dt));
}
let world_matrices = self.asset.compute_world_matrices(&bone_updates);
let skinning_palettes = self
.asset
.skins()
.iter()
.enumerate()
.map(|(skin_index, skin)| SkinningPalette {
skin_id: SkinId::from_index(skin_index),
joint_matrices: self.asset.compute_joint_matrices(skin, &bone_updates),
})
.collect();
let mut morph_weights: Vec<Vec<f32>> = self
.asset
.primitives()
.iter()
.map(|primitive| vec![0.0; primitive.morph_targets().len()])
.collect();
for update in &evaluation.morph_updates {
for (primitive_index, primitive) in self.asset.primitives().iter().enumerate() {
if primitive.node_index() != update.node_index() {
continue;
}
if let Some(weight) =
morph_weights[primitive_index].get_mut(update.target_index() as usize)
{
*weight = update.weight();
}
}
}
let evaluated_materials = evaluate_materials(
&self.asset,
&evaluation.material_color_updates,
&evaluation.texture_transform_updates,
self.material_time,
);
self.frame = FrameState {
world_matrices,
skinning_palettes,
morph_weights,
morph_updates: evaluation.morph_updates,
material_color_updates: evaluation.material_color_updates,
texture_transform_updates: evaluation.texture_transform_updates,
evaluated_materials,
bone_updates,
};
Ok(FrameView {
asset: &self.asset,
state: &self.frame,
})
}
pub fn reset(&mut self) {
self.instance = AvatarInstance::default();
self.spring_simulator.reset();
self.animation = None;
self.material_time = 0.0;
self.frame = FrameState::rest(&self.asset);
}
pub fn instance_mut(&mut self) -> &mut AvatarInstance {
&mut self.instance
}
pub fn spring_simulator_mut(&mut self) -> &mut SpringBoneSimulator {
&mut self.spring_simulator
}
}
#[derive(Clone, Copy)]
pub struct FrameView<'a> {
asset: &'a Arc<Avatar>,
state: &'a FrameState,
}
impl<'a> FrameView<'a> {
pub fn gpu(self) -> GpuFrameView<'a> {
GpuFrameView {
asset: self.asset.as_ref(),
state: self.state,
}
}
pub fn bake_cpu(self) -> Vec<CpuMesh> {
render::bake_frame(
self.asset,
&self.state.world_matrices,
&self.state.skinning_palettes,
&self.state.morph_weights,
)
}
pub fn bake_cpu_for(self, camera: CameraMode) -> Vec<CpuMesh> {
apply_camera_visibility(self.asset, self.bake_cpu(), camera)
}
pub fn to_owned(self) -> FrameSnapshot {
FrameSnapshot {
asset: Arc::clone(self.asset),
state: self.state.clone(),
}
}
pub fn world_matrices(self) -> &'a [Mat4] {
&self.state.world_matrices
}
pub fn skinning_palettes(self) -> &'a [SkinningPalette] {
&self.state.skinning_palettes
}
pub fn morph_updates(self) -> &'a [MorphTargetUpdate] {
&self.state.morph_updates
}
pub fn material_color_updates(self) -> &'a [MaterialColorUpdate] {
&self.state.material_color_updates
}
pub fn texture_transform_updates(self) -> &'a [TextureTransformUpdate] {
&self.state.texture_transform_updates
}
pub fn evaluated_materials(self) -> &'a [EvaluatedMaterial] {
&self.state.evaluated_materials
}
pub fn evaluated_material(self, id: MaterialId) -> Option<&'a EvaluatedMaterial> {
self.state.evaluated_materials.get(id.index())
}
pub fn bone_updates(self) -> &'a [BoneUpdate] {
&self.state.bone_updates
}
}
#[derive(Debug, Clone)]
pub struct FrameSnapshot {
asset: Arc<Avatar>,
state: FrameState,
}
impl FrameSnapshot {
pub fn gpu(&self) -> GpuFrameView<'_> {
GpuFrameView {
asset: &self.asset,
state: &self.state,
}
}
pub fn bake_cpu(&self) -> Vec<CpuMesh> {
render::bake_frame(
&self.asset,
&self.state.world_matrices,
&self.state.skinning_palettes,
&self.state.morph_weights,
)
}
pub fn bake_cpu_for(&self, camera: CameraMode) -> Vec<CpuMesh> {
apply_camera_visibility(&self.asset, self.bake_cpu(), camera)
}
pub fn world_matrices(&self) -> &[Mat4] {
&self.state.world_matrices
}
pub fn skinning_palettes(&self) -> &[SkinningPalette] {
&self.state.skinning_palettes
}
pub fn morph_updates(&self) -> &[MorphTargetUpdate] {
&self.state.morph_updates
}
pub fn material_color_updates(&self) -> &[MaterialColorUpdate] {
&self.state.material_color_updates
}
pub fn texture_transform_updates(&self) -> &[TextureTransformUpdate] {
&self.state.texture_transform_updates
}
pub fn evaluated_materials(&self) -> &[EvaluatedMaterial] {
&self.state.evaluated_materials
}
pub fn evaluated_material(&self, id: MaterialId) -> Option<&EvaluatedMaterial> {
self.state.evaluated_materials.get(id.index())
}
pub fn bone_updates(&self) -> &[BoneUpdate] {
&self.state.bone_updates
}
}
#[derive(Clone, Copy)]
pub struct GpuFrameView<'a> {
asset: &'a Avatar,
state: &'a FrameState,
}
impl<'a> GpuFrameView<'a> {
pub fn draws(self) -> impl ExactSizeIterator<Item = GpuDraw<'a>> + 'a {
self.asset
.primitives()
.iter()
.enumerate()
.map(move |(primitive_index, primitive)| {
let skin_id = primitive.skin_index().map(SkinId::from_index);
let material_id = primitive.material_index().map(MaterialId::from_index);
let joint_matrices = skin_id
.and_then(|skin_id| self.state.skinning_palettes.get(skin_id.index()))
.map(|palette| palette.joint_matrices.as_slice())
.unwrap_or(&[]);
GpuDraw {
asset: self.asset,
primitive_id: PrimitiveId::from_index(primitive_index),
node_id: NodeId::from_index(primitive.node_index() as usize),
material_id,
evaluated_material: material_id
.and_then(|id| self.state.evaluated_materials.get(id.index())),
skin_id,
primitive,
world_matrix: self
.state
.world_matrices
.get(primitive.node_index() as usize)
.copied()
.unwrap_or(Mat4::IDENTITY),
morph_weights: self
.state
.morph_weights
.get(primitive_index)
.map(Vec::as_slice)
.unwrap_or(&[]),
joint_matrices,
}
})
}
}
pub struct GpuDraw<'a> {
asset: &'a Avatar,
pub primitive_id: PrimitiveId,
pub node_id: NodeId,
pub material_id: Option<MaterialId>,
pub evaluated_material: Option<&'a EvaluatedMaterial>,
pub skin_id: Option<SkinId>,
pub primitive: &'a RenderPrimitive,
pub world_matrix: Mat4,
pub morph_weights: &'a [f32],
pub joint_matrices: &'a [Mat4],
}
impl<'a> GpuDraw<'a> {
pub fn indices(&self, camera: CameraMode) -> std::borrow::Cow<'a, [u32]> {
self.asset
.first_person()
.visible_indices(self.asset, self.primitive, camera)
}
}
fn apply_camera_visibility(
asset: &Avatar,
meshes: Vec<CpuMesh>,
camera: CameraMode,
) -> Vec<CpuMesh> {
meshes
.into_iter()
.enumerate()
.filter_map(|(index, mut mesh)| {
let primitive = asset.primitives().get(index)?;
mesh.indices = asset
.first_person()
.visible_indices(asset, primitive, camera)
.into_owned();
(!mesh.indices.is_empty()).then_some(mesh)
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::primitive::{PrimitiveTopology, RenderPrimitive};
use crate::{
Avatar, AvatarNode, BoneTrack, Expression, Expressions, Humanoid, Interpolation, Keyframe,
Material, MaterialColorBind, MaterialColorType, MorphTarget, MorphTargetBind,
TextureTransformBind, Track, Transform,
};
fn test_asset() -> Avatar {
let expression =
Expression::new("happy").with_morph_target_binds(vec![MorphTargetBind::new(0, 0, 1.0)]);
let primitive = RenderPrimitive::new(
0,
Transform::IDENTITY,
vec![[0.0, 0.0, 0.0]],
vec![[0.0, 0.0, 1.0]],
vec![0],
vec![[0; 4]],
vec![[0.0; 4]],
vec![MorphTarget::new(vec![[1.0, 0.0, 0.0]], None, None)],
vec![[0.0, 0.0]],
vec![[1.0, 0.0, 0.0, 1.0]],
vec![[1.0; 4]],
vec![[0.0, 0.0]],
None,
None,
PrimitiveTopology::Triangles,
vec![0.75],
false,
None,
0,
);
Avatar::new()
.with_expressions(Expressions::new(vec![expression]))
.with_primitives(vec![primitive])
}
#[test]
fn expression_controls_persist_between_updates() {
let mut runtime = AvatarRuntime::new(test_asset());
runtime.set_constraints_enabled(false);
runtime.set_spring_bone_enabled(false);
runtime.set_expression("happy", 0.5).unwrap();
let first = runtime.update(0.016).unwrap().gpu().draws().next().unwrap();
assert_eq!(first.morph_weights, &[0.5]);
let second = runtime.update(0.016).unwrap().gpu().draws().next().unwrap();
assert_eq!(second.morph_weights, &[0.5]);
}
#[test]
fn expression_morphs_start_at_zero_instead_of_gltf_weights() {
let mut runtime = AvatarRuntime::new(test_asset());
runtime.set_constraints_enabled(false);
runtime.set_spring_bone_enabled(false);
runtime.set_expression("happy", 0.25).unwrap();
let draw = runtime.update(0.0).unwrap().gpu().draws().next().unwrap();
assert_eq!(draw.morph_weights, &[0.25]);
}
#[test]
fn frame_exposes_expression_evaluated_material_values() {
let expression = Expression::new("happy")
.with_material_color_binds(vec![MaterialColorBind {
material_index: 0,
color_type: MaterialColorType::Color,
target_value: [1.0, 0.0, 0.0, 0.5],
}])
.with_texture_transform_binds(vec![TextureTransformBind {
material_index: 0,
scale: [2.0, 3.0],
offset: [0.25, 0.5],
}]);
let mut material = Material::default();
material.base_color_factor = [0.2, 0.4, 0.6, 1.0];
let mut asset = Avatar::new().with_expressions(Expressions::new(vec![expression]));
asset.materials = vec![material];
let mut runtime = AvatarRuntime::new(asset);
runtime.set_expression("happy", 0.5).unwrap();
let frame = runtime.update(0.0).unwrap();
let evaluated = &frame.evaluated_materials()[0];
assert_eq!(evaluated.material_id, MaterialId::from_index(0));
assert_eq!(evaluated.base_color_factor, [0.6, 0.2, 0.3, 0.75]);
assert_eq!(evaluated.texture_transform.scale, [1.5, 2.0]);
assert_eq!(evaluated.texture_transform.offset, [0.125, 0.25]);
}
#[test]
fn cpu_and_gpu_paths_use_the_same_morph_weights() {
let mut runtime = AvatarRuntime::new(test_asset());
runtime.set_constraints_enabled(false);
runtime.set_spring_bone_enabled(false);
runtime.set_expression("happy", 1.0).unwrap();
let frame = runtime.update(0.0).unwrap();
let draw = frame.gpu().draws().next().unwrap();
let mesh = frame.bake_cpu().pop().unwrap();
assert_eq!(draw.morph_weights, &[1.0]);
assert_eq!(mesh.positions[0], [1.0, 0.0, 0.0]);
}
#[test]
fn reset_clears_controls_and_cached_morphs() {
let mut runtime = AvatarRuntime::new(test_asset());
runtime.set_expression("happy", 1.0).unwrap();
runtime.update(0.0).unwrap();
runtime.reset();
assert_eq!(runtime.expression_weight("happy").unwrap(), 0.0);
let draw = runtime.update(0.0).unwrap().gpu().draws().next().unwrap();
assert_eq!(draw.morph_weights, &[0.0]);
}
#[test]
fn shared_asset_does_not_share_instance_state() {
let asset = Arc::new(test_asset());
let mut first = AvatarRuntime::new(Arc::clone(&asset));
let mut second = AvatarRuntime::new(asset);
first.set_expression("happy", 1.0).unwrap();
let first_weight = first
.update(0.0)
.unwrap()
.gpu()
.draws()
.next()
.unwrap()
.morph_weights[0];
let second_weight = second
.update(0.0)
.unwrap()
.gpu()
.draws()
.next()
.unwrap()
.morph_weights[0];
assert_eq!(first_weight, 1.0);
assert_eq!(second_weight, 0.0);
}
#[test]
fn rejects_invalid_runtime_inputs() {
let mut runtime = AvatarRuntime::new(test_asset());
assert!(matches!(
runtime.set_expression("missing", 1.0),
Err(ControlError::UnknownExpression(_))
));
assert_eq!(
runtime.update(f32::NAN).err(),
Some(RuntimeError::InvalidDeltaTime)
);
}
#[test]
fn rejects_material_clock_overflow_without_mutating_time() {
let mut runtime = AvatarRuntime::new(test_asset());
runtime.set_constraints_enabled(false);
runtime.set_spring_bone_enabled(false);
runtime.update(f32::MAX).unwrap();
let material_time_before_error = runtime.material_time;
assert_eq!(
runtime.update(f32::MAX).err(),
Some(RuntimeError::MaterialTimeOverflow)
);
assert_eq!(runtime.material_time, material_time_before_error);
assert!(runtime.material_time.is_finite());
}
#[test]
fn rejects_animation_step_overflow_without_mutating_any_clock() {
let mut runtime = AvatarRuntime::new(test_asset());
runtime.set_constraints_enabled(false);
runtime.set_spring_bone_enabled(false);
runtime
.play(
VrmAnimation::new(f32::MAX),
PlaybackOptions {
speed: f32::MAX,
..PlaybackOptions::default()
},
)
.unwrap();
assert_eq!(
runtime.update(2.0).err(),
Some(RuntimeError::AnimationTimeOverflow)
);
assert_eq!(runtime.playback_time(), Some(0.0));
assert_eq!(runtime.material_time, 0.0);
}
#[test]
fn update_advances_animation_before_producing_the_frame() {
let asset = Avatar::new()
.with_humanoid(Humanoid::default().with_bone(HumanBone::Hips, 0))
.with_nodes(vec![AvatarNode {
index: 0,
name: Some("hips".to_string()),
parent: None,
children: vec![],
initial_translation: Vec3::ZERO,
initial_rotation: Quat::IDENTITY,
initial_scale: Vec3::ONE,
}]);
let clip = VrmAnimation::new(1.0).with_bone_track(
HumanBone::Hips,
BoneTrack::new().with_translation(Track::new(
Interpolation::Linear,
vec![
Keyframe::new(0.0, Vec3::ZERO),
Keyframe::new(1.0, Vec3::new(2.0, 0.0, 0.0)),
],
)),
);
let mut runtime = AvatarRuntime::new(asset);
runtime.set_constraints_enabled(false);
runtime.set_spring_bone_enabled(false);
runtime
.play(
clip,
PlaybackOptions {
speed: 1.0,
mode: PlaybackMode::Once,
..PlaybackOptions::default()
},
)
.unwrap();
let frame = runtime.update(0.5).unwrap();
let translation = frame.world_matrices()[0].transform_point3(Vec3::ZERO);
assert!(translation.abs_diff_eq(Vec3::new(1.0, 0.0, 0.0), 1.0e-5));
assert_eq!(runtime.playback_time(), Some(0.5));
assert!(runtime.is_playing());
}
#[test]
fn play_rejects_malformed_keyframes() {
let clip = VrmAnimation::new(1.0).with_bone_track(
HumanBone::Hips,
BoneTrack::new().with_rotation(Track::new(
Interpolation::Linear,
vec![Keyframe::new(f32::NAN, Quat::IDENTITY)],
)),
);
let mut runtime = AvatarRuntime::new(test_asset());
assert!(matches!(
runtime.play(clip, PlaybackOptions::default()),
Err(ControlError::InvalidAnimation(_))
));
}
}