From 9e0582cbd596bd4193c113df0cc4f6de67e5a034 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sat, 7 Nov 2020 17:22:25 -0300
Subject: [PATCH 001/153] skinned mesh import + basic startup system

---
 Cargo.toml                          |   2 +
 crates/bevy_core/src/lib.rs         |   6 +-
 crates/bevy_core/src/name.rs        |  22 +++
 crates/bevy_gltf/Cargo.toml         |   6 +-
 crates/bevy_gltf/src/loader.rs      | 213 ++++++++++++++++++++--------
 crates/bevy_render/src/mesh/mesh.rs |  10 ++
 crates/bevy_skinned_mesh/Cargo.toml |  22 +++
 crates/bevy_skinned_mesh/src/lib.rs | 163 +++++++++++++++++++++
 src/default_plugins.rs              |   5 +-
 9 files changed, 388 insertions(+), 61 deletions(-)
 create mode 100644 crates/bevy_core/src/name.rs
 create mode 100644 crates/bevy_skinned_mesh/Cargo.toml
 create mode 100644 crates/bevy_skinned_mesh/src/lib.rs

diff --git a/Cargo.toml b/Cargo.toml
index 8d18c2969c90a..3e78d2b2daf28 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,6 +21,7 @@ default = [
     "bevy_dynamic_plugin",
     "bevy_gilrs",
     "bevy_gltf",
+    "bevy_skinned_mesh",
     "bevy_wgpu",
     "bevy_winit",
     "render",
@@ -74,6 +75,7 @@ bevy_tasks = { path = "crates/bevy_tasks", version = "0.3.0" }
 # bevy (optional)
 bevy_audio = { path = "crates/bevy_audio", optional = true, version = "0.3.0" }
 bevy_gltf = { path = "crates/bevy_gltf", optional = true, version = "0.3.0" }
+bevy_skinned_mesh = { path = "crates/bevy_skinned_mesh", optional = true, version = "0.3.0" }
 bevy_pbr = { path = "crates/bevy_pbr", optional = true, version = "0.3.0" }
 bevy_render = { path = "crates/bevy_render", optional = true, version = "0.3.0" }
 bevy_dynamic_plugin = { path = "crates/bevy_dynamic_plugin", optional = true, version = "0.3.0" }
diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index be901f68140a0..de31cb51f58d1 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -1,17 +1,19 @@
 mod bytes;
 mod float_ord;
 mod label;
+mod name;
 mod task_pool_options;
 mod time;
 
 pub use bytes::*;
 pub use float_ord::*;
 pub use label::*;
+pub use name::*;
 pub use task_pool_options::DefaultTaskPoolOptions;
 pub use time::*;
 
 pub mod prelude {
-    pub use crate::{DefaultTaskPoolOptions, EntityLabels, Labels, Time, Timer};
+    pub use crate::{DefaultTaskPoolOptions, EntityLabels, Labels, Name, Time, Timer};
 }
 
 use bevy_app::prelude::*;
@@ -33,7 +35,9 @@ impl Plugin for CorePlugin {
 
         app.init_resource::<Time>()
             .init_resource::<EntityLabels>()
+            .register_component::<Name>()
             .register_component::<Timer>()
+            .register_component::<Labels>()
             .register_property::<Vec2>()
             .register_property::<Vec3>()
             .register_property::<Mat3>()
diff --git a/crates/bevy_core/src/name.rs b/crates/bevy_core/src/name.rs
new file mode 100644
index 0000000000000..0f6721ad910c9
--- /dev/null
+++ b/crates/bevy_core/src/name.rs
@@ -0,0 +1,22 @@
+use bevy_property::Properties;
+use std::ops::{Deref, DerefMut};
+
+// NOTE: This is used by the animation system to find the right entity to animate
+
+/// Component containing the name used to uniquely identify a entity
+#[derive(Default, Debug, Properties)]
+pub struct Name(pub String);
+
+impl Deref for Name {
+    type Target = String;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for Name {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
diff --git a/crates/bevy_gltf/Cargo.toml b/crates/bevy_gltf/Cargo.toml
index 1f68f4b8a7cfd..4738ddda24f3b 100644
--- a/crates/bevy_gltf/Cargo.toml
+++ b/crates/bevy_gltf/Cargo.toml
@@ -14,6 +14,7 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
+bevy_core = { path = "../bevy_core", version = "0.3.0" }
 bevy_app = { path = "../bevy_app", version = "0.3.0" }
 bevy_asset = { path = "../bevy_asset", version = "0.3.0" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
@@ -24,8 +25,11 @@ bevy_math = { path = "../bevy_math", version = "0.3.0" }
 bevy_scene = { path = "../bevy_scene", version = "0.3.0" }
 bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
 
+# bevy (contrib)
+bevy_skinned_mesh = { path = "../bevy_skinned_mesh", version = "0.3.0" }
+
 # other
-gltf = { version = "0.15.2", default-features = false, features = ["utils"] }
+gltf = { version = "0.15.2", default-features = false, features = ["names", "utils"] }
 image = { version = "0.23", default-features = false }
 thiserror = "1.0"
 anyhow = "1.0"
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 5406ee6e8343e..2b4d2a6911695 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -1,6 +1,7 @@
 use anyhow::Result;
-use bevy_asset::{AssetIoError, AssetLoader, AssetPath, LoadContext, LoadedAsset};
-use bevy_ecs::{bevy_utils::BoxedFuture, World, WorldBuilderSource};
+use bevy_asset::{AssetIoError, AssetLoader, AssetPath, Handle, LoadContext, LoadedAsset};
+use bevy_core::Name;
+use bevy_ecs::{bevy_utils::BoxedFuture, Entity, World, WorldBuilderSource};
 use bevy_math::Mat4;
 use bevy_pbr::prelude::{PbrComponents, StandardMaterial};
 use bevy_render::{
@@ -10,6 +11,7 @@ use bevy_render::{
     texture::{AddressMode, FilterMode, SamplerDescriptor, TextureFormat},
 };
 use bevy_scene::Scene;
+use bevy_skinned_mesh::{MeshSkin, MeshSkinner};
 use bevy_transform::{
     hierarchy::{BuildWorldChildren, WorldChildBuilder},
     prelude::{GlobalTransform, Transform},
@@ -77,6 +79,16 @@ async fn load_gltf<'a, 'b>(
 
     let world_builder = &mut world.build();
 
+    let mut parents = vec![];
+    parents.resize(gltf.nodes().count(), None);
+    for node in gltf.nodes() {
+        for child in node.children() {
+            // Should only happen once, since each node can only have a single parent
+            debug_assert!(parents[child.index()].is_none());
+            parents[child.index()] = Some(node.index());
+        }
+    }
+
     for mesh in gltf.meshes() {
         for primitive in mesh.primitives() {
             let primitive_label = primitive_label(&mesh, &primitive);
@@ -111,11 +123,61 @@ async fn load_gltf<'a, 'b>(
                     mesh.set_indices(Some(Indices::U32(indices.into_u32().collect())));
                 };
 
+                if let Some(color_attribute) = reader
+                    .read_colors(0)
+                    .map(|v| VertexAttributeValues::Uchar4(v.into_rgba_u8().collect()))
+                {
+                    mesh.set_attribute(Mesh::ATTRIBUTE_WEIGHT, color_attribute);
+                }
+
+                if let Some(weight_attribute) = reader
+                    .read_weights(0)
+                    .map(|v| VertexAttributeValues::Float4(v.into_f32().collect()))
+                {
+                    mesh.set_attribute(Mesh::ATTRIBUTE_WEIGHT, weight_attribute);
+                }
+
+                if let Some(joint_attribute) = reader
+                    .read_joints(0)
+                    .map(|v| VertexAttributeValues::Ushort4(v.into_u16().collect()))
+                {
+                    mesh.set_attribute(Mesh::ATTRIBUTE_JOINT, joint_attribute);
+                }
+
                 load_context.set_labeled_asset(&primitive_label, LoadedAsset::new(mesh));
             };
         }
     }
 
+    for skin in gltf.skins() {
+        let skin_label = skin_label(&skin);
+        if load_context.has_labeled_asset(&skin_label) {
+            panic!("non unique skin labels");
+        }
+
+        let reader = skin.reader(|buffer| Some(&buffer_data[buffer.index()]));
+        if let Some(inverse_bind_matrices) = reader.read_inverse_bind_matrices() {
+            let mut bones_names = vec![];
+            let mut bones_parents = vec![];
+
+            for joint in skin.joints() {
+                bones_names.push(joint.name().expect("unnamed bone").to_string());
+                bones_parents.push(parents[joint.index()]);
+            }
+
+            load_context.set_labeled_asset(
+                &skin_label,
+                LoadedAsset::new(MeshSkin {
+                    inverse_bind_matrices: inverse_bind_matrices
+                        .map(|x| Mat4::from_cols_array_2d(&x))
+                        .collect(),
+                    bones_names,
+                    bones_parents,
+                }),
+            );
+        }
+    }
+
     for texture in gltf.textures() {
         if let gltf::image::Source::View { view, mime_type } = texture.source().source() {
             let start = view.offset() as usize;
@@ -180,22 +242,22 @@ async fn load_gltf<'a, 'b>(
         )
     }
 
+    // Each node will be mapped to a slot inside this `entity_lookup`
+    let mut entity_lookup = vec![];
+    entity_lookup.resize_with(gltf.nodes().count(), || None);
+
     for scene in gltf.scenes() {
-        let mut err = None;
-        world_builder
-            .spawn((Transform::default(), GlobalTransform::default()))
-            .with_children(|parent| {
-                for node in scene.nodes() {
-                    let result = load_node(&node, parent, load_context, &buffer_data);
-                    if result.is_err() {
-                        err = Some(result);
-                        return;
-                    }
-                }
-            });
-        if let Some(Err(err)) = err {
-            return Err(err);
+        world_builder.spawn((Transform::default(), GlobalTransform::default()));
+
+        if let Some(name) = scene.name() {
+            world_builder.with(Name(name.to_string()));
         }
+
+        world_builder.with_children(|parent| {
+            for node in scene.nodes() {
+                load_node(&node, &node, parent, load_context, &mut entity_lookup, 0);
+            }
+        });
     }
 
     load_context.set_default_asset(LoadedAsset::new(Scene::new(world)));
@@ -204,54 +266,89 @@ async fn load_gltf<'a, 'b>(
 }
 
 fn load_node(
+    root_node: &gltf::Node,
     node: &gltf::Node,
     world_builder: &mut WorldChildBuilder,
     load_context: &mut LoadContext,
-    buffer_data: &[Vec<u8>],
-) -> Result<(), GltfError> {
-    let transform = node.transform();
-    let mut gltf_error = None;
-    world_builder
-        .spawn((
-            Transform::from_matrix(Mat4::from_cols_array_2d(&transform.matrix())),
-            GlobalTransform::default(),
-        ))
-        .with_children(|parent| {
-            if let Some(mesh) = node.mesh() {
-                for primitive in mesh.primitives() {
-                    let primitive_label = primitive_label(&mesh, &primitive);
-                    let mesh_asset_path =
-                        AssetPath::new_ref(load_context.path(), Some(&primitive_label));
-                    let material = primitive.material();
-                    let material_label = material_label(&material);
-                    let material_asset_path =
-                        AssetPath::new_ref(load_context.path(), Some(&material_label));
-                    parent.spawn(PbrComponents {
-                        mesh: load_context.get_handle(mesh_asset_path),
-                        material: load_context.get_handle(material_asset_path),
-                        ..Default::default()
-                    });
-                }
-            }
+    entity_lookup: &mut Vec<Option<Entity>>,
+    mut depth: usize, // Used to debug (uncomment the prints)
+) {
+    // print!("{}", "    ".repeat(depth));
+    // println!("-{:?}", node.name());
+    depth += 1;
+
+    // NOTE: Avoid heavy computations when possible, also the blender exporter likes to
+    // output decomposed matrixes with is better for us
+    let (translation, rotation, scale) = node.transform().decomposed();
+    world_builder.spawn((
+        Transform {
+            translation: translation.into(),
+            rotation: rotation.into(),
+            scale: scale.into(),
+        },
+        GlobalTransform::default(),
+    ));
+
+    let node_entity = world_builder
+        .current_entity()
+        .expect("entity wasn't created");
+    entity_lookup[node.index()] = Some(node_entity);
+
+    if let Some(name) = node.name() {
+        world_builder.with(Name(name.to_string()));
+    }
 
-            if parent.current_entity().is_none() {
-                return;
+    if let Some(skin) = node.skin() {
+        let skin_label = skin_label(&skin);
+        let skin_asset_path = AssetPath::new_ref(load_context.path(), Some(&skin_label));
+        let skin_handle: Handle<MeshSkin> = load_context.get_handle(skin_asset_path);
+        world_builder.with(skin_handle);
+
+        // TODO: Mesh skinner needs a at least a reference to the skeleton root for it to work
+        // for this reason it need to keep track of all entities created by their index in the gltf node vec
+        let skeleton_root = skin.skeleton().map_or(root_node.index(), |n| n.index());
+        world_builder.with(MeshSkinner::with_skeleton(
+            entity_lookup[skeleton_root].expect("missing skeleton root entity"),
+        ));
+    }
+
+    world_builder.with_children(|parent| {
+        if let Some(mesh) = node.mesh() {
+            for primitive in mesh.primitives() {
+                let primitive_label = primitive_label(&mesh, &primitive);
+                let mesh_asset_path =
+                    AssetPath::new_ref(load_context.path(), Some(&primitive_label));
+                let material = primitive.material();
+                let material_label = material_label(&material);
+                let material_asset_path =
+                    AssetPath::new_ref(load_context.path(), Some(&material_label));
+
+                // print!("{}", "    ".repeat(depth));
+                // println!("-Mesh_{:?}_{}", mesh.name(), primitive.index());
+
+                parent.spawn(PbrComponents {
+                    mesh: load_context.get_handle(mesh_asset_path),
+                    material: load_context.get_handle(material_asset_path),
+                    ..Default::default()
+                });
             }
+        }
 
-            parent.with_children(|parent| {
-                for child in node.children() {
-                    if let Err(err) = load_node(&child, parent, load_context, buffer_data) {
-                        gltf_error = Some(err);
-                        return;
-                    }
-                }
-            });
-        });
-    if let Some(err) = gltf_error {
-        Err(err)
-    } else {
-        Ok(())
-    }
+        for child in node.children() {
+            load_node(
+                root_node,
+                &child,
+                parent,
+                load_context,
+                entity_lookup,
+                depth,
+            );
+        }
+    });
+}
+
+fn skin_label(skin: &gltf::Skin) -> String {
+    format!("Skin{}", skin.index())
 }
 
 fn primitive_label(mesh: &gltf::Mesh, primitive: &Primitive) -> String {
diff --git a/crates/bevy_render/src/mesh/mesh.rs b/crates/bevy_render/src/mesh/mesh.rs
index 7cef1ac9953da..24e284daac6d4 100644
--- a/crates/bevy_render/src/mesh/mesh.rs
+++ b/crates/bevy_render/src/mesh/mesh.rs
@@ -18,6 +18,8 @@ pub const VERTEX_ATTRIBUTE_BUFFER_ID: u64 = 10;
 pub const VERTEX_FALLBACK_BUFFER_ID: u64 = 20;
 #[derive(Clone, Debug)]
 pub enum VertexAttributeValues {
+    Uchar4(Vec<[u8; 4]>),
+    Ushort4(Vec<[u16; 4]>),
     Float(Vec<f32>),
     Float2(Vec<[f32; 2]>),
     Float3(Vec<[f32; 3]>),
@@ -27,6 +29,8 @@ pub enum VertexAttributeValues {
 impl VertexAttributeValues {
     pub fn len(&self) -> usize {
         match *self {
+            VertexAttributeValues::Uchar4(ref values) => values.len(),
+            VertexAttributeValues::Ushort4(ref values) => values.len(),
             VertexAttributeValues::Float(ref values) => values.len(),
             VertexAttributeValues::Float2(ref values) => values.len(),
             VertexAttributeValues::Float3(ref values) => values.len(),
@@ -41,6 +45,8 @@ impl VertexAttributeValues {
     // TODO: add vertex format as parameter here and perform type conversions
     pub fn get_bytes(&self) -> &[u8] {
         match self {
+            VertexAttributeValues::Uchar4(values) => values.as_slice().as_bytes(),
+            VertexAttributeValues::Ushort4(values) => values.as_slice().as_bytes(),
             VertexAttributeValues::Float(values) => values.as_slice().as_bytes(),
             VertexAttributeValues::Float2(values) => values.as_slice().as_bytes(),
             VertexAttributeValues::Float3(values) => values.as_slice().as_bytes(),
@@ -52,6 +58,8 @@ impl VertexAttributeValues {
 impl From<&VertexAttributeValues> for VertexFormat {
     fn from(values: &VertexAttributeValues) -> Self {
         match values {
+            VertexAttributeValues::Uchar4(_) => VertexFormat::Uchar4,
+            VertexAttributeValues::Ushort4(_) => VertexFormat::Ushort4,
             VertexAttributeValues::Float(_) => VertexFormat::Float,
             VertexAttributeValues::Float2(_) => VertexFormat::Float2,
             VertexAttributeValues::Float3(_) => VertexFormat::Float3,
@@ -113,6 +121,8 @@ impl Mesh {
     pub const ATTRIBUTE_NORMAL: &'static str = "Vertex_Normal";
     pub const ATTRIBUTE_POSITION: &'static str = "Vertex_Position";
     pub const ATTRIBUTE_UV_0: &'static str = "Vertex_Uv";
+    pub const ATTRIBUTE_WEIGHT: &'static str = "Vertex_Weight";
+    pub const ATTRIBUTE_JOINT: &'static str = "Vertex_Join";
 
     pub fn new(primitive_topology: PrimitiveTopology) -> Self {
         Mesh {
diff --git a/crates/bevy_skinned_mesh/Cargo.toml b/crates/bevy_skinned_mesh/Cargo.toml
new file mode 100644
index 0000000000000..ac1746f904cd4
--- /dev/null
+++ b/crates/bevy_skinned_mesh/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "bevy_skinned_mesh"
+version = "0.3.0"
+authors = ["Felipe Jorge <felipe.jorge.pereira@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+bevy_app = { path = "../bevy_app", version = "0.3.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.3.0" }
+bevy_core = { path = "../bevy_core", version = "0.3.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
+bevy_math = { path = "../bevy_math", version = "0.3.0" }
+bevy_render = { path = "../bevy_render", version = "0.3.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.3.0" }
+bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
+bevy_property = { path = "../bevy_property", version = "0.3.0" }
+
+# # other
+# serde = { version = "1.0", features = ["derive"] }
+smallvec = { version = "1.4", features = ["serde"] }
diff --git a/crates/bevy_skinned_mesh/src/lib.rs b/crates/bevy_skinned_mesh/src/lib.rs
new file mode 100644
index 0000000000000..edd0789b5de1a
--- /dev/null
+++ b/crates/bevy_skinned_mesh/src/lib.rs
@@ -0,0 +1,163 @@
+// TODO: Later merge with bevy_animation
+use bevy_app::prelude::*;
+use bevy_asset::{AddAsset, Assets, Handle};
+use bevy_core::Name;
+use bevy_ecs::prelude::*;
+use bevy_ecs::MapEntities;
+use bevy_math::Mat4;
+use bevy_property::Properties;
+use bevy_render::mesh::Mesh;
+use bevy_transform::prelude::*;
+use bevy_type_registry::{RegisterType, TypeUuid};
+use smallvec::SmallVec;
+// use serde::{Deserialize, Serialize};
+
+/// Skin asset used by the mesh skinning process
+#[derive(Debug, Clone, TypeUuid)]
+#[uuid = "129d54f5-4ee7-456f-9340-32e71469cdaf"]
+pub struct MeshSkin {
+    pub inverse_bind_matrices: Vec<Mat4>,
+    pub bones_names: Vec<String>,
+    /// Each bone as an entry that specifies their parent bone, maybe used to reconstruct
+    /// the bone hierarchy when missing
+    pub bones_parents: Vec<Option<usize>>,
+}
+
+impl MeshSkin {
+    #[inline(always)]
+    pub fn bone_count(&self) -> usize {
+        self.bones_names.len()
+    }
+}
+
+/// Component that skins some mesh.
+/// Requires a `Handle<MeshSkin>` attached to same entity as the component
+#[derive(Properties)]
+pub struct MeshSkinner {
+    /// Keeps track of what `MeshSkin` this component is configured to,
+    /// extra work is required to keep bones in order.
+    ///
+    /// It's expected to the skin not to change very often or at all
+    #[property(ignore)]
+    skin: Option<Handle<MeshSkin>>,
+    /// Skeleton root entity
+    pub skeleton: Entity,
+    /// Maps each bone to an entity, order matters and must match the
+    /// `Handle<MeshSkin>` bone order, this will simplify the lookup of
+    /// the bind matrix for each bone
+    pub bones: SmallVec<[Option<Entity>; 16]>, // ! FIXME: Property can't handle Vec<Entity>
+    /// List of sub-meshes (gltf primitives) that uses this mesh skinner
+    pub meshes: SmallVec<[Entity; 8]>, // ! FIXME: Property can't handle Vec<Entity>
+}
+
+impl MeshSkinner {
+    pub fn with_skeleton(skeleton: Entity) -> Self {
+        Self {
+            skin: None,
+            skeleton,
+            bones: Default::default(),
+            meshes: Default::default(),
+        }
+    }
+
+    // TODO: Provide a safe interface to `set_bone_by_name` in the MeshSkinner
+}
+
+// TODO: Same problem of Parent component
+impl FromResources for MeshSkinner {
+    fn from_resources(_resources: &bevy_ecs::Resources) -> Self {
+        MeshSkinner::with_skeleton(Entity::new(u32::MAX))
+    }
+}
+
+impl MapEntities for MeshSkinner {
+    fn map_entities(
+        &mut self,
+        entity_map: &bevy_ecs::EntityMap,
+    ) -> Result<(), bevy_ecs::MapEntitiesError> {
+        for bone in &mut self.bones {
+            if let Some(bone_entity) = bone {
+                *bone_entity = entity_map.get(*bone_entity)?;
+            }
+        }
+        self.skeleton = entity_map.get(self.skeleton)?;
+        Ok(())
+    }
+}
+
+// NOTE: This system is provided for a user convenience, once the root bone is assigned this system
+// will find the rest of the skeleton hierarchy.
+fn mesh_skinner_startup(
+    mesh_skin_assets: Res<Assets<MeshSkin>>,
+    mut skinners_query: Query<(&Handle<MeshSkin>, &mut MeshSkinner, Option<&Children>)>,
+    meshes_query: Query<(&Handle<Mesh>,)>,
+    bones_query: Query<(Entity, &Name, Option<&Children>)>,
+) {
+    for (mesh_skin, mut mesh_skinner, children) in skinners_query.iter_mut() {
+        // Already assigned
+        if Some(mesh_skin) == mesh_skinner.skin.as_ref() {
+            continue;
+        }
+
+        // Lookup for all non assigned sub-meshes
+        if let Some(children) = children {
+            for mesh in children
+                .iter()
+                .filter_map(|child| meshes_query.get(*child).map_or(None, |_| Some(child)))
+                .copied()
+            {
+                if mesh_skinner.meshes.contains(&mesh) {
+                    continue;
+                }
+
+                mesh_skinner.meshes.push(mesh);
+            }
+        }
+
+        if let Some(skin) = mesh_skin_assets.get(mesh_skin) {
+            // Ensure bone capacity
+            mesh_skinner.bones.resize(skin.bone_count(), None);
+
+            let mut root = true;
+            let mut stack = vec![mesh_skinner.skeleton];
+            while let Some(entity) = stack.pop() {
+                // Lookup bones in the hierarchy
+                if let Ok((bone_entity, name, children)) = bones_query.get(entity) {
+                    if root {
+                        children.map(|c| stack.extend(c.iter()));
+                        root = false;
+                    }
+
+                    if let Some((bone_index, _)) = skin
+                        .bones_names
+                        .iter()
+                        .enumerate()
+                        .find(|(_, n)| name.eq(*n))
+                    {
+                        mesh_skinner.bones[bone_index] = Some(bone_entity);
+                        children.map(|c| stack.extend(c.iter()));
+                    }
+                }
+            }
+
+            mesh_skinner.skin = Some(mesh_skin.clone());
+        }
+    }
+}
+
+// TODO: MeshSkinner system
+// fn mesh_skinner_update() {
+//     // TODO: have to send the matrices into each entity
+// }
+
+#[derive(Default)]
+pub struct MeshSkinPlugin;
+
+impl Plugin for MeshSkinPlugin {
+    fn build(&self, app: &mut AppBuilder) {
+        app.add_asset::<MeshSkin>()
+            .register_component_with::<MeshSkinner>(|reg| reg.map_entities())
+            .add_system(mesh_skinner_startup.system());
+        // .register_component::<BoneName>();
+    }
+}
diff --git a/src/default_plugins.rs b/src/default_plugins.rs
index 1e132aaec7420..71432abddb244 100644
--- a/src/default_plugins.rs
+++ b/src/default_plugins.rs
@@ -35,7 +35,10 @@ impl PluginGroup for DefaultPlugins {
         group.add(bevy_gilrs::GilrsPlugin::default());
 
         #[cfg(feature = "bevy_gltf")]
-        group.add(bevy_gltf::GltfPlugin::default());
+        {
+            group.add(bevy_gltf::GltfPlugin::default());
+            group.add(bevy_skinned_mesh::MeshSkinPlugin::default());
+        }
 
         #[cfg(feature = "bevy_winit")]
         group.add(bevy_winit::WinitPlugin::default());

From 8ddab67b9074e0822897271829d674b30f4ffba9 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sun, 8 Nov 2020 16:10:50 -0300
Subject: [PATCH 002/153] working towards a generic animation system

---
 Cargo.toml                                    |   4 +-
 .../Cargo.toml                                |   5 +-
 crates/bevy_animation/src/generic.rs          | 437 ++++++++++++++++++
 crates/bevy_animation/src/lerping.rs          |  21 +
 crates/bevy_animation/src/lib.rs              |  38 ++
 .../src/skined_mesh.rs}                       |  21 +-
 crates/bevy_gltf/Cargo.toml                   |   2 +-
 crates/bevy_gltf/src/loader.rs                |  36 +-
 .../bevy_property_derive/src/lib.rs           |  24 +
 .../bevy_property/src/dynamic_properties.rs   |   8 +
 .../impl_property/impl_property_smallvec.rs   |   8 +
 .../src/impl_property/impl_property_std.rs    | 120 +++++
 crates/bevy_property/src/property.rs          |   2 +
 src/default_plugins.rs                        |  10 +-
 14 files changed, 713 insertions(+), 23 deletions(-)
 rename crates/{bevy_skinned_mesh => bevy_animation}/Cargo.toml (90%)
 create mode 100644 crates/bevy_animation/src/generic.rs
 create mode 100644 crates/bevy_animation/src/lerping.rs
 create mode 100644 crates/bevy_animation/src/lib.rs
 rename crates/{bevy_skinned_mesh/src/lib.rs => bevy_animation/src/skined_mesh.rs} (93%)

diff --git a/Cargo.toml b/Cargo.toml
index 3e78d2b2daf28..9344f83fd85f9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,7 +21,7 @@ default = [
     "bevy_dynamic_plugin",
     "bevy_gilrs",
     "bevy_gltf",
-    "bevy_skinned_mesh",
+    "bevy_animation",
     "bevy_wgpu",
     "bevy_winit",
     "render",
@@ -75,7 +75,7 @@ bevy_tasks = { path = "crates/bevy_tasks", version = "0.3.0" }
 # bevy (optional)
 bevy_audio = { path = "crates/bevy_audio", optional = true, version = "0.3.0" }
 bevy_gltf = { path = "crates/bevy_gltf", optional = true, version = "0.3.0" }
-bevy_skinned_mesh = { path = "crates/bevy_skinned_mesh", optional = true, version = "0.3.0" }
+bevy_animation = { path = "crates/bevy_animation", optional = true, version = "0.3.0" }
 bevy_pbr = { path = "crates/bevy_pbr", optional = true, version = "0.3.0" }
 bevy_render = { path = "crates/bevy_render", optional = true, version = "0.3.0" }
 bevy_dynamic_plugin = { path = "crates/bevy_dynamic_plugin", optional = true, version = "0.3.0" }
diff --git a/crates/bevy_skinned_mesh/Cargo.toml b/crates/bevy_animation/Cargo.toml
similarity index 90%
rename from crates/bevy_skinned_mesh/Cargo.toml
rename to crates/bevy_animation/Cargo.toml
index ac1746f904cd4..97ab4440c569b 100644
--- a/crates/bevy_skinned_mesh/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "bevy_skinned_mesh"
+name = "bevy_animation"
 version = "0.3.0"
 authors = ["Felipe Jorge <felipe.jorge.pereira@gmail.com>"]
 edition = "2018"
@@ -18,5 +18,6 @@ bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
 bevy_property = { path = "../bevy_property", version = "0.3.0" }
 
 # # other
-# serde = { version = "1.0", features = ["derive"] }
+serde = { version = "1.0", features = ["derive"] }
 smallvec = { version = "1.4", features = ["serde"] }
+anyhow = "1.0"
diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
new file mode 100644
index 0000000000000..4e65379660862
--- /dev/null
+++ b/crates/bevy_animation/src/generic.rs
@@ -0,0 +1,437 @@
+use anyhow::Result;
+use bevy_app::prelude::*;
+use bevy_asset::{AddAsset, AssetLoader, Assets, Handle, LoadedAsset};
+use bevy_core::prelude::*;
+use bevy_ecs::prelude::*;
+use bevy_ecs::{MapEntities, TypeAccess};
+use bevy_math::{Quat, Vec3, Vec4};
+use bevy_property::Properties;
+use bevy_property::PropertyType;
+use bevy_transform::prelude::*;
+use bevy_type_registry::{TypeRegistry, TypeUuid};
+use serde::{Deserialize, Serialize};
+use std::any::TypeId;
+use std::collections::HashMap;
+
+use super::lerping::LerpValue;
+
+// Naive implementation for skeleton animation
+
+// TODO: Curve/Curve need a validation during deserialization because they are
+// structured as SOA (struct of arrays), so the vec's length must match
+
+#[derive(Default, Debug, Serialize, Deserialize, TypeUuid)]
+#[uuid = "4c76e6c3-706d-4a74-af8e-4f48033e0733"]
+pub struct Clip {
+    #[serde(default = "clip_default_warp")]
+    pub warp: bool,
+    length: f32,
+    //pub bones: Vec<Bone>,
+    /// Property to be animated will be in the format `"path/to/named_entity@Transform.translation.x"`
+    /// where the left side `@` defines a path to the entity to animate,
+    /// while the right side the path to a property to animate starting from the component.
+    ///
+    /// *NOTE*: Keep sorted to improve efficiency
+    properties: Vec<String>,
+    values: Vec<Value>,
+}
+
+fn clip_default_warp() -> bool {
+    true
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum Value {
+    Float(Curve<f32>),
+    Vec3(Curve<Vec3>),
+    Vec4(Curve<Vec4>),
+    Quat(Curve<Quat>),
+}
+
+impl Value {
+    pub fn type_name(&self) -> &str {
+        use std::any::type_name;
+        match self {
+            Value::Float(_) => type_name::<f32>(),
+            Value::Vec3(_) => type_name::<Vec3>(),
+            Value::Vec4(_) => type_name::<Vec4>(),
+            Value::Quat(_) => type_name::<Quat>(),
+        }
+    }
+}
+
+#[derive(Default, Debug, Serialize, Deserialize)]
+pub struct Curve<T> {
+    // TODO: Linear and Spline variants
+    samples: Vec<f32>,
+    values: Vec<T>,
+}
+
+impl<T> Curve<T>
+where
+    T: LerpValue,
+{
+    /// Samples the curve beginning from the keyframe at index
+    pub fn sample(&self, mut index: usize, time: f32) -> (usize, T) {
+        // Adjust for the current keyframe index
+        let last_index = self.samples.len() - 1;
+        loop {
+            if index > last_index {
+                return (last_index, *self.values.last().unwrap());
+            }
+
+            if self.samples[index] < time {
+                index += 1;
+            } else {
+                break;
+            }
+        }
+
+        let value = if index == 0 {
+            self.values[0]
+        } else {
+            // Lerp the value
+            let i = index - 1;
+            let previous_time = self.samples[i];
+            let t = (time - previous_time) / (self.samples[index] - previous_time);
+            //println!("{} => ({}, {}) => {}", time, i, index, t);
+            //let t = t.max(0.0).min(1.0);
+            debug_assert!(t >= 0.0 && t <= 1.0); // Checks if it's required to normalize t
+            T::lerp(self.values[i], self.values[index], t)
+        };
+
+        (index, value)
+    }
+}
+
+#[derive(Default, Debug, Clone, Properties)]
+struct State {
+    clip: usize,
+    time: f32,
+    keyframe: Vec<KeyframeState>,
+}
+
+#[derive(Default, Debug, Clone, Properties)]
+struct KeyframeState {
+    position: usize,
+    rotation: usize,
+    scale: usize,
+}
+
+// #[derive(Default, Clone, Debug, Properties)]
+// struct Lerp {
+//     n: f32,
+//     time: f32,
+//     duration: f32,
+// }
+
+#[derive(Debug, Properties)]
+pub struct Animator {
+    animations: Vec<Handle<Clip>>,
+    #[property(ignore)]
+    instances: Vec<Instance>,
+    pub time_scale: f32,
+    // hierarchy: Vec<()>,
+    current: State,
+    // next: Option<State>, // TODO: Keep memory allocated to be reused
+    // transition: Lerp,
+}
+
+impl Default for Animator {
+    fn default() -> Self {
+        Self {
+            animations: vec![],
+            instances: vec![],
+            time_scale: 1.0,
+            current: State::default(),
+            // next: None,
+            // transition: Lerp::default(),
+        }
+    }
+}
+
+/// Instance info to be animated
+#[derive(Default, Debug)]
+struct Instance {
+    valid: Vec<bool>,
+    entities: Vec<Entity>,
+    components: Vec<TypeId>,
+    properties: Vec<isize>,
+}
+
+/// Fetches entities and properties to animate
+pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
+    // Fetch useful resources
+    let type_registry = resources
+        .get_thread_local::<TypeRegistry>()
+        .expect("missing TypeRegistry");
+
+    let clips = resources
+        .get_thread_local::<Assets<Clip>>()
+        .expect("missing Assets<Clip>");
+
+    // Build queries
+    let type_access = TypeAccess::default();
+    let mut animators_query: Query<(&mut Animator, &Children)> = Query::new(&world, &type_access);
+    let entities_query: Query<(Entity, &Name, &Children)> = Query::new(&world, &type_access);
+
+    // TODO: Parallelize this loop
+    for (mut animator, root_children) in animators_query.iter_mut() {
+        // Trick for proper borrow rules
+        let animator = &mut *animator;
+
+        // TODO: Needs to be updated when the hierarch change
+        // TODO: Needs to be updated when a clip changes
+        let animations_count = animator.animations.len();
+        if animations_count == animator.instances.len() {
+            continue;
+        }
+
+        animator
+            .instances
+            .resize_with(animations_count, || Default::default());
+
+        for (clip_index, clip_handle) in animator.animations.iter().enumerate() {
+            if let Some(clip) = clips.get(clip_handle) {
+                // Get instance reference to modify during the function
+                let instance = &mut animator.instances[clip_index];
+
+                let mut paths = clip
+                    .properties
+                    .iter()
+                    .map(|p| {
+                        let mut split = p.split('@');
+                        (
+                            split.next().unwrap_or("").split('/'),
+                            split.next().unwrap_or("").split('.'),
+                        )
+                    })
+                    .collect::<Vec<_>>();
+
+                // NOTE: `clear` then `resize` is an good way of reuse memory
+                // as much as possible but it doesn't free it so it may come
+                // to need to manually trim these Vec's whenever they get too large
+
+                let valid = &mut instance.valid;
+                valid.clear();
+                valid.resize(paths.len(), false);
+
+                let entities = &mut instance.entities;
+                entities.clear();
+                entities.resize(paths.len(), Entity::new(u32::MAX));
+
+                let mut hierarchy = paths.iter_mut().map(|p| p.0.next()).collect::<Vec<_>>();
+
+                // 1. Find entities
+                let mut stack = vec![];
+                // First uneducated search for all hierarchy
+                for parent in root_children.iter().copied() {
+                    if let Ok((entity, name, children)) = entities_query.get(parent) {
+                        let name = Some(name.0.as_str());
+                        if let Some(i) = hierarchy.iter().position(|level| *level == name) {
+                            hierarchy[i] = paths[i].0.next();
+                            entities[i] = entity;
+                            valid[i] = true;
+                            stack.push((i, children));
+                        }
+                    }
+                }
+                // Fast educated search into the nested hierarchy
+                while let Some((i, parents)) = stack.pop() {
+                    for parent in parents.iter().copied() {
+                        if let Ok((entity, name, children)) = entities_query.get(parent) {
+                            if hierarchy[i] == Some(name.0.as_str()) {
+                                hierarchy[i] = paths[i].0.next();
+                                entities[i] = entity; // Replaces the entity for the lowest
+                                valid[i] = true;
+                                stack.push((i, children));
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                let components = &mut instance.components;
+                components.clear();
+                components.resize(paths.len(), TypeId::of::<()>());
+
+                let properties = &mut instance.properties;
+                properties.clear();
+                properties.resize(paths.len(), 0);
+
+                // 2. Find components and properties in all entities that completed the path
+                for (i, path) in hierarchy.iter().enumerate() {
+                    if valid[i] {
+                        // Not reached the entity at the path
+                        if path.is_none() {
+                            valid[i] = false;
+                            break;
+                        }
+
+                        let component = paths[i].1.next().unwrap_or("?");
+                        if let Some(component_reg) = type_registry
+                            .component
+                            .read()
+                            .get_with_short_name(component)
+                        {
+                            if let Some(location) = world.get_entity_location(entities[i]) {
+                                components[i] = component_reg.ty;
+
+                                let root_properties = component_reg.get_component_properties(
+                                    &world.archetypes[location.archetype as usize],
+                                    location.index,
+                                );
+
+                                // Find the target property to animate
+                                let mut properties_lookup = Some(root_properties.clone());
+                                let mut target_property = None;
+
+                                for property_name in &mut paths[i].1 {
+                                    if let Some(property) =
+                                        properties_lookup.map(|p| p.prop(property_name)).flatten()
+                                    {
+                                        // NOTE: Vec, HashMap and other types can't be animated
+                                        // and needed to be filtered out
+                                        if property.property_type() != PropertyType::Value {
+                                            target_property = None;
+                                            valid[i] = false;
+                                            break;
+                                        }
+
+                                        properties_lookup = property.as_properties();
+                                        target_property = Some(property);
+                                    } else {
+                                        // Failed to find property
+                                        target_property = None;
+                                        valid[i] = false;
+                                        break;
+                                    }
+                                }
+
+                                if let Some(target_property) = target_property {
+                                    // Check for the expected type
+                                    if target_property.type_name() == clip.values[i].type_name() {
+                                        properties[i] = {
+                                            let root_ptr = root_properties.as_ptr();
+                                            let target_ptr = target_property.as_ptr();
+                                            // ! NOTE: Requires rust 1.47.0
+                                            // TODO: Need safety check
+                                            unsafe { root_ptr.offset_from(target_ptr) }
+                                        };
+                                    } else {
+                                        valid[i] = false;
+                                    }
+                                // locations[i] = location;
+                                } else {
+                                    valid[i] = false;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+// pub(crate) fn animator_update(
+//     time: Res<Time>,
+//     // keyboard: Res<Input<KeyCode>>,
+//     clips: Res<Assets<Clip>>,
+//     mut animators_query: Query<(Mut<Animator>,)>,
+//     mut transforms_query: Query<(Mut<Transform>,)>,
+// ) {
+//     // let delta_time = if keyboard.just_pressed(KeyCode::Right) {
+//     //     1.0 / 60.0
+//     // } else {
+//     //     0.0
+//     // };
+
+//     let delta_time = time.delta_seconds;
+
+//     for (mut debugger,) in animators_query.iter_mut() {
+//         let debugger = debugger.deref_mut();
+
+//         if !debugger.builded {
+//             return;
+//         }
+
+//         // Time scales by component
+//         let delta_time = delta_time * debugger.time_scale;
+
+//         // Ensure capacity for cached keyframe index vec
+//         let nodes_count = debugger.hierarchy.len();
+//         if debugger.current.keyframe.len() != nodes_count {
+//             debugger.current.keyframe.clear();
+//             debugger
+//                 .current
+//                 .keyframe
+//                 .resize_with(nodes_count, || Default::default());
+//         }
+
+//         if let Some(clip) = clips.get(&debugger.clip) {
+//             // Update time
+//             let mut time = debugger.current.time + delta_time;
+
+//             // Warp mode
+//             if clip.warp {
+//                 // Warp Around
+//                 if time > clip.length {
+//                     time = (time / clip.length).fract() * clip.length;
+//                     // Reset all keyframes cached indexes
+//                     debugger
+//                         .current
+//                         .keyframe
+//                         .iter_mut()
+//                         .for_each(|x| *x = Default::default())
+//                 }
+//             } else {
+//                 // Hold
+//                 time = time.min(clip.length);
+//             }
+
+//             // Advance state time
+//             debugger.current.time = time;
+
+//             for (i, entity) in debugger.hierarchy.iter().enumerate() {
+//                 if let Ok((mut transform,)) = transforms_query.get_mut(*entity) {
+//                     // Get cached keyframe info
+//                     let keyframe = &mut debugger.current.keyframe[i];
+
+//                     // Sample animation
+//                     let (k, v) = clip.bones[i].position.sample(keyframe.position, time);
+//                     keyframe.position = k;
+//                     transform.translation = v;
+
+//                     let (k, v) = clip.bones[i].rotation.sample(keyframe.rotation, time);
+//                     keyframe.rotation = k;
+//                     transform.rotation = v;
+
+//                     let (k, v) = clip.bones[i].scale.sample(keyframe.scale, time);
+//                     keyframe.scale = k;
+//                     transform.scale = v;
+//                 }
+//             }
+//         }
+//     }
+// }
+
+// pub struct ClipLoader;
+
+// impl AssetLoader for ClipLoader {
+//     fn load<'a>(
+//         &'a self,
+//         bytes: &'a [u8],
+//         load_context: &'a mut bevy::asset::LoadContext,
+//     ) -> bevy::utils::BoxedFuture<'a, Result<()>> {
+//         Box::pin(async move {
+//             let clip: Clip = ron::de::from_bytes(bytes)?;
+//             load_context.set_default_asset(LoadedAsset::new(clip));
+//             Ok(())
+//         })
+//     }
+
+//     fn extensions(&self) -> &[&str] {
+//         &["anim"]
+//     }
+// }
diff --git a/crates/bevy_animation/src/lerping.rs b/crates/bevy_animation/src/lerping.rs
new file mode 100644
index 0000000000000..1da6a12963012
--- /dev/null
+++ b/crates/bevy_animation/src/lerping.rs
@@ -0,0 +1,21 @@
+use bevy_math::prelude::*;
+
+pub trait LerpValue: Copy {
+    fn lerp(a: Self, b: Self, t: f32) -> Self;
+}
+
+impl LerpValue for Vec3 {
+    fn lerp(a: Self, b: Self, t: f32) -> Self {
+        a * (1.0 - t) + b * t
+    }
+}
+
+impl LerpValue for Quat {
+    /// Actually performs an nlerp, because it's much cheaper and easer to combine with other animations,
+    /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
+    fn lerp(a: Self, b: Self, t: f32) -> Self {
+        // ! NOTE: slerp is nice if you want to debug the animation code
+        // a.slerp(b, t)
+        Vec4::lerp(a.into(), b.into(), t).normalize().into()
+    }
+}
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
new file mode 100644
index 0000000000000..4e521cfc89840
--- /dev/null
+++ b/crates/bevy_animation/src/lib.rs
@@ -0,0 +1,38 @@
+use bevy_app::prelude::*;
+use bevy_asset::AddAsset;
+use bevy_ecs::prelude::*;
+use bevy_type_registry::RegisterType;
+
+use crate::generic::*;
+use crate::skined_mesh::*;
+
+pub mod generic;
+mod lerping;
+pub mod skined_mesh;
+
+pub mod prelude {
+    pub use crate::generic::*;
+    pub use crate::lerping::LerpValue;
+    pub use crate::skined_mesh::{MeshSkin, MeshSkinner};
+}
+
+pub mod stage {
+    pub const ANIMATE: &'static str = "animate";
+    pub use bevy_app::stage::UPDATE;
+}
+
+#[derive(Default)]
+pub struct AnimationPlugin;
+
+impl Plugin for AnimationPlugin {
+    fn build(&self, app: &mut AppBuilder) {
+        app.add_asset::<Clip>()
+            .add_stage_after(stage::UPDATE, stage::ANIMATE)
+            //.add_asset_loader(ClipLoader)
+            .add_system_to_stage(stage::ANIMATE, animator_fetch.thread_local_system())
+            //.add_system_to_stage(stage::ANIMATE, animator_update.system())
+            .add_asset::<MeshSkin>()
+            .register_component_with::<MeshSkinner>(|reg| reg.map_entities())
+            .add_system(mesh_skinner_startup.system());
+    }
+}
diff --git a/crates/bevy_skinned_mesh/src/lib.rs b/crates/bevy_animation/src/skined_mesh.rs
similarity index 93%
rename from crates/bevy_skinned_mesh/src/lib.rs
rename to crates/bevy_animation/src/skined_mesh.rs
index edd0789b5de1a..5b11adbe0ec2e 100644
--- a/crates/bevy_skinned_mesh/src/lib.rs
+++ b/crates/bevy_animation/src/skined_mesh.rs
@@ -30,6 +30,7 @@ impl MeshSkin {
     }
 }
 
+// TODO: Find a better name!
 /// Component that skins some mesh.
 /// Requires a `Handle<MeshSkin>` attached to same entity as the component
 #[derive(Properties)]
@@ -87,7 +88,7 @@ impl MapEntities for MeshSkinner {
 
 // NOTE: This system is provided for a user convenience, once the root bone is assigned this system
 // will find the rest of the skeleton hierarchy.
-fn mesh_skinner_startup(
+pub(crate) fn mesh_skinner_startup(
     mesh_skin_assets: Res<Assets<MeshSkin>>,
     mut skinners_query: Query<(&Handle<MeshSkin>, &mut MeshSkinner, Option<&Children>)>,
     meshes_query: Query<(&Handle<Mesh>,)>,
@@ -150,14 +151,10 @@ fn mesh_skinner_startup(
 //     // TODO: have to send the matrices into each entity
 // }
 
-#[derive(Default)]
-pub struct MeshSkinPlugin;
-
-impl Plugin for MeshSkinPlugin {
-    fn build(&self, app: &mut AppBuilder) {
-        app.add_asset::<MeshSkin>()
-            .register_component_with::<MeshSkinner>(|reg| reg.map_entities())
-            .add_system(mesh_skinner_startup.system());
-        // .register_component::<BoneName>();
-    }
-}
+// #[derive(Default, Debug)]
+// pub struct MeshSkinnerDebuger {
+//     pub enabled: bool,
+//     currently_enabled: bool,
+//     mesh: Handle<Mesh>,
+//     entity: Option<Entity>,
+// }
diff --git a/crates/bevy_gltf/Cargo.toml b/crates/bevy_gltf/Cargo.toml
index 4738ddda24f3b..4bdbd33c5f627 100644
--- a/crates/bevy_gltf/Cargo.toml
+++ b/crates/bevy_gltf/Cargo.toml
@@ -26,7 +26,7 @@ bevy_scene = { path = "../bevy_scene", version = "0.3.0" }
 bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
 
 # bevy (contrib)
-bevy_skinned_mesh = { path = "../bevy_skinned_mesh", version = "0.3.0" }
+bevy_animation = { path = "../bevy_animation", version = "0.3.0" }
 
 # other
 gltf = { version = "0.15.2", default-features = false, features = ["names", "utils"] }
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 2b4d2a6911695..90848469ac0d9 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -1,4 +1,5 @@
 use anyhow::Result;
+use bevy_animation::prelude::*;
 use bevy_asset::{AssetIoError, AssetLoader, AssetPath, Handle, LoadContext, LoadedAsset};
 use bevy_core::Name;
 use bevy_ecs::{bevy_utils::BoxedFuture, Entity, World, WorldBuilderSource};
@@ -11,7 +12,6 @@ use bevy_render::{
     texture::{AddressMode, FilterMode, SamplerDescriptor, TextureFormat},
 };
 use bevy_scene::Scene;
-use bevy_skinned_mesh::{MeshSkin, MeshSkinner};
 use bevy_transform::{
     hierarchy::{BuildWorldChildren, WorldChildBuilder},
     prelude::{GlobalTransform, Transform},
@@ -451,3 +451,37 @@ async fn load_buffers(
 
     Ok(buffer_data)
 }
+
+// const EPSILON: f32 = 1.0e-8;
+// const EPSILON_SQUARED: f32 = EPSILON * EPSILON;
+
+// fn angle(a: Quat, b: Quat) -> f32 {
+//     let dot = a.dot(b);
+//     if dot > (1.0 - EPSILON) {
+//         0.0
+//     } else {
+//         dot.abs().min(1.0).acos() * 2.0 * 180.0 / std::f32::consts::PI
+//     }
+// }
+
+// fn axis(a: Quat) -> Vec3 {
+//     let (x, y, z, w) = Vec4::from(a).into();
+//     let scale_sq = (1.0 - w * w).max(0.0);
+//     if scale_sq >= EPSILON_SQUARED {
+//         Vec3::new(x, y, z) / scale_sq.sqrt()
+//     } else {
+//         Vec3::unit_x()
+//     }
+// }
+
+// fn is_axis_flipped(a: Quat, b: Quat) -> bool {
+//     let dot = axis(a).dot(axis(b));
+//     dbg!(dot);
+//     if (1.0 - dot.abs()) > 0.1 {
+//         false
+//     } else {
+//         // Quaternion axis are (almost) colinear
+//         // but heir axis are opposing to each other
+//         dot < 0.0
+//     }
+// }
diff --git a/crates/bevy_property/bevy_property_derive/src/lib.rs b/crates/bevy_property/bevy_property_derive/src/lib.rs
index bbdd211410e42..da5a37f73e960 100644
--- a/crates/bevy_property/bevy_property_derive/src/lib.rs
+++ b/crates/bevy_property/bevy_property_derive/src/lib.rs
@@ -223,6 +223,14 @@ pub fn derive_properties(input: TokenStream) -> TokenStream {
             fn property_type(&self) -> #bevy_property_path::PropertyType {
                 #bevy_property_path::PropertyType::Map
             }
+
+            fn as_ptr(&self) -> *const u8 {
+                self as *const _ as *const u8
+            }
+
+            fn as_mut_ptr(&mut self) -> *mut u8 {
+                self as *mut _ as *mut u8
+            }
         }
     })
 }
@@ -283,6 +291,14 @@ pub fn derive_property(input: TokenStream) -> TokenStream {
             fn property_type(&self) -> #bevy_property_path::PropertyType {
                 #bevy_property_path::PropertyType::Value
             }
+
+            fn as_ptr(&self) -> *const u8 {
+                self as *const _ as *const u8
+            }
+
+            fn as_mut_ptr(&mut self) -> *mut u8 {
+                self as *mut _ as *mut u8
+            }
         }
 
         impl #impl_generics #bevy_property_path::DeserializeProperty for #struct_name#ty_generics  {
@@ -415,6 +431,14 @@ pub fn impl_property(input: TokenStream) -> TokenStream {
             fn property_type(&self) -> #bevy_property_path::PropertyType {
                 #bevy_property_path::PropertyType::Value
             }
+
+            fn as_ptr(&self) -> *const u8 {
+                self as *const _ as *const u8
+            }
+
+            fn as_mut_ptr(&mut self) -> *mut u8 {
+                self as *mut _ as *mut u8
+            }
         }
 
         impl #impl_generics #bevy_property_path::DeserializeProperty for #ty#ty_generics #where_clause  {
diff --git a/crates/bevy_property/src/dynamic_properties.rs b/crates/bevy_property/src/dynamic_properties.rs
index 6312c8ebdbac6..1967ffcd72845 100644
--- a/crates/bevy_property/src/dynamic_properties.rs
+++ b/crates/bevy_property/src/dynamic_properties.rs
@@ -207,6 +207,14 @@ impl Property for DynamicProperties {
     fn property_type(&self) -> PropertyType {
         self.property_type
     }
+
+    fn as_ptr(&self) -> *const u8 {
+        panic!("as_ptr isn't supported for DynamicProperties")
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        panic!("as_mut_ptr isn't supported for DynamicProperties")
+    }
 }
 
 impl DeserializeProperty for DynamicProperties {
diff --git a/crates/bevy_property/src/impl_property/impl_property_smallvec.rs b/crates/bevy_property/src/impl_property/impl_property_smallvec.rs
index caf78a6aa792a..7c6aa6c6c7804 100644
--- a/crates/bevy_property/src/impl_property/impl_property_smallvec.rs
+++ b/crates/bevy_property/src/impl_property/impl_property_smallvec.rs
@@ -47,4 +47,12 @@ where
     fn property_type(&self) -> PropertyType {
         PropertyType::Value
     }
+
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut _ as *mut u8
+    }
 }
diff --git a/crates/bevy_property/src/impl_property/impl_property_std.rs b/crates/bevy_property/src/impl_property/impl_property_std.rs
index 819fdd4c049cf..786c63e466065 100644
--- a/crates/bevy_property/src/impl_property/impl_property_std.rs
+++ b/crates/bevy_property/src/impl_property/impl_property_std.rs
@@ -101,6 +101,14 @@ where
     fn property_type(&self) -> PropertyType {
         PropertyType::Seq
     }
+
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut _ as *mut u8
+    }
 }
 
 // impl_property!(SEQUENCE, VecDeque<T> where T: Clone + Send + Sync + Serialize + 'static);
@@ -154,6 +162,14 @@ impl Property for String {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
+
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut _ as *mut u8
+    }
 }
 
 impl Property for bool {
@@ -194,6 +210,14 @@ impl Property for bool {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
+
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut _ as *mut u8
+    }
 }
 
 impl Property for usize {
@@ -252,6 +276,14 @@ impl Property for usize {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
+
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut _ as *mut u8
+    }
 }
 
 impl Property for u64 {
@@ -310,6 +342,14 @@ impl Property for u64 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
+
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut _ as *mut u8
+    }
 }
 
 impl Property for u32 {
@@ -368,6 +408,14 @@ impl Property for u32 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
+
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut _ as *mut u8
+    }
 }
 
 impl Property for u16 {
@@ -426,6 +474,14 @@ impl Property for u16 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
+
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut _ as *mut u8
+    }
 }
 
 impl Property for u8 {
@@ -484,6 +540,14 @@ impl Property for u8 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
+
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut _ as *mut u8
+    }
 }
 
 impl Property for isize {
@@ -542,6 +606,14 @@ impl Property for isize {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
+
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut _ as *mut u8
+    }
 }
 
 impl Property for i64 {
@@ -600,6 +672,14 @@ impl Property for i64 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
+
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut _ as *mut u8
+    }
 }
 
 impl Property for i32 {
@@ -658,6 +738,14 @@ impl Property for i32 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
+
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut _ as *mut u8
+    }
 }
 
 impl Property for i16 {
@@ -716,6 +804,14 @@ impl Property for i16 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
+
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut _ as *mut u8
+    }
 }
 
 impl Property for i8 {
@@ -774,6 +870,14 @@ impl Property for i8 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
+
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut _ as *mut u8
+    }
 }
 
 impl Property for f32 {
@@ -816,6 +920,14 @@ impl Property for f32 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
+
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut _ as *mut u8
+    }
 }
 
 impl Property for f64 {
@@ -858,4 +970,12 @@ impl Property for f64 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
+
+    fn as_ptr(&self) -> *const u8 {
+        self as *const _ as *const u8
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut _ as *mut u8
+    }
 }
diff --git a/crates/bevy_property/src/property.rs b/crates/bevy_property/src/property.rs
index 6385531f751de..73ec4c77040e1 100644
--- a/crates/bevy_property/src/property.rs
+++ b/crates/bevy_property/src/property.rs
@@ -24,6 +24,8 @@ pub trait Property: Send + Sync + Any + 'static {
         None
     }
     fn serializable<'a>(&'a self, registry: &'a PropertyTypeRegistry) -> Serializable<'a>;
+    fn as_ptr(&self) -> *const u8;
+    fn as_mut_ptr(&mut self) -> *mut u8;
 }
 
 pub trait DeserializeProperty {
diff --git a/src/default_plugins.rs b/src/default_plugins.rs
index 71432abddb244..b28d6e6b1e617 100644
--- a/src/default_plugins.rs
+++ b/src/default_plugins.rs
@@ -34,11 +34,11 @@ impl PluginGroup for DefaultPlugins {
         #[cfg(feature = "bevy_gilrs")]
         group.add(bevy_gilrs::GilrsPlugin::default());
 
-        #[cfg(feature = "bevy_gltf")]
-        {
-            group.add(bevy_gltf::GltfPlugin::default());
-            group.add(bevy_skinned_mesh::MeshSkinPlugin::default());
-        }
+        #[cfg(feature = "bevy_animation")]
+        group.add(bevy_animation::AnimationPlugin::default());
+
+        #[cfg(all(feature = "bevy_gltf", feature = "bevy_animation"))]
+        group.add(bevy_gltf::GltfPlugin::default());
 
         #[cfg(feature = "bevy_winit")]
         group.add(bevy_winit::WinitPlugin::default());

From 93ebe534da051e1f2fea186a6cb39bc3c5862405 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sun, 8 Nov 2020 22:26:16 -0300
Subject: [PATCH 003/153] loading animations from gltf

---
 crates/bevy_animation/src/generic.rs     |  86 +++++-
 crates/bevy_animation/src/lerping.rs     |  11 +
 crates/bevy_animation/src/lib.rs         |   1 +
 crates/bevy_animation/src/skined_mesh.rs |   6 +-
 crates/bevy_animation/src/util.rs        | 350 +++++++++++++++++++++++
 crates/bevy_gltf/src/loader.rs           | 208 +++++++++++---
 6 files changed, 608 insertions(+), 54 deletions(-)
 create mode 100644 crates/bevy_animation/src/util.rs

diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 4e65379660862..03b9c4bb81263 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -1,17 +1,15 @@
 use anyhow::Result;
-use bevy_app::prelude::*;
-use bevy_asset::{AddAsset, AssetLoader, Assets, Handle, LoadedAsset};
+use bevy_asset::{Assets, Handle};
 use bevy_core::prelude::*;
 use bevy_ecs::prelude::*;
-use bevy_ecs::{MapEntities, TypeAccess};
-use bevy_math::{Quat, Vec3, Vec4};
+use bevy_ecs::TypeAccess;
+use bevy_math::prelude::*;
 use bevy_property::Properties;
 use bevy_property::PropertyType;
 use bevy_transform::prelude::*;
 use bevy_type_registry::{TypeRegistry, TypeUuid};
 use serde::{Deserialize, Serialize};
 use std::any::TypeId;
-use std::collections::HashMap;
 
 use super::lerping::LerpValue;
 
@@ -25,7 +23,7 @@ use super::lerping::LerpValue;
 pub struct Clip {
     #[serde(default = "clip_default_warp")]
     pub warp: bool,
-    length: f32,
+    pub length: f32,
     //pub bones: Vec<Bone>,
     /// Property to be animated will be in the format `"path/to/named_entity@Transform.translation.x"`
     /// where the left side `@` defines a path to the entity to animate,
@@ -40,6 +38,44 @@ fn clip_default_warp() -> bool {
     true
 }
 
+impl Clip {
+    pub fn add_animated_prop(&mut self, property_path: String, value: Value) {
+        self.properties.push(property_path);
+        self.values.push(value);
+    }
+
+    pub fn iter(&mut self) -> impl Iterator<Item = (&String, &Value)> {
+        self.properties.iter().zip(self.values.iter())
+    }
+
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (&mut String, &mut Value)> {
+        self.properties.iter_mut().zip(self.values.iter_mut())
+    }
+
+    pub fn optimize(&mut self) {
+        // // SAFE: No string gets dropped and are only used during for sorting
+        // let props: &[String] = unsafe { &*(&self.properties[..] as *const _) };
+
+        // let mut indexes = props
+        //     .iter()
+        //     .enumerate()
+        //     .map(|(i, n)| (i, i, n))
+        //     .collect::<Vec<_>>();
+
+        // indexes.sort_by(|a, b| a.2.partial_cmp(b.2).unwrap());
+        // indexes.iter_mut().enumerate().for_each(|(i, (j, k, _))| {
+        //     *k = i;
+        // });
+        // // It's necessary to sort
+        // indexes.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
+
+        // for (i, j, _) in indexes {
+        //     self.properties[..].swap(i, j);
+        //     self.values[..].swap(i, j);
+        // }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 pub enum Value {
     Float(Curve<f32>),
@@ -49,6 +85,15 @@ pub enum Value {
 }
 
 impl Value {
+    pub fn samples_mut(&mut self) -> impl Iterator<Item = &mut f32> {
+        match self {
+            Value::Float(c) => c.samples.iter_mut(),
+            Value::Vec3(c) => c.samples.iter_mut(),
+            Value::Vec4(c) => c.samples.iter_mut(),
+            Value::Quat(c) => c.samples.iter_mut(),
+        }
+    }
+
     pub fn type_name(&self) -> &str {
         use std::any::type_name;
         match self {
@@ -71,6 +116,12 @@ impl<T> Curve<T>
 where
     T: LerpValue,
 {
+    pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
+        // TODO: Proper error handling
+        assert!(samples.len() == values.len());
+        Self { samples, values }
+    }
+
     /// Samples the curve beginning from the keyframe at index
     pub fn sample(&self, mut index: usize, time: f32) -> (usize, T) {
         // Adjust for the current keyframe index
@@ -150,6 +201,15 @@ impl Default for Animator {
     }
 }
 
+impl Animator {
+    pub fn add_clip(&mut self, clip: Handle<Clip>) {
+        if self.animations.contains(&clip) {
+            return;
+        }
+        self.animations.push(clip);
+    }
+}
+
 /// Instance info to be animated
 #[derive(Default, Debug)]
 struct Instance {
@@ -162,13 +222,15 @@ struct Instance {
 /// Fetches entities and properties to animate
 pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
     // Fetch useful resources
-    let type_registry = resources
-        .get_thread_local::<TypeRegistry>()
-        .expect("missing TypeRegistry");
+    let type_registry = resources.get_thread_local::<TypeRegistry>();
+    let clips = resources.get_thread_local::<Assets<Clip>>();
+
+    if type_registry.is_none() || clips.is_none() {
+        return;
+    }
 
-    let clips = resources
-        .get_thread_local::<Assets<Clip>>()
-        .expect("missing Assets<Clip>");
+    let type_registry = type_registry.unwrap();
+    let clips = clips.unwrap();
 
     // Build queries
     let type_access = TypeAccess::default();
diff --git a/crates/bevy_animation/src/lerping.rs b/crates/bevy_animation/src/lerping.rs
index 1da6a12963012..1e69912b89b09 100644
--- a/crates/bevy_animation/src/lerping.rs
+++ b/crates/bevy_animation/src/lerping.rs
@@ -1,3 +1,4 @@
+// use bevy_asset::prelude::*;
 use bevy_math::prelude::*;
 
 pub trait LerpValue: Copy {
@@ -19,3 +20,13 @@ impl LerpValue for Quat {
         Vec4::lerp(a.into(), b.into(), t).normalize().into()
     }
 }
+
+// impl<T: 'static> LerpValue for Handle<T> {
+//     fn lerp(a: Self, b: Self, t: f32) -> Self {
+//         if t > 0.5 {
+//             b
+//         } else {
+//             a
+//         }
+//     }
+// }
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 4e521cfc89840..be60d81df4bb6 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -9,6 +9,7 @@ use crate::skined_mesh::*;
 pub mod generic;
 mod lerping;
 pub mod skined_mesh;
+//mod util;
 
 pub mod prelude {
     pub use crate::generic::*;
diff --git a/crates/bevy_animation/src/skined_mesh.rs b/crates/bevy_animation/src/skined_mesh.rs
index 5b11adbe0ec2e..0f074ea62f5e2 100644
--- a/crates/bevy_animation/src/skined_mesh.rs
+++ b/crates/bevy_animation/src/skined_mesh.rs
@@ -1,6 +1,5 @@
 // TODO: Later merge with bevy_animation
-use bevy_app::prelude::*;
-use bevy_asset::{AddAsset, Assets, Handle};
+use bevy_asset::{Assets, Handle};
 use bevy_core::Name;
 use bevy_ecs::prelude::*;
 use bevy_ecs::MapEntities;
@@ -8,9 +7,8 @@ use bevy_math::Mat4;
 use bevy_property::Properties;
 use bevy_render::mesh::Mesh;
 use bevy_transform::prelude::*;
-use bevy_type_registry::{RegisterType, TypeUuid};
+use bevy_type_registry::TypeUuid;
 use smallvec::SmallVec;
-// use serde::{Deserialize, Serialize};
 
 /// Skin asset used by the mesh skinning process
 #[derive(Debug, Clone, TypeUuid)]
diff --git a/crates/bevy_animation/src/util.rs b/crates/bevy_animation/src/util.rs
new file mode 100644
index 0000000000000..0ef130acf0b6d
--- /dev/null
+++ b/crates/bevy_animation/src/util.rs
@@ -0,0 +1,350 @@
+use std::mem::{self, size_of};
+use std::ptr;
+
+////////////////////////////////////////////////////////////////////////////////
+// Sorting for SOA
+////////////////////////////////////////////////////////////////////////////////
+
+/// Inserts `v[0]` into pre-sorted sequence `v[1..]` so that whole `v[..]` becomes sorted.
+///
+/// This is the integral subroutine of insertion sort.
+fn insert_head<T, U, F>(v: &mut [T], u: &mut [U], is_less: &mut F)
+where
+    F: FnMut(&T, &T) -> bool,
+{
+    if v.len() >= 2 && is_less(&v[1], &v[0]) {
+        unsafe {
+            // There are three ways to implement insertion here:
+            //
+            // 1. Swap adjacent elements until the first one gets to its final destination.
+            //    However, this way we copy data around more than is necessary. If elements are big
+            //    structures (costly to copy), this method will be slow.
+            //
+            // 2. Iterate until the right place for the first element is found. Then shift the
+            //    elements succeeding it to make room for it and finally place it into the
+            //    remaining hole. This is a good method.
+            //
+            // 3. Copy the first element into a temporary variable. Iterate until the right place
+            //    for it is found. As we go along, copy every traversed element into the slot
+            //    preceding it. Finally, copy data from the temporary variable into the remaining
+            //    hole. This method is very good. Benchmarks demonstrated slightly better
+            //    performance than with the 2nd method.
+            //
+            // All methods were benchmarked, and the 3rd showed best results. So we chose that one.
+            let mut tmp = mem::ManuallyDrop::new(ptr::read(&v[0]));
+
+            // Intermediate state of the insertion process is always tracked by `hole`, which
+            // serves two purposes:
+            // 1. Protects integrity of `v` from panics in `is_less`.
+            // 2. Fills the remaining hole in `v` in the end.
+            //
+            // Panic safety:
+            //
+            // If `is_less` panics at any point during the process, `hole` will get dropped and
+            // fill the hole in `v` with `tmp`, thus ensuring that `v` still holds every object it
+            // initially held exactly once.
+            let mut hole = InsertionHole {
+                src: &mut *tmp,
+                dest: &mut v[1],
+            };
+            ptr::copy_nonoverlapping(&v[1], &mut v[0], 1);
+
+            for i in 2..v.len() {
+                if !is_less(&v[i], &*tmp) {
+                    break;
+                }
+                ptr::copy_nonoverlapping(&v[i], &mut v[i - 1], 1);
+                hole.dest = &mut v[i];
+            }
+            // `hole` gets dropped and thus copies `tmp` into the remaining hole in `v`.
+        }
+    }
+
+    // When dropped, copies from `src` into `dest`.
+    struct InsertionHole<T> {
+        src: *mut T,
+        dest: *mut T,
+    }
+
+    impl<T> Drop for InsertionHole<T> {
+        fn drop(&mut self) {
+            unsafe {
+                ptr::copy_nonoverlapping(self.src, self.dest, 1);
+            }
+        }
+    }
+}
+
+/// Merges non-decreasing runs `v[..mid]` and `v[mid..]` using `buf` as temporary storage, and
+/// stores the result into `v[..]`.
+///
+/// # Safety
+///
+/// The two slices must be non-empty and `mid` must be in bounds. Buffer `buf` must be long enough
+/// to hold a copy of the shorter slice. Also, `T` must not be a zero-sized type.
+unsafe fn merge<T, U, F>(v: &mut [T], u: &mut [U], mid: usize, buf: *mut T, is_less: &mut F)
+where
+    F: FnMut(&T, &T) -> bool,
+{
+    let len = v.len();
+    let v = v.as_mut_ptr();
+    let (v_mid, v_end) = unsafe { (v.add(mid), v.add(len)) };
+
+    // The merge process first copies the shorter run into `buf`. Then it traces the newly copied
+    // run and the longer run forwards (or backwards), comparing their next unconsumed elements and
+    // copying the lesser (or greater) one into `v`.
+    //
+    // As soon as the shorter run is fully consumed, the process is done. If the longer run gets
+    // consumed first, then we must copy whatever is left of the shorter run into the remaining
+    // hole in `v`.
+    //
+    // Intermediate state of the process is always tracked by `hole`, which serves two purposes:
+    // 1. Protects integrity of `v` from panics in `is_less`.
+    // 2. Fills the remaining hole in `v` if the longer run gets consumed first.
+    //
+    // Panic safety:
+    //
+    // If `is_less` panics at any point during the process, `hole` will get dropped and fill the
+    // hole in `v` with the unconsumed range in `buf`, thus ensuring that `v` still holds every
+    // object it initially held exactly once.
+    let mut hole;
+
+    if mid <= len - mid {
+        // The left run is shorter.
+        unsafe {
+            ptr::copy_nonoverlapping(v, buf, mid);
+            hole = MergeHole {
+                start: buf,
+                end: buf.add(mid),
+                dest: v,
+            };
+        }
+
+        // Initially, these pointers point to the beginnings of their arrays.
+        let left = &mut hole.start;
+        let mut right = v_mid;
+        let out = &mut hole.dest;
+
+        while *left < hole.end && right < v_end {
+            // Consume the lesser side.
+            // If equal, prefer the left run to maintain stability.
+            unsafe {
+                let to_copy = if is_less(&*right, &**left) {
+                    get_and_increment(&mut right)
+                } else {
+                    get_and_increment(left)
+                };
+                ptr::copy_nonoverlapping(to_copy, get_and_increment(out), 1);
+            }
+        }
+    } else {
+        // The right run is shorter.
+        unsafe {
+            ptr::copy_nonoverlapping(v_mid, buf, len - mid);
+            hole = MergeHole {
+                start: buf,
+                end: buf.add(len - mid),
+                dest: v_mid,
+            };
+        }
+
+        // Initially, these pointers point past the ends of their arrays.
+        let left = &mut hole.dest;
+        let right = &mut hole.end;
+        let mut out = v_end;
+
+        while v < *left && buf < *right {
+            // Consume the greater side.
+            // If equal, prefer the right run to maintain stability.
+            unsafe {
+                let to_copy = if is_less(&*right.offset(-1), &*left.offset(-1)) {
+                    decrement_and_get(left)
+                } else {
+                    decrement_and_get(right)
+                };
+                ptr::copy_nonoverlapping(to_copy, decrement_and_get(&mut out), 1);
+            }
+        }
+    }
+    // Finally, `hole` gets dropped. If the shorter run was not fully consumed, whatever remains of
+    // it will now be copied into the hole in `v`.
+
+    unsafe fn get_and_increment<T>(ptr: &mut *mut T) -> *mut T {
+        let old = *ptr;
+        *ptr = unsafe { ptr.offset(1) };
+        old
+    }
+
+    unsafe fn decrement_and_get<T>(ptr: &mut *mut T) -> *mut T {
+        *ptr = unsafe { ptr.offset(-1) };
+        *ptr
+    }
+
+    // When dropped, copies the range `start..end` into `dest..`.
+    struct MergeHole<T> {
+        start: *mut T,
+        end: *mut T,
+        dest: *mut T,
+    }
+
+    impl<T> Drop for MergeHole<T> {
+        fn drop(&mut self) {
+            // `T` is not a zero-sized type, so it's okay to divide by its size.
+            let len = (self.end as usize - self.start as usize) / mem::size_of::<T>();
+            unsafe {
+                ptr::copy_nonoverlapping(self.start, self.dest, len);
+            }
+        }
+    }
+}
+
+/// This merge sort borrows some (but not all) ideas from TimSort, which is described in detail
+/// [here](http://svn.python.org/projects/python/trunk/Objects/listsort.txt).
+///
+/// The algorithm identifies strictly descending and non-descending subsequences, which are called
+/// natural runs. There is a stack of pending runs yet to be merged. Each newly found run is pushed
+/// onto the stack, and then some pairs of adjacent runs are merged until these two invariants are
+/// satisfied:
+///
+/// 1. for every `i` in `1..runs.len()`: `runs[i - 1].len > runs[i].len`
+/// 2. for every `i` in `2..runs.len()`: `runs[i - 2].len > runs[i - 1].len + runs[i].len`
+///
+/// The invariants ensure that the total running time is `O(n * log(n))` worst-case.
+pub fn merge_sort2<T, U, F>(v: &mut [T], u: &mut [U], mut is_less: F)
+where
+    F: FnMut(&T, &T) -> bool,
+{
+    debug_assert!(u.len() == v.len());
+
+    // Slices of up to this length get sorted using insertion sort.
+    const MAX_INSERTION: usize = 20;
+    // Very short runs are extended using insertion sort to span at least this many elements.
+    const MIN_RUN: usize = 10;
+
+    // Sorting has no meaningful behavior on zero-sized types.
+    if size_of::<T>() == 0 {
+        return;
+    }
+
+    let len = v.len();
+
+    // Short arrays get sorted in-place via insertion sort to avoid allocations.
+    if len <= MAX_INSERTION {
+        if len >= 2 {
+            for i in (0..len - 1).rev() {
+                insert_head(&mut v[i..], &mut u[i..], &mut is_less);
+            }
+        }
+        return;
+    }
+
+    // Allocate a buffer to use as scratch memory. We keep the length 0 so we can keep in it
+    // shallow copies of the contents of `v` without risking the dtors running on copies if
+    // `is_less` panics. When merging two sorted runs, this buffer holds a copy of the shorter run,
+    // which will always have length at most `len / 2`.
+    let mut buf = Vec::with_capacity(len / 2);
+
+    // In order to identify natural runs in `v`, we traverse it backwards. That might seem like a
+    // strange decision, but consider the fact that merges more often go in the opposite direction
+    // (forwards). According to benchmarks, merging forwards is slightly faster than merging
+    // backwards. To conclude, identifying runs by traversing backwards improves performance.
+    let mut runs = vec![];
+    let mut end = len;
+    while end > 0 {
+        // Find the next natural run, and reverse it if it's strictly descending.
+        let mut start = end - 1;
+        if start > 0 {
+            start -= 1;
+            unsafe {
+                if is_less(v.get_unchecked(start + 1), v.get_unchecked(start)) {
+                    while start > 0 && is_less(v.get_unchecked(start), v.get_unchecked(start - 1)) {
+                        start -= 1;
+                    }
+                    v[start..end].reverse();
+                    u[start..end].reverse();
+                } else {
+                    while start > 0 && !is_less(v.get_unchecked(start), v.get_unchecked(start - 1))
+                    {
+                        start -= 1;
+                    }
+                }
+            }
+        }
+
+        // Insert some more elements into the run if it's too short. Insertion sort is faster than
+        // merge sort on short sequences, so this significantly improves performance.
+        while start > 0 && end - start < MIN_RUN {
+            start -= 1;
+            insert_head(&mut v[start..end], &mut u[start..end], &mut is_less);
+        }
+
+        // Push this run onto the stack.
+        runs.push(Run {
+            start,
+            len: end - start,
+        });
+        end = start;
+
+        // Merge some pairs of adjacent runs to satisfy the invariants.
+        while let Some(r) = collapse(&runs) {
+            let left = runs[r + 1];
+            let right = runs[r];
+            unsafe {
+                merge(
+                    &mut v[left.start..right.start + right.len],
+                    &mut u[left.start..right.start + right.len],
+                    left.len,
+                    buf.as_mut_ptr(),
+                    &mut is_less,
+                );
+            }
+            runs[r] = Run {
+                start: left.start,
+                len: left.len + right.len,
+            };
+            runs.remove(r + 1);
+        }
+    }
+
+    // Finally, exactly one run must remain in the stack.
+    debug_assert!(runs.len() == 1 && runs[0].start == 0 && runs[0].len == len);
+
+    // Examines the stack of runs and identifies the next pair of runs to merge. More specifically,
+    // if `Some(r)` is returned, that means `runs[r]` and `runs[r + 1]` must be merged next. If the
+    // algorithm should continue building a new run instead, `None` is returned.
+    //
+    // TimSort is infamous for its buggy implementations, as described here:
+    // http://envisage-project.eu/timsort-specification-and-verification/
+    //
+    // The gist of the story is: we must enforce the invariants on the top four runs on the stack.
+    // Enforcing them on just top three is not sufficient to ensure that the invariants will still
+    // hold for *all* runs in the stack.
+    //
+    // This function correctly checks invariants for the top four runs. Additionally, if the top
+    // run starts at index 0, it will always demand a merge operation until the stack is fully
+    // collapsed, in order to complete the sort.
+    #[inline]
+    fn collapse(runs: &[Run]) -> Option<usize> {
+        let n = runs.len();
+        if n >= 2
+            && (runs[n - 1].start == 0
+                || runs[n - 2].len <= runs[n - 1].len
+                || (n >= 3 && runs[n - 3].len <= runs[n - 2].len + runs[n - 1].len)
+                || (n >= 4 && runs[n - 4].len <= runs[n - 3].len + runs[n - 2].len))
+        {
+            if n >= 3 && runs[n - 3].len < runs[n - 1].len {
+                Some(n - 3)
+            } else {
+                Some(n - 2)
+            }
+        } else {
+            None
+        }
+    }
+
+    #[derive(Clone, Copy)]
+    struct Run {
+        start: usize,
+        len: usize,
+    }
+}
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 90848469ac0d9..61145a8b60ca6 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -3,7 +3,7 @@ use bevy_animation::prelude::*;
 use bevy_asset::{AssetIoError, AssetLoader, AssetPath, Handle, LoadContext, LoadedAsset};
 use bevy_core::Name;
 use bevy_ecs::{bevy_utils::BoxedFuture, Entity, World, WorldBuilderSource};
-use bevy_math::Mat4;
+use bevy_math::prelude::*;
 use bevy_pbr::prelude::{PbrComponents, StandardMaterial};
 use bevy_render::{
     mesh::{Indices, Mesh, VertexAttributeValues},
@@ -17,6 +17,7 @@ use bevy_transform::{
     prelude::{GlobalTransform, Transform},
 };
 use gltf::{
+    animation::{util::ReadOutputs, Interpolation},
     mesh::Mode,
     texture::{MagFilter, MinFilter, WrappingMode},
     Primitive,
@@ -242,6 +243,129 @@ async fn load_gltf<'a, 'b>(
         )
     }
 
+    let mut clips_handles: Vec<Handle<Clip>> = vec![];
+    for animation in gltf.animations() {
+        let anim_label = animation_label(&animation);
+        if load_context.has_labeled_asset(&anim_label) {
+            panic!("non unique animation labels");
+        }
+
+        let mut clip = Clip::default();
+        clip.warp = true; // Enable warping by default
+
+        let mut start_time = f32::MAX;
+
+        // Each chanel defines how to sample the data and where it will be written
+        for channel in animation.channels() {
+            let sampler = channel.sampler();
+            // TODO: Support cubic spline interpolation
+            assert!(sampler.interpolation() != Interpolation::CubicSpline);
+
+            let target = channel.target();
+
+            // Find node path
+            let node = target.node();
+            let mut property_path = node
+                .name()
+                .expect("unnamed node can't be animated")
+                .to_string();
+            let mut parent = parents[node.index()];
+            while let Some(p) = parent {
+                let node = gltf.nodes().nth(p).unwrap();
+                let name = node
+                    .name()
+                    .expect("unnamed node can't be parent of an animated node");
+                property_path = format!("{}/{}", name, property_path);
+                parent = parents[node.index()];
+            }
+
+            let reader = channel.reader(|buffer| Some(&buffer_data[buffer.index()]));
+            let time_stamps = reader.read_inputs().unwrap().collect::<Vec<_>>();
+
+            // Start time
+            start_time = start_time.min(time_stamps.get(0).copied().unwrap_or(0.0));
+
+            // Figure out clip duration
+            clip.length = clip.length.max(time_stamps.last().copied().unwrap_or(0.0));
+
+            match reader.read_outputs().unwrap() {
+                ReadOutputs::Translations(values) => {
+                    let values = values.map(|v| Vec3::from(v)).collect::<Vec<_>>();
+                    property_path += "@Transform.translation";
+                    clip.add_animated_prop(
+                        property_path,
+                        Value::Vec3(Curve::new(time_stamps, values)),
+                    )
+
+                    // TODO: This is a runtime importer so here's no place for further optimizations
+                }
+                ReadOutputs::Rotations(values) => {
+                    let mut values = values.into_f32().map(|v| Quat::from(v)).collect::<Vec<_>>();
+
+                    // NOTE: To avoid 2pi rotations in between frames we keep the w value always positive
+                    // this happens when decomposing frames from Mat4, each frame snapshot by it self is
+                    // correct but the motion is wrong, causing a in between frames 360º spin around the
+                    // quaternion axis;
+                    //
+                    // When quaternion changes its sign: https://math.stackexchange.com/questions/2016282/negative-quaternion
+
+                    // NOTE: Making sure w > 0 is not enough
+                    // for r in rotation.iter_mut() {
+                    //     if r[3] < 0.0 {
+                    //         *r = -*r;
+                    //     }
+                    //     // NODE: No need to normalize the quaternion
+                    // }
+
+                    // NOTE: Same problem than before but in a different way, some times the quaternion
+                    // axis will flip in between frames (even ensuring w > 0). So the function `is_axis_flipped`
+                    // will check if they are colinear and if they flipped their sing.
+                    if values.len() > 1 {
+                        for i in 0..values.len() - 1 {
+                            if is_axis_flipped(values[i], values[i + 1]) {
+                                let r = &mut values[i + 1];
+                                *r = -(*r);
+                            }
+                        }
+                    }
+
+                    property_path += "@Transform.rotation";
+                    clip.add_animated_prop(
+                        property_path,
+                        Value::Quat(Curve::new(time_stamps, values)),
+                    );
+                }
+                ReadOutputs::Scales(values) => {
+                    let values = values.map(|v| Vec3::from(v)).collect::<Vec<_>>();
+
+                    property_path += "@Transform.scale";
+                    clip.add_animated_prop(
+                        property_path,
+                        Value::Vec3(Curve::new(time_stamps, values)),
+                    )
+                }
+                ReadOutputs::MorphTargetWeights(_) => {
+                    unimplemented!("morph targets aren't current supported")
+                }
+            }
+        }
+
+        // Make sure the start frame is always 0.0
+        for (_, value) in clip.iter_mut() {
+            value.samples_mut().for_each(|x| *x -= start_time);
+        }
+
+        clip.length -= start_time;
+
+        // Sort properties by path to optimize clip execution
+        clip.optimize();
+
+        load_context.set_labeled_asset(&anim_label, LoadedAsset::new(clip));
+
+        let path = AssetPath::new_ref(load_context.path(), Some(&anim_label));
+        clips_handles.push(load_context.get_handle(path));
+    }
+
     // Each node will be mapped to a slot inside this `entity_lookup`
     let mut entity_lookup = vec![];
     entity_lookup.resize_with(gltf.nodes().count(), || None);
@@ -253,6 +377,13 @@ async fn load_gltf<'a, 'b>(
             world_builder.with(Name(name.to_string()));
         }
 
+        // Animator component
+        let mut animator = Animator::default();
+        for clip_handle in &clips_handles {
+            animator.add_clip(clip_handle.clone());
+        }
+        world_builder.with(animator);
+
         world_builder.with_children(|parent| {
             for node in scene.nodes() {
                 load_node(&node, &node, parent, load_context, &mut entity_lookup, 0);
@@ -347,10 +478,6 @@ fn load_node(
     });
 }
 
-fn skin_label(skin: &gltf::Skin) -> String {
-    format!("Skin{}", skin.index())
-}
-
 fn primitive_label(mesh: &gltf::Mesh, primitive: &Primitive) -> String {
     format!("Mesh{}/Primitive{}", mesh.index(), primitive.index())
 }
@@ -367,6 +494,21 @@ fn texture_label(texture: &gltf::Texture) -> String {
     format!("Texture{}", texture.index())
 }
 
+fn skin_label(skin: &gltf::Skin) -> String {
+    format!("Skin{}", skin.index())
+}
+
+fn animation_label(animation: &gltf::Animation) -> String {
+    // NOTE: I kind really want these to be properly named, so it's possible to
+    // reference tha right animation, but also want the indexed version
+    // for workflows with 1 animation per file
+    // animation.name().map_or_else(
+    //     || format!("Anims/{}", animation.index()),
+    //     |name| format!("Anims/{}", name),
+    // )
+    format!("Anim{}", animation.index())
+}
+
 fn texture_sampler(texture: &gltf::Texture) -> Result<SamplerDescriptor, GltfError> {
     let gltf_sampler = texture.sampler();
 
@@ -452,36 +594,26 @@ async fn load_buffers(
     Ok(buffer_data)
 }
 
-// const EPSILON: f32 = 1.0e-8;
-// const EPSILON_SQUARED: f32 = EPSILON * EPSILON;
-
-// fn angle(a: Quat, b: Quat) -> f32 {
-//     let dot = a.dot(b);
-//     if dot > (1.0 - EPSILON) {
-//         0.0
-//     } else {
-//         dot.abs().min(1.0).acos() * 2.0 * 180.0 / std::f32::consts::PI
-//     }
-// }
-
-// fn axis(a: Quat) -> Vec3 {
-//     let (x, y, z, w) = Vec4::from(a).into();
-//     let scale_sq = (1.0 - w * w).max(0.0);
-//     if scale_sq >= EPSILON_SQUARED {
-//         Vec3::new(x, y, z) / scale_sq.sqrt()
-//     } else {
-//         Vec3::unit_x()
-//     }
-// }
-
-// fn is_axis_flipped(a: Quat, b: Quat) -> bool {
-//     let dot = axis(a).dot(axis(b));
-//     dbg!(dot);
-//     if (1.0 - dot.abs()) > 0.1 {
-//         false
-//     } else {
-//         // Quaternion axis are (almost) colinear
-//         // but heir axis are opposing to each other
-//         dot < 0.0
-//     }
-// }
+const EPSILON: f32 = 1.0e-8;
+const EPSILON_SQUARED: f32 = EPSILON * EPSILON;
+
+fn axis(a: Quat) -> Vec3 {
+    let (x, y, z, w) = Vec4::from(a).into();
+    let scale_sq = (1.0 - w * w).max(0.0);
+    if scale_sq >= EPSILON_SQUARED {
+        Vec3::new(x, y, z) / scale_sq.sqrt()
+    } else {
+        Vec3::unit_x()
+    }
+}
+
+fn is_axis_flipped(a: Quat, b: Quat) -> bool {
+    let dot = axis(a).dot(axis(b));
+    if (1.0 - dot.abs()) > 0.1 {
+        false
+    } else {
+        // Quaternion axis are (almost) colinear
+        // but heir axis are opposing to each other
+        dot < 0.0
+    }
+}

From 41b5fefa484c2cee3dbc9d461f147f3de0d51d83 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sun, 8 Nov 2020 23:47:37 -0300
Subject: [PATCH 004/153] feching properties

---
 crates/bevy_animation/src/generic.rs | 58 +++++++++++++++++++++++-----
 crates/bevy_animation/src/lib.rs     | 13 ++++---
 src/lib.rs                           |  8 +++-
 3 files changed, 62 insertions(+), 17 deletions(-)

diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 03b9c4bb81263..3e62ba6e9cd2b 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -208,22 +208,39 @@ impl Animator {
         }
         self.animations.push(clip);
     }
+
+    pub fn clips_len(&self) -> usize {
+        self.animations.len()
+    }
 }
 
 /// Instance info to be animated
-#[derive(Default, Debug)]
+#[derive(Debug)]
 struct Instance {
+    dirty: bool,
     valid: Vec<bool>,
     entities: Vec<Entity>,
     components: Vec<TypeId>,
     properties: Vec<isize>,
 }
 
+impl Default for Instance {
+    fn default() -> Self {
+        Self {
+            dirty: true,
+            valid: vec![],
+            entities: vec![],
+            components: vec![],
+            properties: vec![],
+        }
+    }
+}
+
 /// Fetches entities and properties to animate
 pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
     // Fetch useful resources
-    let type_registry = resources.get_thread_local::<TypeRegistry>();
-    let clips = resources.get_thread_local::<Assets<Clip>>();
+    let type_registry = resources.get::<TypeRegistry>();
+    let clips = resources.get::<Assets<Clip>>();
 
     if type_registry.is_none() || clips.is_none() {
         return;
@@ -235,6 +252,7 @@ pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
     // Build queries
     let type_access = TypeAccess::default();
     let mut animators_query: Query<(&mut Animator, &Children)> = Query::new(&world, &type_access);
+    //let animators_query = unsafe { world.query_unchecked::<(&mut Animator, &Children)>() };
     let entities_query: Query<(Entity, &Name, &Children)> = Query::new(&world, &type_access);
 
     // TODO: Parallelize this loop
@@ -246,7 +264,9 @@ pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
         // TODO: Needs to be updated when a clip changes
         let animations_count = animator.animations.len();
         if animations_count == animator.instances.len() {
-            continue;
+            if animator.instances.iter().all(|item| !item.dirty) {
+                break;
+            }
         }
 
         animator
@@ -254,9 +274,14 @@ pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
             .resize_with(animations_count, || Default::default());
 
         for (clip_index, clip_handle) in animator.animations.iter().enumerate() {
+            let instance = &mut animator.instances[clip_index];
+            if !instance.dirty {
+                continue;
+            }
+
             if let Some(clip) = clips.get(clip_handle) {
                 // Get instance reference to modify during the function
-                let instance = &mut animator.instances[clip_index];
+                instance.dirty = false;
 
                 let mut paths = clip
                     .properties
@@ -290,8 +315,12 @@ pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
                 for parent in root_children.iter().copied() {
                     if let Ok((entity, name, children)) = entities_query.get(parent) {
                         let name = Some(name.0.as_str());
-                        if let Some(i) = hierarchy.iter().position(|level| *level == name) {
-                            hierarchy[i] = paths[i].0.next();
+                        for (i, level) in hierarchy.iter_mut().enumerate() {
+                            if *level != name {
+                                continue;
+                            }
+
+                            *level = paths[i].0.next();
                             entities[i] = entity;
                             valid[i] = true;
                             stack.push((i, children));
@@ -299,6 +328,7 @@ pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
                     }
                 }
                 // Fast educated search into the nested hierarchy
+                // TODO: Many identical queries for the same entity will happen here!
                 while let Some((i, parents)) = stack.pop() {
                     for parent in parents.iter().copied() {
                         if let Ok((entity, name, children)) = entities_query.get(parent) {
@@ -322,12 +352,12 @@ pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
                 properties.resize(paths.len(), 0);
 
                 // 2. Find components and properties in all entities that completed the path
-                for (i, path) in hierarchy.iter().enumerate() {
+                for (i, level) in hierarchy.iter().enumerate() {
                     if valid[i] {
                         // Not reached the entity at the path
-                        if path.is_none() {
+                        if level.is_some() {
                             valid[i] = false;
-                            break;
+                            continue;
                         }
 
                         let component = paths[i].1.next().unwrap_or("?");
@@ -391,6 +421,14 @@ pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
                         }
                     }
                 }
+
+                // for (i, valid) in valid.iter().copied().enumerate() {
+                //     if valid {
+                //         println!("found: {}", &clip.properties[i]);
+                //     } else {
+                //         println!("missing: {}", &clip.properties[i]);
+                //     }
+                // }
             }
         }
     }
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index be60d81df4bb6..7b685c79abcaa 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -3,16 +3,16 @@ use bevy_asset::AddAsset;
 use bevy_ecs::prelude::*;
 use bevy_type_registry::RegisterType;
 
-use crate::generic::*;
-use crate::skined_mesh::*;
-
 pub mod generic;
-mod lerping;
-pub mod skined_mesh;
+pub mod lerping;
+mod skined_mesh;
+
+pub use crate::generic::*;
+pub use crate::skined_mesh::*;
 //mod util;
 
 pub mod prelude {
-    pub use crate::generic::*;
+    pub use crate::generic::{Animator, Clip, Curve, Value};
     pub use crate::lerping::LerpValue;
     pub use crate::skined_mesh::{MeshSkin, MeshSkinner};
 }
@@ -30,6 +30,7 @@ impl Plugin for AnimationPlugin {
         app.add_asset::<Clip>()
             .add_stage_after(stage::UPDATE, stage::ANIMATE)
             //.add_asset_loader(ClipLoader)
+            .register_component::<Animator>()
             .add_system_to_stage(stage::ANIMATE, animator_fetch.thread_local_system())
             //.add_system_to_stage(stage::ANIMATE, animator_update.system())
             .add_asset::<MeshSkin>()
diff --git a/src/lib.rs b/src/lib.rs
index c3f8893919e80..22db9cdda91b0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -120,12 +120,18 @@ pub mod audio {
     pub use bevy_audio::*;
 }
 
-#[cfg(feature = "bevy_gltf")]
+#[cfg(all(feature = "bevy_gltf", feature = "bevy_animation"))]
 pub mod gltf {
     //! Support for GLTF file loading.
     pub use bevy_gltf::*;
 }
 
+#[cfg(feature = "bevy_animation")]
+pub mod animation {
+    //! Support for animations
+    pub use bevy_animation::*;
+}
+
 #[cfg(feature = "bevy_pbr")]
 pub mod pbr {
     //! Physically based rendering.

From ffa6ad307f713723c894325976dbe984340c865b Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Wed, 11 Nov 2020 19:11:18 -0300
Subject: [PATCH 005/153] working animations!

---
 crates/bevy_animation/Cargo.toml         |   2 +
 crates/bevy_animation/src/generic.rs     | 277 ++++++++++++++---------
 crates/bevy_animation/src/lerping.rs     |  18 ++
 crates/bevy_animation/src/lib.rs         |  20 +-
 crates/bevy_animation/src/skined_mesh.rs | 207 +++++++++++++++--
 crates/bevy_gltf/src/loader.rs           |  11 +-
 6 files changed, 398 insertions(+), 137 deletions(-)

diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index 97ab4440c569b..cbabb5c4c0d65 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -11,8 +11,10 @@ bevy_app = { path = "../bevy_app", version = "0.3.0" }
 bevy_asset = { path = "../bevy_asset", version = "0.3.0" }
 bevy_core = { path = "../bevy_core", version = "0.3.0" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
+bevy_pbr = { path = "../bevy_pbr", version = "0.3.0" }
 bevy_math = { path = "../bevy_math", version = "0.3.0" }
 bevy_render = { path = "../bevy_render", version = "0.3.0" }
+#bevy_tasks = { path = "../bevy_tasks", version = "0.3.0" }
 bevy_transform = { path = "../bevy_transform", version = "0.3.0" }
 bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
 bevy_property = { path = "../bevy_property", version = "0.3.0" }
diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 3e62ba6e9cd2b..9e3c5ed28b1dc 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -2,7 +2,7 @@ use anyhow::Result;
 use bevy_asset::{Assets, Handle};
 use bevy_core::prelude::*;
 use bevy_ecs::prelude::*;
-use bevy_ecs::TypeAccess;
+use bevy_ecs::{Location, TypeAccess};
 use bevy_math::prelude::*;
 use bevy_property::Properties;
 use bevy_property::PropertyType;
@@ -24,7 +24,6 @@ pub struct Clip {
     #[serde(default = "clip_default_warp")]
     pub warp: bool,
     pub length: f32,
-    //pub bones: Vec<Bone>,
     /// Property to be animated will be in the format `"path/to/named_entity@Transform.translation.x"`
     /// where the left side `@` defines a path to the entity to animate,
     /// while the right side the path to a property to animate starting from the component.
@@ -159,15 +158,15 @@ where
 struct State {
     clip: usize,
     time: f32,
-    keyframe: Vec<KeyframeState>,
+    keyframe: Vec<usize>,
 }
 
-#[derive(Default, Debug, Clone, Properties)]
-struct KeyframeState {
-    position: usize,
-    rotation: usize,
-    scale: usize,
-}
+// #[derive(Default, Debug, Clone, Properties)]
+// struct KeyframeState {
+//     position: usize,
+//     rotation: usize,
+//     scale: usize,
+// }
 
 // #[derive(Default, Clone, Debug, Properties)]
 // struct Lerp {
@@ -180,7 +179,7 @@ struct KeyframeState {
 pub struct Animator {
     animations: Vec<Handle<Clip>>,
     #[property(ignore)]
-    instances: Vec<Instance>,
+    binds: Vec<ValueBind>,
     pub time_scale: f32,
     // hierarchy: Vec<()>,
     current: State,
@@ -192,7 +191,7 @@ impl Default for Animator {
     fn default() -> Self {
         Self {
             animations: vec![],
-            instances: vec![],
+            binds: vec![],
             time_scale: 1.0,
             current: State::default(),
             // next: None,
@@ -214,9 +213,8 @@ impl Animator {
     }
 }
 
-/// Instance info to be animated
 #[derive(Debug)]
-struct Instance {
+struct ValueBind {
     dirty: bool,
     valid: Vec<bool>,
     entities: Vec<Entity>,
@@ -224,7 +222,7 @@ struct Instance {
     properties: Vec<isize>,
 }
 
-impl Default for Instance {
+impl Default for ValueBind {
     fn default() -> Self {
         Self {
             dirty: true,
@@ -239,23 +237,15 @@ impl Default for Instance {
 /// Fetches entities and properties to animate
 pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
     // Fetch useful resources
-    let type_registry = resources.get::<TypeRegistry>();
-    let clips = resources.get::<Assets<Clip>>();
-
-    if type_registry.is_none() || clips.is_none() {
-        return;
-    }
-
-    let type_registry = type_registry.unwrap();
-    let clips = clips.unwrap();
+    let type_registry = resources.get::<TypeRegistry>().unwrap();
+    let clips = resources.get::<Assets<Clip>>().unwrap();
 
     // Build queries
     let type_access = TypeAccess::default();
     let mut animators_query: Query<(&mut Animator, &Children)> = Query::new(&world, &type_access);
-    //let animators_query = unsafe { world.query_unchecked::<(&mut Animator, &Children)>() };
     let entities_query: Query<(Entity, &Name, &Children)> = Query::new(&world, &type_access);
 
-    // TODO: Parallelize this loop
+    // TODO: Parallelize use ComputeTaskPool resource?
     for (mut animator, root_children) in animators_query.iter_mut() {
         // Trick for proper borrow rules
         let animator = &mut *animator;
@@ -263,18 +253,18 @@ pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
         // TODO: Needs to be updated when the hierarch change
         // TODO: Needs to be updated when a clip changes
         let animations_count = animator.animations.len();
-        if animations_count == animator.instances.len() {
-            if animator.instances.iter().all(|item| !item.dirty) {
+        if animations_count == animator.binds.len() {
+            if animator.binds.iter().all(|item| !item.dirty) {
                 break;
             }
         }
 
         animator
-            .instances
+            .binds
             .resize_with(animations_count, || Default::default());
 
         for (clip_index, clip_handle) in animator.animations.iter().enumerate() {
-            let instance = &mut animator.instances[clip_index];
+            let instance = &mut animator.binds[clip_index];
             if !instance.dirty {
                 continue;
             }
@@ -407,8 +397,8 @@ pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
                                             let root_ptr = root_properties.as_ptr();
                                             let target_ptr = target_property.as_ptr();
                                             // ! NOTE: Requires rust 1.47.0
-                                            // TODO: Need safety check
-                                            unsafe { root_ptr.offset_from(target_ptr) }
+                                            // TODO: Need safety check or SAFE argument
+                                            unsafe { target_ptr.offset_from(root_ptr) }
                                         };
                                     } else {
                                         valid[i] = false;
@@ -434,87 +424,150 @@ pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
     }
 }
 
-// pub(crate) fn animator_update(
-//     time: Res<Time>,
-//     // keyboard: Res<Input<KeyCode>>,
-//     clips: Res<Assets<Clip>>,
-//     mut animators_query: Query<(Mut<Animator>,)>,
-//     mut transforms_query: Query<(Mut<Transform>,)>,
-// ) {
-//     // let delta_time = if keyboard.just_pressed(KeyCode::Right) {
-//     //     1.0 / 60.0
-//     // } else {
-//     //     0.0
-//     // };
-
-//     let delta_time = time.delta_seconds;
-
-//     for (mut debugger,) in animators_query.iter_mut() {
-//         let debugger = debugger.deref_mut();
-
-//         if !debugger.builded {
-//             return;
-//         }
-
-//         // Time scales by component
-//         let delta_time = delta_time * debugger.time_scale;
-
-//         // Ensure capacity for cached keyframe index vec
-//         let nodes_count = debugger.hierarchy.len();
-//         if debugger.current.keyframe.len() != nodes_count {
-//             debugger.current.keyframe.clear();
-//             debugger
-//                 .current
-//                 .keyframe
-//                 .resize_with(nodes_count, || Default::default());
-//         }
-
-//         if let Some(clip) = clips.get(&debugger.clip) {
-//             // Update time
-//             let mut time = debugger.current.time + delta_time;
-
-//             // Warp mode
-//             if clip.warp {
-//                 // Warp Around
-//                 if time > clip.length {
-//                     time = (time / clip.length).fract() * clip.length;
-//                     // Reset all keyframes cached indexes
-//                     debugger
-//                         .current
-//                         .keyframe
-//                         .iter_mut()
-//                         .for_each(|x| *x = Default::default())
-//                 }
-//             } else {
-//                 // Hold
-//                 time = time.min(clip.length);
-//             }
-
-//             // Advance state time
-//             debugger.current.time = time;
-
-//             for (i, entity) in debugger.hierarchy.iter().enumerate() {
-//                 if let Ok((mut transform,)) = transforms_query.get_mut(*entity) {
-//                     // Get cached keyframe info
-//                     let keyframe = &mut debugger.current.keyframe[i];
-
-//                     // Sample animation
-//                     let (k, v) = clip.bones[i].position.sample(keyframe.position, time);
-//                     keyframe.position = k;
-//                     transform.translation = v;
-
-//                     let (k, v) = clip.bones[i].rotation.sample(keyframe.rotation, time);
-//                     keyframe.rotation = k;
-//                     transform.rotation = v;
-
-//                     let (k, v) = clip.bones[i].scale.sample(keyframe.scale, time);
-//                     keyframe.scale = k;
-//                     transform.scale = v;
-//                 }
-//             }
-//         }
-//     }
-// }
+pub(crate) fn animator_update(world: &mut World, resources: &mut Resources) {
+    let time = resources.get::<Time>().unwrap();
+    let clips = resources.get::<Assets<Clip>>().unwrap();
+    let type_registry = resources.get::<TypeRegistry>().unwrap();
+
+    // Build queries
+    let type_access = TypeAccess::default();
+    let mut animators_query: Query<(&mut Animator,)> = Query::new(&world, &type_access);
+
+    // let delta_time = if keyboard.just_pressed(KeyCode::Right) {
+    //     1.0 / 60.0
+    // } else {
+    //     0.0
+    // };
+
+    let delta_time = time.delta_seconds;
+
+    // TODO: Parallelize
+    for (mut animator,) in animators_query.iter_mut() {
+        let animator = &mut *animator;
+
+        // Time scales by component
+        let delta_time = delta_time * animator.time_scale;
+
+        let current = &mut animator.current;
+        let clip_index = current.clip;
+        if let Some(current_clip) = animator
+            .animations
+            .get(clip_index)
+            .map(|clip_handle| clips.get(clip_handle))
+            .flatten()
+        {
+            let bind = &animator.binds[clip_index];
+            let curves_count = current_clip.values.len();
+
+            // Ensure capacity for cached keyframe index vec
+            if current.keyframe.len() != curves_count {
+                current.keyframe.clear();
+                current
+                    .keyframe
+                    .resize_with(curves_count, || Default::default());
+            }
+
+            // Update time
+            let mut time = current.time + delta_time;
+
+            // Warp mode
+            if current_clip.warp {
+                // Warp Around
+                if time > current_clip.length {
+                    time = (time / current_clip.length).fract() * current_clip.length;
+                    // Reset all keyframes cached indexes
+                    current
+                        .keyframe
+                        .iter_mut()
+                        .for_each(|x| *x = Default::default())
+                }
+            } else {
+                // Hold
+                time = time.min(current_clip.length);
+            }
+
+            // Advance state time
+            current.time = time;
+
+            let mut entity = None;
+            let mut component = None;
+            let mut pointer = std::ptr::null_mut();
+            let mut location = Location {
+                archetype: u32::MAX,
+                index: usize::MAX,
+            };
+            for i in 0..curves_count {
+                if !bind.valid[i] {
+                    continue;
+                }
+
+                let next_entity = bind.entities[i];
+                if entity != Some(next_entity) {
+                    if let Some(l) = world.get_entity_location(next_entity) {
+                        location = l;
+                        entity = Some(next_entity);
+                        component = None; // Force component update
+                    } else {
+                        // Missing entity
+                        continue;
+                    }
+                }
+
+                let next_component = bind.components[i];
+                if component != Some(next_component) {
+                    if let Some(properties) = type_registry
+                        .component
+                        .read()
+                        .get(&next_component)
+                        .map(|reg| {
+                            reg.get_component_properties(
+                                &world.archetypes[location.archetype as usize],
+                                location.index,
+                            )
+                        })
+                    {
+                        // TODO: Find a better way
+                        pointer = unsafe { properties.as_ptr() as *mut u8 };
+                        component = Some(next_component);
+                    } else {
+                        // Missing component
+                        continue;
+                    }
+                }
+
+                let attr = pointer.wrapping_offset(bind.properties[i]);
+                let keyframe = &mut current.keyframe[i];
+
+                match &current_clip.values[i] {
+                    Value::Float(v) => {
+                        let (k, v) = v.sample(*keyframe, time);
+                        let attr = unsafe { &mut *(attr as *mut f32) };
+                        *attr = v;
+                        *keyframe = k;
+                    }
+                    Value::Vec3(v) => {
+                        let (k, v) = v.sample(*keyframe, time);
+                        let attr = unsafe { &mut *(attr as *mut Vec3) };
+                        *attr = v;
+                        *keyframe = k;
+                    }
+                    Value::Vec4(v) => {
+                        let (k, v) = v.sample(*keyframe, time);
+                        let attr = unsafe { &mut *(attr as *mut Vec4) };
+                        *attr = v;
+                        *keyframe = k;
+                    }
+                    Value::Quat(v) => {
+                        let (k, v) = v.sample(*keyframe, time);
+                        let attr = unsafe { &mut *(attr as *mut Quat) };
+                        *attr = v;
+                        *keyframe = k;
+                    }
+                }
+            }
+        }
+    }
+}
 
 // pub struct ClipLoader;
 
diff --git a/crates/bevy_animation/src/lerping.rs b/crates/bevy_animation/src/lerping.rs
index 1e69912b89b09..a31db95b8e8a7 100644
--- a/crates/bevy_animation/src/lerping.rs
+++ b/crates/bevy_animation/src/lerping.rs
@@ -5,12 +5,30 @@ pub trait LerpValue: Copy {
     fn lerp(a: Self, b: Self, t: f32) -> Self;
 }
 
+impl LerpValue for f32 {
+    fn lerp(a: Self, b: Self, t: f32) -> Self {
+        a * (1.0 - t) + b * t
+    }
+}
+
+impl LerpValue for Vec2 {
+    fn lerp(a: Self, b: Self, t: f32) -> Self {
+        a * (1.0 - t) + b * t
+    }
+}
+
 impl LerpValue for Vec3 {
     fn lerp(a: Self, b: Self, t: f32) -> Self {
         a * (1.0 - t) + b * t
     }
 }
 
+impl LerpValue for Vec4 {
+    fn lerp(a: Self, b: Self, t: f32) -> Self {
+        a * (1.0 - t) + b * t
+    }
+}
+
 impl LerpValue for Quat {
     /// Actually performs an nlerp, because it's much cheaper and easer to combine with other animations,
     /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 7b685c79abcaa..2f2bfbc6e78af 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -14,11 +14,12 @@ pub use crate::skined_mesh::*;
 pub mod prelude {
     pub use crate::generic::{Animator, Clip, Curve, Value};
     pub use crate::lerping::LerpValue;
-    pub use crate::skined_mesh::{MeshSkin, MeshSkinner};
+    pub use crate::skined_mesh::{MeshSkin, MeshSkinBinder, MeshSkinnerDebuger};
 }
 
 pub mod stage {
     pub const ANIMATE: &'static str = "animate";
+    pub use bevy_app::stage::POST_UPDATE;
     pub use bevy_app::stage::UPDATE;
 }
 
@@ -27,14 +28,19 @@ pub struct AnimationPlugin;
 
 impl Plugin for AnimationPlugin {
     fn build(&self, app: &mut AppBuilder) {
+        // Generic animation
         app.add_asset::<Clip>()
-            .add_stage_after(stage::UPDATE, stage::ANIMATE)
             //.add_asset_loader(ClipLoader)
+            .add_stage_after(stage::UPDATE, stage::ANIMATE)
             .register_component::<Animator>()
-            .add_system_to_stage(stage::ANIMATE, animator_fetch.thread_local_system())
-            //.add_system_to_stage(stage::ANIMATE, animator_update.system())
-            .add_asset::<MeshSkin>()
-            .register_component_with::<MeshSkinner>(|reg| reg.map_entities())
-            .add_system(mesh_skinner_startup.system());
+            .add_system_to_stage(stage::ANIMATE, animator_update.thread_local_system())
+            .add_system_to_stage_front(stage::ANIMATE, animator_fetch.thread_local_system());
+
+        // Skinning
+        app.add_asset::<MeshSkin>()
+            .register_component_with::<MeshSkinBinder>(|reg| reg.map_entities())
+            .register_component::<MeshSkinnerDebuger>()
+            .add_system_to_stage(stage::POST_UPDATE, mesh_skinner_debugger_update.system())
+            .add_system_to_stage_front(stage::UPDATE, mesh_skinner_startup.system());
     }
 }
diff --git a/crates/bevy_animation/src/skined_mesh.rs b/crates/bevy_animation/src/skined_mesh.rs
index 0f074ea62f5e2..218c5d910d999 100644
--- a/crates/bevy_animation/src/skined_mesh.rs
+++ b/crates/bevy_animation/src/skined_mesh.rs
@@ -4,8 +4,10 @@ use bevy_core::Name;
 use bevy_ecs::prelude::*;
 use bevy_ecs::MapEntities;
 use bevy_math::Mat4;
+use bevy_pbr::prelude::*;
 use bevy_property::Properties;
-use bevy_render::mesh::Mesh;
+use bevy_render::mesh::{shape, Indices, Mesh, VertexAttributeValues};
+use bevy_render::pipeline::PrimitiveTopology;
 use bevy_transform::prelude::*;
 use bevy_type_registry::TypeUuid;
 use smallvec::SmallVec;
@@ -28,11 +30,10 @@ impl MeshSkin {
     }
 }
 
-// TODO: Find a better name!
 /// Component that skins some mesh.
 /// Requires a `Handle<MeshSkin>` attached to same entity as the component
 #[derive(Properties)]
-pub struct MeshSkinner {
+pub struct MeshSkinBinder {
     /// Keeps track of what `MeshSkin` this component is configured to,
     /// extra work is required to keep bones in order.
     ///
@@ -49,7 +50,7 @@ pub struct MeshSkinner {
     pub meshes: SmallVec<[Entity; 8]>, // ! FIXME: Property can't handle Vec<Entity>
 }
 
-impl MeshSkinner {
+impl MeshSkinBinder {
     pub fn with_skeleton(skeleton: Entity) -> Self {
         Self {
             skin: None,
@@ -63,13 +64,13 @@ impl MeshSkinner {
 }
 
 // TODO: Same problem of Parent component
-impl FromResources for MeshSkinner {
+impl FromResources for MeshSkinBinder {
     fn from_resources(_resources: &bevy_ecs::Resources) -> Self {
-        MeshSkinner::with_skeleton(Entity::new(u32::MAX))
+        MeshSkinBinder::with_skeleton(Entity::new(u32::MAX))
     }
 }
 
-impl MapEntities for MeshSkinner {
+impl MapEntities for MeshSkinBinder {
     fn map_entities(
         &mut self,
         entity_map: &bevy_ecs::EntityMap,
@@ -88,7 +89,7 @@ impl MapEntities for MeshSkinner {
 // will find the rest of the skeleton hierarchy.
 pub(crate) fn mesh_skinner_startup(
     mesh_skin_assets: Res<Assets<MeshSkin>>,
-    mut skinners_query: Query<(&Handle<MeshSkin>, &mut MeshSkinner, Option<&Children>)>,
+    mut skinners_query: Query<(&Handle<MeshSkin>, &mut MeshSkinBinder, Option<&Children>)>,
     meshes_query: Query<(&Handle<Mesh>,)>,
     bones_query: Query<(Entity, &Name, Option<&Children>)>,
 ) {
@@ -144,15 +145,189 @@ pub(crate) fn mesh_skinner_startup(
     }
 }
 
-// TODO: MeshSkinner system
-// fn mesh_skinner_update() {
+// TODO: MeshSkinBinder system
+// fn mesh_skin_binder_update() {
 //     // TODO: have to send the matrices into each entity
 // }
 
-// #[derive(Default, Debug)]
-// pub struct MeshSkinnerDebuger {
-//     pub enabled: bool,
-//     currently_enabled: bool,
-//     mesh: Handle<Mesh>,
-//     entity: Option<Entity>,
+///////////////////////////////////////////////////////////////////////////////
+
+// TODO: Should I implement a SkeletalAnimator for better performance for mesh animations
+// // Similar to Animator but only works for transforms
+// pub struct SkeletalAnimator {}
+
+// pub(crate) fn skeletal_animator_update(
+//     time: Res<Time>,
+//     // keyboard: Res<Input<KeyCode>>,
+//     clips: Res<Assets<Clip>>,
+//     mut animators_query: Query<(Mut<Animator>,)>,
+//     mut transforms_query: Query<(Mut<Transform>,)>,
+// ) {
+//     // let delta_time = if keyboard.just_pressed(KeyCode::Right) {
+//     //     1.0 / 60.0
+//     // } else {
+//     //     0.0
+//     // };
+
+//     let delta_time = time.delta_seconds;
+
+//     for (mut debugger,) in animators_query.iter_mut() {
+//         let debugger = debugger.deref_mut();
+
+//         if !debugger.builded {
+//             return;
+//         }
+
+//         // Time scales by component
+//         let delta_time = delta_time * debugger.time_scale;
+
+//         // Ensure capacity for cached keyframe index vec
+//         let nodes_count = debugger.hierarchy.len();
+//         if debugger.current.keyframe.len() != nodes_count {
+//             debugger.current.keyframe.clear();
+//             debugger
+//                 .current
+//                 .keyframe
+//                 .resize_with(nodes_count, || Default::default());
+//         }
+
+//         if let Some(clip) = clips.get(&debugger.clip) {
+//             // Update time
+//             let mut time = debugger.current.time + delta_time;
+
+//             // Warp mode
+//             if clip.warp {
+//                 // Warp Around
+//                 if time > clip.length {
+//                     time = (time / clip.length).fract() * clip.length;
+//                     // Reset all keyframes cached indexes
+//                     debugger
+//                         .current
+//                         .keyframe
+//                         .iter_mut()
+//                         .for_each(|x| *x = Default::default())
+//                 }
+//             } else {
+//                 // Hold
+//                 time = time.min(clip.length);
+//             }
+
+//             // Advance state time
+//             debugger.current.time = time;
+
+//             for (i, entity) in debugger.hierarchy.iter().enumerate() {
+//                 if let Ok((mut transform,)) = transforms_query.get_mut(*entity) {
+//                     // Get cached keyframe info
+//                     let keyframe = &mut debugger.current.keyframe[i];
+
+//                     // Sample animation
+//                     let (k, v) = clip.bones[i].position.sample(keyframe.position, time);
+//                     keyframe.position = k;
+//                     transform.translation = v;
+
+//                     let (k, v) = clip.bones[i].rotation.sample(keyframe.rotation, time);
+//                     keyframe.rotation = k;
+//                     transform.rotation = v;
+
+//                     let (k, v) = clip.bones[i].scale.sample(keyframe.scale, time);
+//                     keyframe.scale = k;
+//                     transform.scale = v;
+//                 }
+//             }
+//         }
+//     }
 // }
+
+///////////////////////////////////////////////////////////////////////////////
+
+#[derive(Default, Debug, Properties)]
+pub struct MeshSkinnerDebuger {
+    //pub enabled: bool,
+    #[property(ignore)]
+    mesh: Option<Handle<Mesh>>,
+    #[property(ignore)]
+    entity: Option<Entity>,
+}
+
+pub(crate) fn mesh_skinner_debugger_update(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    skins: Res<Assets<MeshSkin>>,
+    mut debugger_query: Query<(&Handle<MeshSkin>, &MeshSkinBinder, &mut MeshSkinnerDebuger)>,
+    bones_query: Query<(&GlobalTransform,)>,
+) {
+    for (skin_handle, skinner, mut debugger) in debugger_query.iter_mut() {
+        let debugger = &mut *debugger;
+
+        // if !debugger.enabled {
+        //     continue;
+        // }
+
+        if let Some(skin) = skins.get(skin_handle) {
+            if debugger.mesh.is_none() {
+                let mesh = Mesh::new(PrimitiveTopology::LineList);
+                debugger.mesh = Some(meshes.add(mesh));
+
+                let bone_mesh = meshes.add(Mesh::from(shape::Cube { size: 0.02 }));
+                for bone in skinner.bones.iter() {
+                    if let Some(entity) = bone {
+                        commands
+                            .spawn(PbrComponents {
+                                mesh: bone_mesh.clone(),
+                                ..Default::default()
+                            })
+                            .with(Parent(*entity));
+                    }
+                }
+            }
+
+            let mesh_handle = debugger.mesh.as_ref().unwrap();
+            let mesh = meshes.get_mut(mesh_handle).unwrap();
+
+            if debugger.entity.is_none() {
+                debugger.entity = commands
+                    .spawn(PbrComponents {
+                        mesh: mesh_handle.clone(),
+                        ..Default::default()
+                    })
+                    .current_entity()
+            }
+
+            let positions = skinner
+                .bones
+                .iter()
+                .map(|bone| {
+                    if let Some(entity) = *bone {
+                        if let Ok((global_transform,)) = bones_query.get(entity) {
+                            global_transform.translation
+                        } else {
+                            Default::default()
+                        }
+                    } else {
+                        Default::default()
+                    }
+                })
+                .collect::<Vec<_>>();
+
+            // TODO: Improve mesh generation with a 3 sided pyramid
+            // TODO: How reuse mesh buffers?
+
+            let mut indices = vec![];
+            let mut vertices = vec![];
+            for (i, parent) in skin.bones_parents.iter().enumerate() {
+                if let Some(parent) = *parent {
+                    indices.push(vertices.len() as u32);
+                    vertices.push(positions[i].into());
+                    indices.push(vertices.len() as u32);
+                    vertices.push(positions[parent].into());
+                }
+            }
+
+            mesh.set_attribute(
+                Mesh::ATTRIBUTE_POSITION,
+                VertexAttributeValues::Float3(vertices),
+            );
+            mesh.set_indices(Some(Indices::U32(indices)));
+        }
+    }
+}
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 61145a8b60ca6..f13c88241ee2e 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -163,7 +163,12 @@ async fn load_gltf<'a, 'b>(
 
             for joint in skin.joints() {
                 bones_names.push(joint.name().expect("unnamed bone").to_string());
-                bones_parents.push(parents[joint.index()]);
+
+                if let Some(parent) = parents[joint.index()] {
+                    bones_parents.push(skin.joints().position(|j| j.index() == parent));
+                } else {
+                    bones_parents.push(None);
+                }
             }
 
             load_context.set_labeled_asset(
@@ -438,9 +443,11 @@ fn load_node(
         // TODO: Mesh skinner needs a at least a reference to the skeleton root for it to work
         // for this reason it need to keep track of all entities created by their index in the gltf node vec
         let skeleton_root = skin.skeleton().map_or(root_node.index(), |n| n.index());
-        world_builder.with(MeshSkinner::with_skeleton(
+        world_builder.with(MeshSkinBinder::with_skeleton(
             entity_lookup[skeleton_root].expect("missing skeleton root entity"),
         ));
+
+        world_builder.with(MeshSkinnerDebuger::default());
     }
 
     world_builder.with_children(|parent| {

From 3abe4d10f3251d921c288f3c593f1792b68ae432 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sat, 14 Nov 2020 11:13:12 -0300
Subject: [PATCH 006/153] missing merge changes

---
 crates/bevy_animation/src/generic.rs     | 23 ++++++++++++-----------
 crates/bevy_animation/src/skined_mesh.rs |  2 +-
 crates/bevy_internal/Cargo.toml          |  1 +
 crates/bevy_internal/src/lib.rs          |  8 +++++++-
 4 files changed, 21 insertions(+), 13 deletions(-)

diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 9e3c5ed28b1dc..167f595a11658 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -2,7 +2,7 @@ use anyhow::Result;
 use bevy_asset::{Assets, Handle};
 use bevy_core::prelude::*;
 use bevy_ecs::prelude::*;
-use bevy_ecs::{Location, TypeAccess};
+use bevy_ecs::Location;
 use bevy_math::prelude::*;
 use bevy_property::Properties;
 use bevy_property::PropertyType;
@@ -241,12 +241,10 @@ pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
     let clips = resources.get::<Assets<Clip>>().unwrap();
 
     // Build queries
-    let type_access = TypeAccess::default();
-    let mut animators_query: Query<(&mut Animator, &Children)> = Query::new(&world, &type_access);
-    let entities_query: Query<(Entity, &Name, &Children)> = Query::new(&world, &type_access);
+    let animators_query = unsafe { world.query_unchecked::<(&mut Animator, &Children), ()>() };
 
     // TODO: Parallelize use ComputeTaskPool resource?
-    for (mut animator, root_children) in animators_query.iter_mut() {
+    for (mut animator, root_children) in animators_query {
         // Trick for proper borrow rules
         let animator = &mut *animator;
 
@@ -303,7 +301,9 @@ pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
                 let mut stack = vec![];
                 // First uneducated search for all hierarchy
                 for parent in root_children.iter().copied() {
-                    if let Ok((entity, name, children)) = entities_query.get(parent) {
+                    if let Ok((entity, name, children)) =
+                        world.query_one::<(Entity, &Name, &Children)>(parent)
+                    {
                         let name = Some(name.0.as_str());
                         for (i, level) in hierarchy.iter_mut().enumerate() {
                             if *level != name {
@@ -321,7 +321,9 @@ pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
                 // TODO: Many identical queries for the same entity will happen here!
                 while let Some((i, parents)) = stack.pop() {
                     for parent in parents.iter().copied() {
-                        if let Ok((entity, name, children)) = entities_query.get(parent) {
+                        if let Ok((entity, name, children)) =
+                            world.query_one::<(Entity, &Name, &Children)>(parent)
+                        {
                             if hierarchy[i] == Some(name.0.as_str()) {
                                 hierarchy[i] = paths[i].0.next();
                                 entities[i] = entity; // Replaces the entity for the lowest
@@ -430,8 +432,7 @@ pub(crate) fn animator_update(world: &mut World, resources: &mut Resources) {
     let type_registry = resources.get::<TypeRegistry>().unwrap();
 
     // Build queries
-    let type_access = TypeAccess::default();
-    let mut animators_query: Query<(&mut Animator,)> = Query::new(&world, &type_access);
+    let animators_query = unsafe { world.query_unchecked::<(&mut Animator,), ()>() };
 
     // let delta_time = if keyboard.just_pressed(KeyCode::Right) {
     //     1.0 / 60.0
@@ -442,7 +443,7 @@ pub(crate) fn animator_update(world: &mut World, resources: &mut Resources) {
     let delta_time = time.delta_seconds;
 
     // TODO: Parallelize
-    for (mut animator,) in animators_query.iter_mut() {
+    for (mut animator,) in animators_query {
         let animator = &mut *animator;
 
         // Time scales by component
@@ -527,7 +528,7 @@ pub(crate) fn animator_update(world: &mut World, resources: &mut Resources) {
                         })
                     {
                         // TODO: Find a better way
-                        pointer = unsafe { properties.as_ptr() as *mut u8 };
+                        pointer = properties.as_ptr() as *mut u8;
                         component = Some(next_component);
                     } else {
                         // Missing component
diff --git a/crates/bevy_animation/src/skined_mesh.rs b/crates/bevy_animation/src/skined_mesh.rs
index 218c5d910d999..abd05bd6a4da6 100644
--- a/crates/bevy_animation/src/skined_mesh.rs
+++ b/crates/bevy_animation/src/skined_mesh.rs
@@ -250,7 +250,7 @@ pub struct MeshSkinnerDebuger {
 }
 
 pub(crate) fn mesh_skinner_debugger_update(
-    mut commands: Commands,
+    commands: &mut Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     skins: Res<Assets<MeshSkin>>,
     mut debugger_query: Query<(&Handle<MeshSkin>, &MeshSkinBinder, &mut MeshSkinnerDebuger)>,
diff --git a/crates/bevy_internal/Cargo.toml b/crates/bevy_internal/Cargo.toml
index 23fdc7de6151f..bcb218887409d 100644
--- a/crates/bevy_internal/Cargo.toml
+++ b/crates/bevy_internal/Cargo.toml
@@ -51,6 +51,7 @@ bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
 bevy_window = { path = "../bevy_window", version = "0.3.0" }
 bevy_tasks = { path = "../bevy_tasks", version = "0.3.0" }
 # bevy (optional)
+bevy_animation = { path = "../bevy_animation", optional = true, version = "0.3.0" }
 bevy_audio = { path = "../bevy_audio", optional = true, version = "0.3.0" }
 bevy_gltf = { path = "../bevy_gltf", optional = true, version = "0.3.0" }
 bevy_pbr = { path = "../bevy_pbr", optional = true, version = "0.3.0" }
diff --git a/crates/bevy_internal/src/lib.rs b/crates/bevy_internal/src/lib.rs
index 0872432f55125..7034b9a55e8e3 100644
--- a/crates/bevy_internal/src/lib.rs
+++ b/crates/bevy_internal/src/lib.rs
@@ -79,12 +79,18 @@ pub mod audio {
     pub use bevy_audio::*;
 }
 
-#[cfg(feature = "bevy_gltf")]
+#[cfg(all(feature = "bevy_gltf", feature = "bevy_animation"))]
 pub mod gltf {
     //! Support for GLTF file loading.
     pub use bevy_gltf::*;
 }
 
+#[cfg(feature = "bevy_animation")]
+pub mod animation {
+    //! Support for GLTF file loading.
+    pub use bevy_animation::*;
+}
+
 #[cfg(feature = "bevy_pbr")]
 pub mod pbr {
     //! Physically based rendering.

From 474a6ce490e78bbb020526f63892873faefeeda2 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Wed, 18 Nov 2020 12:56:19 -0300
Subject: [PATCH 007/153] testing some ideas and profiling animation

---
 crates/bevy_animation/Cargo.toml     |  1 +
 crates/bevy_animation/src/generic.rs | 40 +++++++++++++++-------------
 2 files changed, 22 insertions(+), 19 deletions(-)

diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index cbabb5c4c0d65..49d16c346d005 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -23,3 +23,4 @@ bevy_property = { path = "../bevy_property", version = "0.3.0" }
 serde = { version = "1.0", features = ["derive"] }
 smallvec = { version = "1.4", features = ["serde"] }
 anyhow = "1.0"
+tracing = { version = "0.1.21", features = ["attributes"] }
\ No newline at end of file
diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 167f595a11658..add76b68a8382 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -154,37 +154,23 @@ where
     }
 }
 
+// TODO: rename to Layer
 #[derive(Default, Debug, Clone, Properties)]
 struct State {
-    clip: usize,
-    time: f32,
+    //pub weight: f32, // TODO: Enable blending logic
+    pub clip: usize,
+    pub time: f32,
     keyframe: Vec<usize>,
 }
 
-// #[derive(Default, Debug, Clone, Properties)]
-// struct KeyframeState {
-//     position: usize,
-//     rotation: usize,
-//     scale: usize,
-// }
-
-// #[derive(Default, Clone, Debug, Properties)]
-// struct Lerp {
-//     n: f32,
-//     time: f32,
-//     duration: f32,
-// }
-
 #[derive(Debug, Properties)]
 pub struct Animator {
     animations: Vec<Handle<Clip>>,
     #[property(ignore)]
     binds: Vec<ValueBind>,
     pub time_scale: f32,
-    // hierarchy: Vec<()>,
     current: State,
-    // next: Option<State>, // TODO: Keep memory allocated to be reused
-    // transition: Lerp,
+    //pub states: Vec<State>,
 }
 
 impl Default for Animator {
@@ -213,6 +199,7 @@ impl Animator {
     }
 }
 
+// TODO: Remove
 #[derive(Debug)]
 struct ValueBind {
     dirty: bool,
@@ -234,7 +221,21 @@ impl Default for ValueBind {
     }
 }
 
+/// Batch of all necessary commands that can run on parallel
+#[derive(Debug)]
+struct ClipCommandsBatch {
+    commands: Vec<Command>,
+}
+
+#[derive(Debug)]
+struct Command {
+    entity: Entity,
+    curves: Vec<u16>,
+    offsets: Vec<isize>,
+}
+
 /// Fetches entities and properties to animate
+#[tracing::instrument(skip(world, resources))]
 pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
     // Fetch useful resources
     let type_registry = resources.get::<TypeRegistry>().unwrap();
@@ -426,6 +427,7 @@ pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
     }
 }
 
+#[tracing::instrument(skip(world, resources))]
 pub(crate) fn animator_update(world: &mut World, resources: &mut Resources) {
     let time = resources.get::<Time>().unwrap();
     let clips = resources.get::<Assets<Clip>>().unwrap();

From 46274cabd3160edba875cbb7726a86de9d9ab589 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sat, 21 Nov 2020 13:21:09 -0300
Subject: [PATCH 008/153] fix dup children

---
 .../bevy_transform/src/components/children.rs | 14 ++++---------
 .../bevy_transform/src/components/parent.rs   | 21 +++++++++++++++++--
 .../src/hierarchy/child_builder.rs            |  4 ++--
 .../bevy_transform/src/hierarchy/hierarchy.rs |  2 +-
 .../hierarchy/hierarchy_maintenance_system.rs |  4 ++++
 .../src/hierarchy/world_child_builder.rs      |  2 +-
 crates/bevy_transform/src/lib.rs              |  3 ++-
 7 files changed, 33 insertions(+), 17 deletions(-)

diff --git a/crates/bevy_transform/src/components/children.rs b/crates/bevy_transform/src/components/children.rs
index 5b08a41b48f6d..a38611fda1b69 100644
--- a/crates/bevy_transform/src/components/children.rs
+++ b/crates/bevy_transform/src/components/children.rs
@@ -1,10 +1,10 @@
 use bevy_ecs::{Entity, MapEntities};
 use bevy_property::Properties;
 use smallvec::SmallVec;
-use std::ops::{Deref, DerefMut};
+use std::ops::Deref;
 
 #[derive(Default, Clone, Properties, Debug)]
-pub struct Children(pub SmallVec<[Entity; 8]>);
+pub struct Children(pub(crate) SmallVec<[Entity; 8]>);
 
 impl MapEntities for Children {
     fn map_entities(
@@ -26,15 +26,9 @@ impl Children {
 }
 
 impl Deref for Children {
-    type Target = SmallVec<[Entity; 8]>;
+    type Target = [Entity];
 
     fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl DerefMut for Children {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
+        &self.0[..]
     }
 }
diff --git a/crates/bevy_transform/src/components/parent.rs b/crates/bevy_transform/src/components/parent.rs
index bf9bdab9a67b2..1246d2d256f07 100644
--- a/crates/bevy_transform/src/components/parent.rs
+++ b/crates/bevy_transform/src/components/parent.rs
@@ -25,8 +25,25 @@ impl MapEntities for Parent {
     }
 }
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub struct PreviousParent(pub Entity);
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Properties)]
+pub struct PreviousParent(pub(crate) Entity);
+
+impl MapEntities for PreviousParent {
+    fn map_entities(
+        &mut self,
+        entity_map: &bevy_ecs::EntityMap,
+    ) -> Result<(), bevy_ecs::MapEntitiesError> {
+        self.0 = entity_map.get(self.0)?;
+        Ok(())
+    }
+}
+
+// TODO: Better handle this case
+impl FromResources for PreviousParent {
+    fn from_resources(_resources: &bevy_ecs::Resources) -> Self {
+        PreviousParent(Entity::new(u32::MAX))
+    }
+}
 
 impl Deref for Parent {
     type Target = Entity;
diff --git a/crates/bevy_transform/src/hierarchy/child_builder.rs b/crates/bevy_transform/src/hierarchy/child_builder.rs
index b42772cfb8bc7..572f2a100c9b4 100644
--- a/crates/bevy_transform/src/hierarchy/child_builder.rs
+++ b/crates/bevy_transform/src/hierarchy/child_builder.rs
@@ -19,7 +19,7 @@ impl Command for InsertChildren {
         {
             let mut added = false;
             if let Ok(mut children) = world.get_mut::<Children>(self.parent) {
-                children.insert_from_slice(self.index, &self.children);
+                children.0.insert_from_slice(self.index, &self.children);
                 added = true;
             }
 
@@ -54,7 +54,7 @@ impl Command for PushChildren {
         {
             let mut added = false;
             if let Ok(mut children) = world.get_mut::<Children>(self.parent) {
-                children.extend(self.children.iter().cloned());
+                children.0.extend(self.children.iter().cloned());
                 added = true;
             }
 
diff --git a/crates/bevy_transform/src/hierarchy/hierarchy.rs b/crates/bevy_transform/src/hierarchy/hierarchy.rs
index 6509fa0ff7a0d..e9ec1070bc80b 100644
--- a/crates/bevy_transform/src/hierarchy/hierarchy.rs
+++ b/crates/bevy_transform/src/hierarchy/hierarchy.rs
@@ -42,7 +42,7 @@ fn despawn_with_children_recursive(world: &mut World, entity: Entity) {
     // first, make the entity's own parent forget about it
     if let Ok(parent) = world.get::<Parent>(entity).map(|parent| parent.0) {
         if let Ok(mut children) = world.get_mut::<Children>(parent) {
-            children.retain(|c| *c != entity);
+            children.0.retain(|c| *c != entity);
         }
     }
 
diff --git a/crates/bevy_transform/src/hierarchy/hierarchy_maintenance_system.rs b/crates/bevy_transform/src/hierarchy/hierarchy_maintenance_system.rs
index 09f67b68e8b05..6073300001af7 100644
--- a/crates/bevy_transform/src/hierarchy/hierarchy_maintenance_system.rs
+++ b/crates/bevy_transform/src/hierarchy/hierarchy_maintenance_system.rs
@@ -47,6 +47,10 @@ pub fn parent_update_system(
         // `children_additions`).
         if let Ok(mut new_parent_children) = children_query.get_mut(parent.0) {
             // This is the parent
+            debug_assert!(
+                !(*new_parent_children).0.contains(&entity),
+                "children already added"
+            );
             (*new_parent_children).0.push(entity);
         } else {
             // The parent doesn't have a children entity, lets add it
diff --git a/crates/bevy_transform/src/hierarchy/world_child_builder.rs b/crates/bevy_transform/src/hierarchy/world_child_builder.rs
index a658956c06e69..8f1dc84528fe6 100644
--- a/crates/bevy_transform/src/hierarchy/world_child_builder.rs
+++ b/crates/bevy_transform/src/hierarchy/world_child_builder.rs
@@ -22,7 +22,7 @@ impl<'a, 'b> WorldChildBuilder<'a, 'b> {
             let world = &mut self.world_builder.world;
             let mut added = false;
             if let Ok(mut children) = world.get_mut::<Children>(parent_entity) {
-                children.push(entity);
+                children.0.push(entity);
                 added = true;
             }
 
diff --git a/crates/bevy_transform/src/lib.rs b/crates/bevy_transform/src/lib.rs
index fe8dc696c996e..eece2199a1e4a 100644
--- a/crates/bevy_transform/src/lib.rs
+++ b/crates/bevy_transform/src/lib.rs
@@ -8,7 +8,7 @@ pub mod prelude {
 
 use bevy_app::prelude::*;
 use bevy_type_registry::RegisterType;
-use prelude::{parent_update_system, Children, GlobalTransform, Parent, Transform};
+use prelude::{parent_update_system, Children, GlobalTransform, Parent, PreviousParent, Transform};
 
 #[derive(Default)]
 pub struct TransformPlugin;
@@ -17,6 +17,7 @@ impl Plugin for TransformPlugin {
     fn build(&self, app: &mut AppBuilder) {
         app.register_component_with::<Children>(|reg| reg.map_entities())
             .register_component_with::<Parent>(|reg| reg.map_entities())
+            .register_component_with::<PreviousParent>(|reg| reg.map_entities())
             .register_component::<Transform>()
             .register_component::<GlobalTransform>()
             // add transform systems to startup so the first update is "correct"

From ce60d3b8b51f9427be5a4bc47ecee1c3b0dab488 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sun, 22 Nov 2020 17:37:55 -0300
Subject: [PATCH 009/153] (wip) major rewrite

---
 crates/bevy_animation/Cargo.toml         |   1 +
 crates/bevy_animation/src/generic.rs     | 696 ++++++++++++++---------
 crates/bevy_animation/src/lerping.rs     |  53 +-
 crates/bevy_animation/src/lib.rs         |  19 +-
 crates/bevy_animation/src/skined_mesh.rs |  39 +-
 crates/bevy_ecs/src/core/entities.rs     |   2 +-
 crates/bevy_gltf/src/loader.rs           |   6 +-
 7 files changed, 506 insertions(+), 310 deletions(-)

diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index 49d16c346d005..2d041e4458f26 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -14,6 +14,7 @@ bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
 bevy_pbr = { path = "../bevy_pbr", version = "0.3.0" }
 bevy_math = { path = "../bevy_math", version = "0.3.0" }
 bevy_render = { path = "../bevy_render", version = "0.3.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
 #bevy_tasks = { path = "../bevy_tasks", version = "0.3.0" }
 bevy_transform = { path = "../bevy_transform", version = "0.3.0" }
 bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index add76b68a8382..90d33c982650f 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -1,105 +1,134 @@
 use anyhow::Result;
-use bevy_asset::{Assets, Handle};
+use bevy_app::prelude::{EventReader, Events};
+use bevy_asset::{AssetEvent, Assets, Handle, HandleUntyped};
 use bevy_core::prelude::*;
 use bevy_ecs::prelude::*;
-use bevy_ecs::Location;
+use bevy_ecs::{Location, SystemId};
 use bevy_math::prelude::*;
 use bevy_property::Properties;
 use bevy_property::PropertyType;
 use bevy_transform::prelude::*;
 use bevy_type_registry::{TypeRegistry, TypeUuid};
+use bevy_utils::HashSet;
 use serde::{Deserialize, Serialize};
 use std::any::TypeId;
+use std::convert::TryFrom;
+use std::ptr::null_mut;
 
 use super::lerping::LerpValue;
 
-// Naive implementation for skeleton animation
-
 // TODO: Curve/Curve need a validation during deserialization because they are
 // structured as SOA (struct of arrays), so the vec's length must match
 
-#[derive(Default, Debug, Serialize, Deserialize, TypeUuid)]
+#[derive(Debug, Serialize, Deserialize, TypeUuid)]
 #[uuid = "4c76e6c3-706d-4a74-af8e-4f48033e0733"]
 pub struct Clip {
     #[serde(default = "clip_default_warp")]
     pub warp: bool,
-    pub length: f32,
-    /// Property to be animated will be in the format `"path/to/named_entity@Transform.translation.x"`
-    /// where the left side `@` defines a path to the entity to animate,
-    /// while the right side the path to a property to animate starting from the component.
-    ///
-    /// *NOTE*: Keep sorted to improve efficiency
-    properties: Vec<String>,
-    values: Vec<Value>,
+    duration: f32,
+    /// Entity identification parent index on this same vec and name
+    entities: Vec<(u16, String)>,
+    /// Attribute is made by the entity index and a string that combines
+    /// component name followed by their attributes spaced by a period,
+    /// like so: `"Transform.translation.x"`
+    attribute: Vec<(u16, String)>,
+    curves: Vec<CurveUntyped>,
 }
 
 fn clip_default_warp() -> bool {
     true
 }
 
-impl Clip {
-    pub fn add_animated_prop(&mut self, property_path: String, value: Value) {
-        self.properties.push(property_path);
-        self.values.push(value);
-    }
-
-    pub fn iter(&mut self) -> impl Iterator<Item = (&String, &Value)> {
-        self.properties.iter().zip(self.values.iter())
+impl Default for Clip {
+    fn default() -> Self {
+        Self {
+            warp: true,
+            duration: 0.0,
+            // NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
+            entities: vec![(u16::MAX, String::default())],
+            attribute: vec![],
+            curves: vec![],
+        }
     }
+}
 
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = (&mut String, &mut Value)> {
-        self.properties.iter_mut().zip(self.values.iter_mut())
-    }
+impl Clip {
+    /// Property to be animated must be in the following format `"path/to/named_entity@Transform.translation.x"`
+    /// where the left side `@` defines a path to the entity to animate,
+    /// while the right side the path to a property to animate starting from the component.
+    pub fn add_animated_prop(&mut self, property_path: &str, curve: CurveUntyped) {
+        // Clip an only have some amount of curves and entities
+        // this limitation was added to save memory (but you can increase it if you want)
+        assert!(
+            (self.curves.len() as u16) <= u16::MAX,
+            "curve limit reached"
+        );
+
+        let path =
+            property_path.split_at(property_path.rfind('@').expect("property path missing @"));
+
+        let mut entity = 0; // Start search from root
+        for name in path.0.split('/') {
+            if let Some(e) = self
+                .entities
+                .iter()
+                .position(|(p, n)| (*p, n.as_str()) == (entity, name))
+            {
+                // Found entity
+                entity = e as u16;
+            } else {
+                // Add entity
+                let e = self.entities.len();
+                // Soft limit added to save memory, identical to the curve limit
+                entity = u16::try_from(e).expect("entities limit reached");
+                self.entities.push((entity, name.to_string()));
+            }
+        }
 
-    pub fn optimize(&mut self) {
-        // // SAFE: No string gets dropped and are only used during for sorting
-        // let props: &[String] = unsafe { &*(&self.properties[..] as *const _) };
-
-        // let mut indexes = props
-        //     .iter()
-        //     .enumerate()
-        //     .map(|(i, n)| (i, i, n))
-        //     .collect::<Vec<_>>();
-
-        // indexes.sort_by(|a, b| a.2.partial_cmp(b.2).unwrap());
-        // indexes.iter_mut().enumerate().for_each(|(i, (j, k, _))| {
-        //     *k = i;
-        // });
-        // // It's necessary to sort
-        // indexes.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
-
-        // for (i, j, _) in indexes {
-        //     self.properties[..].swap(i, j);
-        //     self.values[..].swap(i, j);
-        // }
+        // TODO: also replace the curve
+        // TODO: we can only have (u16 - 1) max
+        // TODO: "...@Transform.translation" and "...@Transform.translation.x" can't live with each other
+        self.duration = self.duration.max(curve.duration());
+        self.attribute.push((entity, path.1.to_string()));
+        self.curves.push(curve);
     }
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-pub enum Value {
+pub enum CurveUntyped {
     Float(Curve<f32>),
     Vec3(Curve<Vec3>),
     Vec4(Curve<Vec4>),
     Quat(Curve<Quat>),
+    //Handle(Curve<HandleUntyped>), // TODO: Requires (de)serialize!
 }
 
-impl Value {
-    pub fn samples_mut(&mut self) -> impl Iterator<Item = &mut f32> {
+impl CurveUntyped {
+    pub fn duration(&self) -> f32 {
         match self {
-            Value::Float(c) => c.samples.iter_mut(),
-            Value::Vec3(c) => c.samples.iter_mut(),
-            Value::Vec4(c) => c.samples.iter_mut(),
-            Value::Quat(c) => c.samples.iter_mut(),
+            CurveUntyped::Float(v) => v.duration(),
+            CurveUntyped::Vec3(v) => v.duration(),
+            CurveUntyped::Vec4(v) => v.duration(),
+            CurveUntyped::Quat(v) => v.duration(),
         }
     }
 
-    pub fn type_name(&self) -> &str {
-        use std::any::type_name;
+    // pub fn value_type_name(&self) -> &str {
+    //     use std::any::type_name;
+    //     match self {
+    //         CurveUntyped::Float(_) => type_name::<f32>(),
+    //         CurveUntyped::Vec3(_) => type_name::<Vec3>(),
+    //         CurveUntyped::Vec4(_) => type_name::<Vec4>(),
+    //         CurveUntyped::Quat(_) => type_name::<Quat>(),
+    //     }
+    // }
+
+    pub fn value_type(&self) -> TypeId {
         match self {
-            Value::Float(_) => type_name::<f32>(),
-            Value::Vec3(_) => type_name::<Vec3>(),
-            Value::Vec4(_) => type_name::<Vec4>(),
-            Value::Quat(_) => type_name::<Quat>(),
+            CurveUntyped::Float(_) => TypeId::of::<f32>(),
+            CurveUntyped::Vec3(_) => TypeId::of::<Vec3>(),
+            CurveUntyped::Vec4(_) => TypeId::of::<Vec4>(),
+            CurveUntyped::Quat(_) => TypeId::of::<Quat>(),
         }
     }
 }
@@ -115,6 +144,10 @@ impl<T> Curve<T>
 where
     T: LerpValue,
 {
+    pub fn duration(&self) -> f32 {
+        self.samples.last().copied().unwrap_or(0.0)
+    }
+
     pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
         // TODO: Proper error handling
         assert!(samples.len() == values.len());
@@ -147,17 +180,16 @@ where
             //println!("{} => ({}, {}) => {}", time, i, index, t);
             //let t = t.max(0.0).min(1.0);
             debug_assert!(t >= 0.0 && t <= 1.0); // Checks if it's required to normalize t
-            T::lerp(self.values[i], self.values[index], t)
+            T::lerp(&self.values[i], &self.values[index], t)
         };
 
         (index, value)
     }
 }
 
-// TODO: rename to Layer
 #[derive(Default, Debug, Clone, Properties)]
-struct State {
-    //pub weight: f32, // TODO: Enable blending logic
+struct Layer {
+    pub weight: f32,
     pub clip: usize,
     pub time: f32,
     keyframe: Vec<usize>,
@@ -165,266 +197,385 @@ struct State {
 
 #[derive(Debug, Properties)]
 pub struct Animator {
-    animations: Vec<Handle<Clip>>,
+    clips: Vec<Handle<Clip>>,
     #[property(ignore)]
-    binds: Vec<ValueBind>,
+    binds: Vec<Option<Binds>>,
     pub time_scale: f32,
-    current: State,
-    //pub states: Vec<State>,
+    pub layers: Vec<Layer>,
+    // TODO: Transitions to control the animation layer blending byt time and other params
 }
 
 impl Default for Animator {
     fn default() -> Self {
         Self {
-            animations: vec![],
+            clips: vec![],
             binds: vec![],
             time_scale: 1.0,
-            current: State::default(),
-            // next: None,
-            // transition: Lerp::default(),
+            layers: vec![],
         }
     }
 }
 
 impl Animator {
     pub fn add_clip(&mut self, clip: Handle<Clip>) {
-        if self.animations.contains(&clip) {
+        if self.clips.contains(&clip) {
             return;
         }
-        self.animations.push(clip);
+        self.clips.push(clip);
     }
 
     pub fn clips_len(&self) -> usize {
-        self.animations.len()
+        self.clips.len()
     }
 }
 
-// TODO: Remove
 #[derive(Debug)]
-struct ValueBind {
-    dirty: bool,
-    valid: Vec<bool>,
-    entities: Vec<Entity>,
-    components: Vec<TypeId>,
-    properties: Vec<isize>,
+struct Binds {
+    metadata: Vec<BindMeta>,
+    curves: Vec<u16>,
+    attributes: Vec<Ptr>,
 }
 
-impl Default for ValueBind {
-    fn default() -> Self {
-        Self {
-            dirty: true,
-            valid: vec![],
-            entities: vec![],
-            components: vec![],
-            properties: vec![],
-        }
-    }
-}
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+struct Ptr(*mut u8);
+
+// SAFETY: Store pointers to each attribute to be updated, a clip can't have two pointers
+// with the same value. Each clip per Animator will be updated sequentially
+unsafe impl Send for Ptr {}
+unsafe impl Sync for Ptr {}
 
-/// Batch of all necessary commands that can run on parallel
+/// Marker type for missing component
+struct MissingComponentMarker;
+
+/// Missing component
+const MISSING_COMPONENT: TypeId = TypeId::of::<MissingComponentMarker>();
+
+/// Meta data is used to check the bind validity
 #[derive(Debug)]
-struct ClipCommandsBatch {
-    commands: Vec<Command>,
+struct BindMeta {
+    entity_index: u16,
+    inner: Option<BindInner>,
+    range: (u16, u16),
 }
 
 #[derive(Debug)]
-struct Command {
+struct BindInner {
+    parent: Option<Entity>,
     entity: Entity,
-    curves: Vec<u16>,
-    offsets: Vec<isize>,
+    location: Location,
+    component: TypeId,
+}
+
+#[derive(Default)]
+struct ClipResourceProviderState {
+    clip_event_reader: EventReader<AssetEvent<Clip>>,
 }
 
-/// Fetches entities and properties to animate
 #[tracing::instrument(skip(world, resources))]
-pub(crate) fn animator_fetch(world: &mut World, resources: &mut Resources) {
-    // Fetch useful resources
+pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resources) {
+    let system_id = SystemId(0); // ? NOTE: shouldn't be required to match the system id
+
+    // Fetch resources
+    let mut state = resources
+        .get_local_mut::<ClipResourceProviderState>(system_id)
+        .unwrap();
+
     let type_registry = resources.get::<TypeRegistry>().unwrap();
+    let type_registry_read_guard = type_registry.component.read();
+
     let clips = resources.get::<Assets<Clip>>().unwrap();
+    let clip_events = resources.get::<Events<AssetEvent<Clip>>>().unwrap();
+
+    // Builds query
+    // SAFETY: Only query with mutable reference the Animator component
+    let mut animator_query =
+        unsafe { world.query_unchecked::<(Entity, &mut Animator, &Children), ()>() };
+
+    // ? NOTE: Changing a clip on fly is supported, but very expensive so use with caution
+    // Query all clips that changed and remove their binds from the animator
+    let mut modified = HashSet::default();
+    for event in state.clip_event_reader.iter(&clip_events) {
+        match event {
+            AssetEvent::Removed { handle } => modified.insert(handle),
+            AssetEvent::Modified { handle } => modified.insert(handle),
+            _ => false,
+        };
+    }
 
-    // Build queries
-    let animators_query = unsafe { world.query_unchecked::<(&mut Animator, &Children), ()>() };
-
-    // TODO: Parallelize use ComputeTaskPool resource?
-    for (mut animator, root_children) in animators_query {
-        // Trick for proper borrow rules
-        let animator = &mut *animator;
-
-        // TODO: Needs to be updated when the hierarch change
-        // TODO: Needs to be updated when a clip changes
-        let animations_count = animator.animations.len();
-        if animations_count == animator.binds.len() {
-            if animator.binds.iter().all(|item| !item.dirty) {
-                break;
-            }
-        }
+    for (root, mut animator, children) in animator_query {
+        let mut animator = &mut *animator; // Make sure the borrow checker is happy
+
+        // Make room for binds or deallocate unused
+        animator.binds.resize_with(animator.clips.len(), || None);
 
-        animator
-            .binds
-            .resize_with(animations_count, || Default::default());
+        // Used for entity translation
+        let mut entities_table_cache = vec![];
 
-        for (clip_index, clip_handle) in animator.animations.iter().enumerate() {
-            let instance = &mut animator.binds[clip_index];
-            if !instance.dirty {
-                continue;
+        for (clip_handle, bind) in animator.clips.iter().zip(animator.binds.iter_mut()) {
+            // Invalidate binds for clips that where modified
+            if modified.contains(clip_handle) {
+                *bind = None;
             }
 
             if let Some(clip) = clips.get(clip_handle) {
-                // Get instance reference to modify during the function
-                instance.dirty = false;
-
-                let mut paths = clip
-                    .properties
-                    .iter()
-                    .map(|p| {
-                        let mut split = p.split('@');
-                        (
-                            split.next().unwrap_or("").split('/'),
-                            split.next().unwrap_or("").split('.'),
-                        )
-                    })
-                    .collect::<Vec<_>>();
-
-                // NOTE: `clear` then `resize` is an good way of reuse memory
-                // as much as possible but it doesn't free it so it may come
-                // to need to manually trim these Vec's whenever they get too large
-
-                let valid = &mut instance.valid;
-                valid.clear();
-                valid.resize(paths.len(), false);
-
-                let entities = &mut instance.entities;
-                entities.clear();
-                entities.resize(paths.len(), Entity::new(u32::MAX));
-
-                let mut hierarchy = paths.iter_mut().map(|p| p.0.next()).collect::<Vec<_>>();
-
-                // 1. Find entities
-                let mut stack = vec![];
-                // First uneducated search for all hierarchy
-                for parent in root_children.iter().copied() {
-                    if let Ok((entity, name, children)) =
-                        world.query_one::<(Entity, &Name, &Children)>(parent)
+                // Prepare the entities table cache
+                entities_table_cache.clear();
+                entities_table_cache.resize(clip.entities.len(), None);
+                // Assign the root entity as the first element
+                entities_table_cache[0] = Some(root);
+
+                if bind.is_none() {
+                    // Build binds from scratch
+                    // Allocate the minium enough of memory on right at the begin
+                    let b = Binds {
+                        metadata: Vec::with_capacity(clip.entities.len()),
+                        curves: Vec::with_capacity(clip.attribute.len()),
+                        attributes: Vec::with_capacity(clip.attribute.len()),
+                    };
+
+                    let mut range = (0, 0);
+                    let mut prev_partial_info = None;
+                    let mut prev_component = MISSING_COMPONENT;
+                    let mut prev_component_short_name = "";
+
+                    for (curve_index, (entity_index, attr_path)) in
+                        clip.attribute.iter().enumerate()
                     {
-                        let name = Some(name.0.as_str());
-                        for (i, level) in hierarchy.iter_mut().enumerate() {
-                            if *level != name {
-                                continue;
+                        let mut commit = false;
+                        let mut partial_info = None;
+                        let mut component = MISSING_COMPONENT;
+
+                        // Query component by name
+                        let path = attr_path.split('.');
+                        let component_short_name =
+                            path.next().expect("missing component short name");
+
+                        if let Some(entity) = find_entity(
+                            *entity_index,
+                            &clip.entities,
+                            &mut entities_table_cache,
+                            &world,
+                        ) {
+                            let location = world.get_entity_location(entity).unwrap();
+
+                            // Commit is needed
+                            partial_info = Some((entity, location));
+                            if prev_partial_info != partial_info {
+                                commit = true;
                             }
 
-                            *level = paths[i].0.next();
-                            entities[i] = entity;
-                            valid[i] = true;
-                            stack.push((i, children));
-                        }
-                    }
-                }
-                // Fast educated search into the nested hierarchy
-                // TODO: Many identical queries for the same entity will happen here!
-                while let Some((i, parents)) = stack.pop() {
-                    for parent in parents.iter().copied() {
-                        if let Ok((entity, name, children)) =
-                            world.query_one::<(Entity, &Name, &Children)>(parent)
-                        {
-                            if hierarchy[i] == Some(name.0.as_str()) {
-                                hierarchy[i] = paths[i].0.next();
-                                entities[i] = entity; // Replaces the entity for the lowest
-                                valid[i] = true;
-                                stack.push((i, children));
-                                break;
+                            if let Some(component_reg) =
+                                type_registry_read_guard.get_with_short_name(component_short_name)
+                            {
+                                component = component_reg.ty;
+
+                                let root_props = component_reg.get_component_properties(
+                                    &world.archetypes[location.archetype as usize],
+                                    location.index,
+                                );
+
+                                b.curves.push(curve_index as u16);
+                                b.attributes.push(Ptr(find_target_property(path, root_props)
+                                    .and_then(|prop| {
+                                        if prop.any().type_id()
+                                            == clip.curves[curve_index].value_type()
+                                        {
+                                            Some(prop.as_ptr() as *mut _)
+                                        } else {
+                                            // TODO: Log warn wrong type
+                                            None
+                                        }
+                                    })
+                                    .unwrap_or(null_mut())));
+
+                                // Group by component type
+                                commit |= prev_component != component;
+                            } else {
+                                // Missing component
+                                b.curves.push(curve_index as u16);
+                                b.attributes.push(Ptr(null_mut()));
+
+                                // Group by component name
+                                commit |= prev_component_short_name != component_short_name;
                             }
+                        } else {
+                            // Missing entity
+                            commit = prev_partial_info != partial_info;
+                            commit |= prev_component_short_name != component_short_name;
+
+                            b.curves.push(curve_index as u16);
+                            b.attributes.push(Ptr(null_mut()));
+                        }
+
+                        if commit {
+                            // Close range
+                            range.1 = b.curves.len() as u16;
+
+                            // Commit meta
+                            b.metadata.push(BindMeta {
+                                entity_index: *entity_index,
+                                inner: prev_partial_info.map(|(entity, location)| BindInner {
+                                    // An entity will always have parent unless is the root entity
+                                    parent: entities_table_cache
+                                        .get(clip.entities[*entity_index as usize].0 as usize)
+                                        .copied()
+                                        .flatten(),
+                                    entity,
+                                    location,
+                                    component,
+                                }),
+                                range,
+                            });
+
+                            // Jump to the next range
+                            prev_partial_info = partial_info;
+                            prev_component = component;
+                            prev_component_short_name = component_short_name;
+                            range.0 = range.1;
                         }
                     }
+
+                    *bind = Some(b);
+
+                    // No need to continue because binds are fresh
+                    continue;
                 }
 
-                let components = &mut instance.components;
-                components.clear();
-                components.resize(paths.len(), TypeId::of::<()>());
-
-                let properties = &mut instance.properties;
-                properties.clear();
-                properties.resize(paths.len(), 0);
-
-                // 2. Find components and properties in all entities that completed the path
-                for (i, level) in hierarchy.iter().enumerate() {
-                    if valid[i] {
-                        // Not reached the entity at the path
-                        if level.is_some() {
-                            valid[i] = false;
-                            continue;
+                // Check bind state and update the necessary parts
+                let bind = bind.unwrap();
+                for meta in bind.metadata.iter_mut() {
+                    if meta.inner.is_none() {
+                        // TODO: Handle missing entity
+                        continue;
+                    }
+
+                    let inner = meta.inner.as_mut().unwrap();
+
+                    // TODO: Handle `Parent` change ..
+
+                    let mut loc = world.get_entity_location(inner.entity);
+                    if loc.is_none() {
+                        // Missing entity
+                        if let Some(found_entity) = find_entity(
+                            meta.entity_index,
+                            &clip.entities,
+                            &mut entities_table_cache,
+                            &world,
+                        ) {
+                            // Found new entity
+                            inner.entity = found_entity;
+                            // Fetch it's location
+                            loc = world.get_entity_location(found_entity);
+                        } else {
+                            // Entity wasn't found, invalidate all the bind attributes
+                            for i in (meta.range.0)..(meta.range.1) {
+                                bind.attributes[i as usize] = Ptr(null_mut());
+                            }
                         }
+                    }
 
-                        let component = paths[i].1.next().unwrap_or("?");
-                        if let Some(component_reg) = type_registry
-                            .component
-                            .read()
-                            .get_with_short_name(component)
-                        {
-                            if let Some(location) = world.get_entity_location(entities[i]) {
-                                components[i] = component_reg.ty;
+                    let loc = loc.unwrap();
+                    if inner.location == loc {
+                        // Nothing left todo
+                        continue;
+                    }
 
-                                let root_properties = component_reg.get_component_properties(
-                                    &world.archetypes[location.archetype as usize],
-                                    location.index,
-                                );
+                    if inner.component == MISSING_COMPONENT {
+                        // TODO: Find component by name
+                        continue;
+                    }
 
-                                // Find the target property to animate
-                                let mut properties_lookup = Some(root_properties.clone());
-                                let mut target_property = None;
-
-                                for property_name in &mut paths[i].1 {
-                                    if let Some(property) =
-                                        properties_lookup.map(|p| p.prop(property_name)).flatten()
-                                    {
-                                        // NOTE: Vec, HashMap and other types can't be animated
-                                        // and needed to be filtered out
-                                        if property.property_type() != PropertyType::Value {
-                                            target_property = None;
-                                            valid[i] = false;
-                                            break;
-                                        }
+                    // Entity archetype changed
+                    if let Some(component_reg) = type_registry_read_guard.get(&inner.component) {
+                        let root_props = component_reg.get_component_properties(
+                            &world.archetypes[loc.archetype as usize],
+                            loc.index,
+                        );
+
+                        // Update pointers to reflect the new entity memory location
+                        for i in (meta.range.0)..(meta.range.1) {
+                            let i = i as usize;
+                            let curve_index = bind.curves[i] as usize;
+                            let path = clip.attribute[curve_index].1.split('.');
+                            path.next(); // Skip component
+                            if let Some(prop) = find_target_property(path, root_props) {
+                                // Found property
+                                bind.attributes[i] = Ptr(prop.as_ptr() as *mut _);
+                            } else {
+                                bind.attributes[i] = Ptr(null_mut());
+                            }
+                        }
+                    }
 
-                                        properties_lookup = property.as_properties();
-                                        target_property = Some(property);
-                                    } else {
-                                        // Failed to find property
-                                        target_property = None;
-                                        valid[i] = false;
-                                        break;
-                                    }
-                                }
+                    // Update bind location
+                    inner.location = loc;
+                }
+            }
+        }
+    }
+}
 
-                                if let Some(target_property) = target_property {
-                                    // Check for the expected type
-                                    if target_property.type_name() == clip.values[i].type_name() {
-                                        properties[i] = {
-                                            let root_ptr = root_properties.as_ptr();
-                                            let target_ptr = target_property.as_ptr();
-                                            // ! NOTE: Requires rust 1.47.0
-                                            // TODO: Need safety check or SAFE argument
-                                            unsafe { target_ptr.offset_from(root_ptr) }
-                                        };
-                                    } else {
-                                        valid[i] = false;
-                                    }
-                                // locations[i] = location;
+fn find_entity(
+    entity_index: u16,
+    entities_ids: &Vec<(u16, String)>,
+    entities_table_cache: &mut Vec<Option<Entity>>,
+    world: &World,
+) -> Option<Entity> {
+    if let Some(entity) = &entities_table_cache[entity_index as usize] {
+        Some(*entity)
+    } else {
+        let (parent_index, entity_name) = &entities_ids[entity_index as usize];
+        // Use recursion to find the entity parent
+        find_entity(*parent_index, entities_ids, entities_table_cache, world).and_then(
+            |parent_entity| {
+                if let Ok((children,)) = world.get::<(Children,)>(parent_entity) {
+                    children
+                        .iter()
+                        .find(|entity| {
+                            if let Ok((name,)) = world.get::<(Name,)>(**entity) {
+                                if &name.0 == entity_name {
+                                    // Update cache
+                                    entities_table_cache[entity_index as usize] = Some(**entity);
+                                    true
                                 } else {
-                                    valid[i] = false;
+                                    false
                                 }
+                            } else {
+                                false
                             }
-                        }
-                    }
+                        })
+                        .copied()
+                } else {
+                    None
                 }
+            },
+        )
+    }
+}
 
-                // for (i, valid) in valid.iter().copied().enumerate() {
-                //     if valid {
-                //         println!("found: {}", &clip.properties[i]);
-                //     } else {
-                //         println!("missing: {}", &clip.properties[i]);
-                //     }
-                // }
+fn find_target_property<'a, P: Iterator<Item = &'a str>>(
+    path: P,
+    mut root_props: &dyn Properties,
+) -> Option<&dyn Properties> {
+    let mut target_property = None;
+    for property_name in path {
+        if let Some(property) = root_props.prop(property_name) {
+            // NOTE: Vec, HashMap and other types can't be animated
+            // and needed to be filtered out
+            if property.property_type() != PropertyType::Value {
+                target_property = None;
+                break;
             }
+
+            root_props = property.as_properties().unwrap();
+            target_property = Some(root_props);
+        } else {
+            // Failed to find property
+            target_property = None;
+            break;
         }
     }
+    target_property
 }
 
 #[tracing::instrument(skip(world, resources))]
@@ -435,18 +586,11 @@ pub(crate) fn animator_update(world: &mut World, resources: &mut Resources) {
 
     // Build queries
     let animators_query = unsafe { world.query_unchecked::<(&mut Animator,), ()>() };
-
-    // let delta_time = if keyboard.just_pressed(KeyCode::Right) {
-    //     1.0 / 60.0
-    // } else {
-    //     0.0
-    // };
-
     let delta_time = time.delta_seconds;
 
     // TODO: Parallelize
     for (mut animator,) in animators_query {
-        let animator = &mut *animator;
+        let mut animator = &mut *animator;
 
         // Time scales by component
         let delta_time = delta_time * animator.time_scale;
@@ -454,13 +598,13 @@ pub(crate) fn animator_update(world: &mut World, resources: &mut Resources) {
         let current = &mut animator.current;
         let clip_index = current.clip;
         if let Some(current_clip) = animator
-            .animations
+            .clips
             .get(clip_index)
             .map(|clip_handle| clips.get(clip_handle))
             .flatten()
         {
             let bind = &animator.binds[clip_index];
-            let curves_count = current_clip.values.len();
+            let curves_count = current_clip.curves.len();
 
             // Ensure capacity for cached keyframe index vec
             if current.keyframe.len() != curves_count {
@@ -476,8 +620,8 @@ pub(crate) fn animator_update(world: &mut World, resources: &mut Resources) {
             // Warp mode
             if current_clip.warp {
                 // Warp Around
-                if time > current_clip.length {
-                    time = (time / current_clip.length).fract() * current_clip.length;
+                if time > current_clip.duration {
+                    time = (time / current_clip.duration).fract() * current_clip.duration;
                     // Reset all keyframes cached indexes
                     current
                         .keyframe
@@ -486,7 +630,7 @@ pub(crate) fn animator_update(world: &mut World, resources: &mut Resources) {
                 }
             } else {
                 // Hold
-                time = time.min(current_clip.length);
+                time = time.min(current_clip.duration);
             }
 
             // Advance state time
@@ -500,7 +644,7 @@ pub(crate) fn animator_update(world: &mut World, resources: &mut Resources) {
                 index: usize::MAX,
             };
             for i in 0..curves_count {
-                if !bind.valid[i] {
+                if !bind.valid.get(i).unwrap_or(&false) {
                     continue;
                 }
 
@@ -541,26 +685,26 @@ pub(crate) fn animator_update(world: &mut World, resources: &mut Resources) {
                 let attr = pointer.wrapping_offset(bind.properties[i]);
                 let keyframe = &mut current.keyframe[i];
 
-                match &current_clip.values[i] {
-                    Value::Float(v) => {
+                match &current_clip.curves[i] {
+                    CurveUntyped::Float(v) => {
                         let (k, v) = v.sample(*keyframe, time);
                         let attr = unsafe { &mut *(attr as *mut f32) };
                         *attr = v;
                         *keyframe = k;
                     }
-                    Value::Vec3(v) => {
+                    CurveUntyped::Vec3(v) => {
                         let (k, v) = v.sample(*keyframe, time);
                         let attr = unsafe { &mut *(attr as *mut Vec3) };
                         *attr = v;
                         *keyframe = k;
                     }
-                    Value::Vec4(v) => {
+                    CurveUntyped::Vec4(v) => {
                         let (k, v) = v.sample(*keyframe, time);
                         let attr = unsafe { &mut *(attr as *mut Vec4) };
                         *attr = v;
                         *keyframe = k;
                     }
-                    Value::Quat(v) => {
+                    CurveUntyped::Quat(v) => {
                         let (k, v) = v.sample(*keyframe, time);
                         let attr = unsafe { &mut *(attr as *mut Quat) };
                         *attr = v;
diff --git a/crates/bevy_animation/src/lerping.rs b/crates/bevy_animation/src/lerping.rs
index a31db95b8e8a7..b1344dddeb917 100644
--- a/crates/bevy_animation/src/lerping.rs
+++ b/crates/bevy_animation/src/lerping.rs
@@ -1,50 +1,61 @@
 // use bevy_asset::prelude::*;
+use bevy_asset::{Asset, Handle, HandleUntyped};
 use bevy_math::prelude::*;
 
-pub trait LerpValue: Copy {
-    fn lerp(a: Self, b: Self, t: f32) -> Self;
+pub trait LerpValue {
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self;
 }
 
 impl LerpValue for f32 {
-    fn lerp(a: Self, b: Self, t: f32) -> Self {
-        a * (1.0 - t) + b * t
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        (*a) * (1.0 - t) + (*b) * t
     }
 }
 
 impl LerpValue for Vec2 {
-    fn lerp(a: Self, b: Self, t: f32) -> Self {
-        a * (1.0 - t) + b * t
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        (*a) * (1.0 - t) + (*b) * t
     }
 }
 
 impl LerpValue for Vec3 {
-    fn lerp(a: Self, b: Self, t: f32) -> Self {
-        a * (1.0 - t) + b * t
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        (*a) * (1.0 - t) + (*b) * t
     }
 }
 
 impl LerpValue for Vec4 {
-    fn lerp(a: Self, b: Self, t: f32) -> Self {
-        a * (1.0 - t) + b * t
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        (*a) * (1.0 - t) + (*b) * t
     }
 }
 
 impl LerpValue for Quat {
     /// Actually performs an nlerp, because it's much cheaper and easer to combine with other animations,
     /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
-    fn lerp(a: Self, b: Self, t: f32) -> Self {
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         // ! NOTE: slerp is nice if you want to debug the animation code
         // a.slerp(b, t)
-        Vec4::lerp(a.into(), b.into(), t).normalize().into()
+        Vec4::lerp((*a).into(), (*b).into(), t).normalize().into()
     }
 }
 
-// impl<T: 'static> LerpValue for Handle<T> {
-//     fn lerp(a: Self, b: Self, t: f32) -> Self {
-//         if t > 0.5 {
-//             b
-//         } else {
-//             a
-//         }
-//     }
-// }
+impl<T: Asset + 'static> LerpValue for Handle<T> {
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        if t > 0.99 {
+            b.clone()
+        } else {
+            a.clone()
+        }
+    }
+}
+
+impl LerpValue for HandleUntyped {
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        if t > 0.99 {
+            b.clone()
+        } else {
+            a.clone()
+        }
+    }
+}
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 2f2bfbc6e78af..c41ed9458bc39 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1,6 +1,6 @@
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::prelude::*;
+//use bevy_ecs::prelude::*;
 use bevy_type_registry::RegisterType;
 
 pub mod generic;
@@ -12,13 +12,16 @@ pub use crate::skined_mesh::*;
 //mod util;
 
 pub mod prelude {
-    pub use crate::generic::{Animator, Clip, Curve, Value};
+    pub use crate::generic::{Animator, Clip, Curve, CurveUntyped};
     pub use crate::lerping::LerpValue;
     pub use crate::skined_mesh::{MeshSkin, MeshSkinBinder, MeshSkinnerDebuger};
 }
 
 pub mod stage {
     pub const ANIMATE: &'static str = "animate";
+    // ? NOTE: At this stage the Children component should be in a valid state
+    // sadly this will add a one frame startup delay for each animator
+    pub(crate) const WARM_ANIMATE: &'static str = "warm_animate";
     pub use bevy_app::stage::POST_UPDATE;
     pub use bevy_app::stage::UPDATE;
 }
@@ -28,19 +31,21 @@ pub struct AnimationPlugin;
 
 impl Plugin for AnimationPlugin {
     fn build(&self, app: &mut AppBuilder) {
+        app.add_stage_after(stage::UPDATE, stage::ANIMATE);
+        app.add_stage_after(stage::POST_UPDATE, stage::WARM_ANIMATE);
+
         // Generic animation
         app.add_asset::<Clip>()
             //.add_asset_loader(ClipLoader)
-            .add_stage_after(stage::UPDATE, stage::ANIMATE)
             .register_component::<Animator>()
-            .add_system_to_stage(stage::ANIMATE, animator_update.thread_local_system())
-            .add_system_to_stage_front(stage::ANIMATE, animator_fetch.thread_local_system());
+            .add_system_to_stage(stage::ANIMATE, animator_update)
+            .add_system_to_stage(stage::WARM_ANIMATE, animator_fetch);
 
         // Skinning
         app.add_asset::<MeshSkin>()
             .register_component_with::<MeshSkinBinder>(|reg| reg.map_entities())
             .register_component::<MeshSkinnerDebuger>()
-            .add_system_to_stage(stage::POST_UPDATE, mesh_skinner_debugger_update.system())
-            .add_system_to_stage_front(stage::UPDATE, mesh_skinner_startup.system());
+            .add_system_to_stage(stage::ANIMATE, mesh_skinner_debugger_update)
+            .add_system_to_stage(stage::WARM_ANIMATE, mesh_skinner_startup);
     }
 }
diff --git a/crates/bevy_animation/src/skined_mesh.rs b/crates/bevy_animation/src/skined_mesh.rs
index abd05bd6a4da6..a5377c5fecf7d 100644
--- a/crates/bevy_animation/src/skined_mesh.rs
+++ b/crates/bevy_animation/src/skined_mesh.rs
@@ -126,6 +126,7 @@ pub(crate) fn mesh_skinner_startup(
                     if root {
                         children.map(|c| stack.extend(c.iter()));
                         root = false;
+                        continue;
                     }
 
                     if let Some((bone_index, _)) = skin
@@ -244,6 +245,8 @@ pub(crate) fn mesh_skinner_startup(
 pub struct MeshSkinnerDebuger {
     //pub enabled: bool,
     #[property(ignore)]
+    started: bool,
+    #[property(ignore)]
     mesh: Option<Handle<Mesh>>,
     #[property(ignore)]
     entity: Option<Entity>,
@@ -257,6 +260,10 @@ pub(crate) fn mesh_skinner_debugger_update(
     bones_query: Query<(&GlobalTransform,)>,
 ) {
     for (skin_handle, skinner, mut debugger) in debugger_query.iter_mut() {
+        if skinner.skin.as_ref() != Some(skin_handle) {
+            continue;
+        }
+
         let debugger = &mut *debugger;
 
         // if !debugger.enabled {
@@ -267,18 +274,24 @@ pub(crate) fn mesh_skinner_debugger_update(
             if debugger.mesh.is_none() {
                 let mesh = Mesh::new(PrimitiveTopology::LineList);
                 debugger.mesh = Some(meshes.add(mesh));
+            }
 
+            if !debugger.started {
                 let bone_mesh = meshes.add(Mesh::from(shape::Cube { size: 0.02 }));
                 for bone in skinner.bones.iter() {
                     if let Some(entity) = bone {
                         commands
-                            .spawn(PbrComponents {
+                            .spawn(PbrBundle {
                                 mesh: bone_mesh.clone(),
                                 ..Default::default()
                             })
                             .with(Parent(*entity));
+
+                        dbg!(commands.current_entity());
                     }
                 }
+
+                debugger.started = true;
             }
 
             let mesh_handle = debugger.mesh.as_ref().unwrap();
@@ -286,7 +299,7 @@ pub(crate) fn mesh_skinner_debugger_update(
 
             if debugger.entity.is_none() {
                 debugger.entity = commands
-                    .spawn(PbrComponents {
+                    .spawn(PbrBundle {
                         mesh: mesh_handle.clone(),
                         ..Default::default()
                     })
@@ -314,6 +327,7 @@ pub(crate) fn mesh_skinner_debugger_update(
 
             let mut indices = vec![];
             let mut vertices = vec![];
+
             for (i, parent) in skin.bones_parents.iter().enumerate() {
                 if let Some(parent) = *parent {
                     indices.push(vertices.len() as u32);
@@ -323,10 +337,31 @@ pub(crate) fn mesh_skinner_debugger_update(
                 }
             }
 
+            // TODO: Change shader to not require normals and uv attributes
+
+            let normals = Some([0f32; 3])
+                .iter()
+                .copied()
+                .cycle()
+                .take(vertices.len())
+                .collect::<Vec<_>>();
+
+            let uvs = Some([0f32; 2])
+                .iter()
+                .copied()
+                .cycle()
+                .take(vertices.len())
+                .collect::<Vec<_>>();
+
             mesh.set_attribute(
                 Mesh::ATTRIBUTE_POSITION,
                 VertexAttributeValues::Float3(vertices),
             );
+            mesh.set_attribute(
+                Mesh::ATTRIBUTE_NORMAL,
+                VertexAttributeValues::Float3(normals),
+            );
+            mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, VertexAttributeValues::Float2(uvs));
             mesh.set_indices(Some(Indices::U32(indices)));
         }
     }
diff --git a/crates/bevy_ecs/src/core/entities.rs b/crates/bevy_ecs/src/core/entities.rs
index 2a5cc637481bb..51e6477e43ac6 100644
--- a/crates/bevy_ecs/src/core/entities.rs
+++ b/crates/bevy_ecs/src/core/entities.rs
@@ -338,7 +338,7 @@ pub(crate) struct EntityMeta {
 }
 
 /// A location of an entity in an archetype
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub struct Location {
     /// The archetype index
     pub archetype: u32,
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 92c9aa7442e2a..a1a2781a702bc 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -302,7 +302,7 @@ async fn load_gltf<'a, 'b>(
                     property_path += "@Transform.translation";
                     clip.add_animated_prop(
                         property_path,
-                        Value::Vec3(Curve::new(time_stamps, values)),
+                        CurveUntyped::Vec3(Curve::new(time_stamps, values)),
                     )
 
                     // TODO: This is a runtime importer so here's no place for further optimizations
@@ -340,7 +340,7 @@ async fn load_gltf<'a, 'b>(
                     property_path += "@Transform.rotation";
                     clip.add_animated_prop(
                         property_path,
-                        Value::Quat(Curve::new(time_stamps, values)),
+                        CurveUntyped::Quat(Curve::new(time_stamps, values)),
                     );
                 }
                 ReadOutputs::Scales(values) => {
@@ -349,7 +349,7 @@ async fn load_gltf<'a, 'b>(
                     property_path += "@Transform.scale";
                     clip.add_animated_prop(
                         property_path,
-                        Value::Vec3(Curve::new(time_stamps, values)),
+                        CurveUntyped::Vec3(Curve::new(time_stamps, values)),
                     )
                 }
                 ReadOutputs::MorphTargetWeights(_) => {

From 95430a054801f1334f83ffed051e044ae5aa3584 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Mon, 23 Nov 2020 01:03:05 -0300
Subject: [PATCH 010/153] major rewrite works but it seems something is not
 right

---
 crates/bevy_animation/src/generic.rs     | 338 ++++++++++++-----------
 crates/bevy_animation/src/lib.rs         |  10 +-
 crates/bevy_animation/src/skined_mesh.rs |   2 -
 crates/bevy_gltf/src/loader.rs           |  32 +--
 4 files changed, 199 insertions(+), 183 deletions(-)

diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 90d33c982650f..377045e41b75c 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -1,12 +1,11 @@
 use anyhow::Result;
 use bevy_app::prelude::{EventReader, Events};
-use bevy_asset::{AssetEvent, Assets, Handle, HandleUntyped};
+use bevy_asset::{AssetEvent, Assets, Handle /*, HandleUntyped*/};
 use bevy_core::prelude::*;
 use bevy_ecs::prelude::*;
 use bevy_ecs::{Location, SystemId};
 use bevy_math::prelude::*;
-use bevy_property::Properties;
-use bevy_property::PropertyType;
+use bevy_property::{Properties, Property, PropertyType};
 use bevy_transform::prelude::*;
 use bevy_type_registry::{TypeRegistry, TypeUuid};
 use bevy_utils::HashSet;
@@ -79,9 +78,9 @@ impl Clip {
             } else {
                 // Add entity
                 let e = self.entities.len();
+                self.entities.push((entity, name.to_string()));
                 // Soft limit added to save memory, identical to the curve limit
                 entity = u16::try_from(e).expect("entities limit reached");
-                self.entities.push((entity, name.to_string()));
             }
         }
 
@@ -89,9 +88,14 @@ impl Clip {
         // TODO: we can only have (u16 - 1) max
         // TODO: "...@Transform.translation" and "...@Transform.translation.x" can't live with each other
         self.duration = self.duration.max(curve.duration());
-        self.attribute.push((entity, path.1.to_string()));
+        self.attribute
+            .push((entity, path.1.split_at(1).1.to_string()));
         self.curves.push(curve);
     }
+
+    pub fn duration(&self) -> f32 {
+        self.duration
+    }
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -142,14 +146,13 @@ pub struct Curve<T> {
 
 impl<T> Curve<T>
 where
-    T: LerpValue,
+    T: LerpValue + Clone,
 {
     pub fn duration(&self) -> f32 {
         self.samples.last().copied().unwrap_or(0.0)
     }
 
     pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
-        // TODO: Proper error handling
         assert!(samples.len() == values.len());
         Self { samples, values }
     }
@@ -160,7 +163,7 @@ where
         let last_index = self.samples.len() - 1;
         loop {
             if index > last_index {
-                return (last_index, *self.values.last().unwrap());
+                return (last_index, self.values.last().unwrap().clone());
             }
 
             if self.samples[index] < time {
@@ -171,7 +174,7 @@ where
         }
 
         let value = if index == 0 {
-            self.values[0]
+            self.values[0].clone()
         } else {
             // Lerp the value
             let i = index - 1;
@@ -185,12 +188,30 @@ where
 
         (index, value)
     }
+
+    pub fn add_offset_time(&mut self, time_offset: f32) {
+        self.samples.iter_mut().for_each(|t| *t += time_offset);
+    }
+
+    // pub fn insert(&mut self, time_sample: f32, value: T) {
+    // }
+
+    // pub fn remove(&mut self, index: usize) {
+    // }
+
+    pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
+        self.samples.iter().copied().zip(self.values.iter())
+    }
+
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
+        self.samples.iter().copied().zip(self.values.iter_mut())
+    }
 }
 
 #[derive(Default, Debug, Clone, Properties)]
-struct Layer {
+pub struct Layer {
     pub weight: f32,
-    pub clip: usize,
+    pub clip: u16,
     pub time: f32,
     keyframe: Vec<usize>,
 }
@@ -202,7 +223,7 @@ pub struct Animator {
     binds: Vec<Option<Binds>>,
     pub time_scale: f32,
     pub layers: Vec<Layer>,
-    // TODO: Transitions to control the animation layer blending byt time and other params
+    // TODO: Transitions to simplify layer blending
 }
 
 impl Default for Animator {
@@ -217,11 +238,25 @@ impl Default for Animator {
 }
 
 impl Animator {
-    pub fn add_clip(&mut self, clip: Handle<Clip>) {
-        if self.clips.contains(&clip) {
-            return;
+    pub fn add_clip(&mut self, clip: Handle<Clip>) -> u16 {
+        if let Some(i) = self.clips.iter().position(|c| *c == clip) {
+            i as u16
+        } else {
+            let i = self.clips.len();
+            self.clips.push(clip);
+            i as u16
         }
-        self.clips.push(clip);
+    }
+
+    pub fn add_layer(&mut self, clip: Handle<Clip>, weight: f32) -> usize {
+        let clip = self.add_clip(clip);
+        let layer_index = self.layers.len();
+        self.layers.push(Layer {
+            clip,
+            weight,
+            ..Default::default()
+        });
+        layer_index
     }
 
     pub fn clips_len(&self) -> usize {
@@ -236,7 +271,7 @@ struct Binds {
     attributes: Vec<Ptr>,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 struct Ptr(*mut u8);
 
 // SAFETY: Store pointers to each attribute to be updated, a clip can't have two pointers
@@ -247,9 +282,6 @@ unsafe impl Sync for Ptr {}
 /// Marker type for missing component
 struct MissingComponentMarker;
 
-/// Missing component
-const MISSING_COMPONENT: TypeId = TypeId::of::<MissingComponentMarker>();
-
 /// Meta data is used to check the bind validity
 #[derive(Debug)]
 struct BindMeta {
@@ -276,9 +308,18 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
     let system_id = SystemId(0); // ? NOTE: shouldn't be required to match the system id
 
     // Fetch resources
-    let mut state = resources
-        .get_local_mut::<ClipResourceProviderState>(system_id)
-        .unwrap();
+    let mut state = {
+        let state = resources.get_local_mut::<ClipResourceProviderState>(system_id);
+        if state.is_none() {
+            std::mem::drop(state); // ? NOTE: Makes the borrow checker happy
+            resources.insert_local(system_id, ClipResourceProviderState::default());
+            resources
+                .get_local_mut::<ClipResourceProviderState>(system_id)
+                .unwrap()
+        } else {
+            state.unwrap()
+        }
+    };
 
     let type_registry = resources.get::<TypeRegistry>().unwrap();
     let type_registry_read_guard = type_registry.component.read();
@@ -288,8 +329,7 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
 
     // Builds query
     // SAFETY: Only query with mutable reference the Animator component
-    let mut animator_query =
-        unsafe { world.query_unchecked::<(Entity, &mut Animator, &Children), ()>() };
+    let animator_query = unsafe { world.query_unchecked::<(Entity, &mut Animator), ()>() };
 
     // ? NOTE: Changing a clip on fly is supported, but very expensive so use with caution
     // Query all clips that changed and remove their binds from the animator
@@ -302,8 +342,8 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
         };
     }
 
-    for (root, mut animator, children) in animator_query {
-        let mut animator = &mut *animator; // Make sure the borrow checker is happy
+    for (root, mut animator) in animator_query {
+        let animator = &mut *animator; // Make sure the borrow checker is happy
 
         // Make room for binds or deallocate unused
         animator.binds.resize_with(animator.clips.len(), || None);
@@ -327,7 +367,7 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
                 if bind.is_none() {
                     // Build binds from scratch
                     // Allocate the minium enough of memory on right at the begin
-                    let b = Binds {
+                    let mut b = Binds {
                         metadata: Vec::with_capacity(clip.entities.len()),
                         curves: Vec::with_capacity(clip.attribute.len()),
                         attributes: Vec::with_capacity(clip.attribute.len()),
@@ -335,7 +375,7 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
 
                     let mut range = (0, 0);
                     let mut prev_partial_info = None;
-                    let mut prev_component = MISSING_COMPONENT;
+                    let mut prev_component = TypeId::of::<MissingComponentMarker>();
                     let mut prev_component_short_name = "";
 
                     for (curve_index, (entity_index, attr_path)) in
@@ -343,10 +383,10 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
                     {
                         let mut commit = false;
                         let mut partial_info = None;
-                        let mut component = MISSING_COMPONENT;
+                        let mut component = TypeId::of::<MissingComponentMarker>();
 
                         // Query component by name
-                        let path = attr_path.split('.');
+                        let mut path = attr_path.split('.');
                         let component_short_name =
                             path.next().expect("missing component short name");
 
@@ -442,7 +482,7 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
                 }
 
                 // Check bind state and update the necessary parts
-                let bind = bind.unwrap();
+                let bind = bind.as_mut().unwrap();
                 for meta in bind.metadata.iter_mut() {
                     if meta.inner.is_none() {
                         // TODO: Handle missing entity
@@ -451,7 +491,24 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
 
                     let inner = meta.inner.as_mut().unwrap();
 
-                    // TODO: Handle `Parent` change ..
+                    // Handle `Parent` changed
+                    if let Some(parent) = inner.parent {
+                        // Not root
+                        if let Ok(Parent(new_parent)) =
+                            world.query_one_filtered::<&Parent, Changed<Parent>>(inner.entity)
+                        {
+                            if parent != *new_parent {
+                                // TODO: Look again for the entity
+
+                                // Invalidate bind ...
+                                meta.inner = None;
+                                for i in (meta.range.0)..(meta.range.1) {
+                                    bind.attributes[i as usize] = Ptr(null_mut());
+                                }
+                                continue;
+                            }
+                        }
+                    }
 
                     let mut loc = world.get_entity_location(inner.entity);
                     if loc.is_none() {
@@ -480,7 +537,7 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
                         continue;
                     }
 
-                    if inner.component == MISSING_COMPONENT {
+                    if inner.component == TypeId::of::<MissingComponentMarker>() {
                         // TODO: Find component by name
                         continue;
                     }
@@ -496,7 +553,7 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
                         for i in (meta.range.0)..(meta.range.1) {
                             let i = i as usize;
                             let curve_index = bind.curves[i] as usize;
-                            let path = clip.attribute[curve_index].1.split('.');
+                            let mut path = clip.attribute[curve_index].1.split('.');
                             path.next(); // Skip component
                             if let Some(prop) = find_target_property(path, root_props) {
                                 // Found property
@@ -525,14 +582,15 @@ fn find_entity(
         Some(*entity)
     } else {
         let (parent_index, entity_name) = &entities_ids[entity_index as usize];
+
         // Use recursion to find the entity parent
         find_entity(*parent_index, entities_ids, entities_table_cache, world).and_then(
             |parent_entity| {
-                if let Ok((children,)) = world.get::<(Children,)>(parent_entity) {
+                if let Ok(children) = world.get::<Children>(parent_entity) {
                     children
                         .iter()
                         .find(|entity| {
-                            if let Ok((name,)) = world.get::<(Name,)>(**entity) {
+                            if let Ok(name) = world.get::<Name>(**entity) {
                                 if &name.0 == entity_name {
                                     // Update cache
                                     entities_table_cache[entity_index as usize] = Some(**entity);
@@ -555,160 +613,124 @@ fn find_entity(
 
 fn find_target_property<'a, P: Iterator<Item = &'a str>>(
     path: P,
-    mut root_props: &dyn Properties,
-) -> Option<&dyn Properties> {
-    let mut target_property = None;
+    root_props: &dyn Properties,
+) -> Option<&dyn Property> {
+    let mut target = None;
+    let mut current = Some(root_props);
     for property_name in path {
-        if let Some(property) = root_props.prop(property_name) {
+        if let Some(property) = current.map(|p| p.prop(property_name)).flatten() {
             // NOTE: Vec, HashMap and other types can't be animated
             // and needed to be filtered out
             if property.property_type() != PropertyType::Value {
-                target_property = None;
+                target = None;
                 break;
             }
 
-            root_props = property.as_properties().unwrap();
-            target_property = Some(root_props);
+            target = Some(property);
+            current = property.as_properties();
         } else {
             // Failed to find property
-            target_property = None;
+            target = None;
             break;
         }
     }
-    target_property
+    target
 }
 
 #[tracing::instrument(skip(world, resources))]
-pub(crate) fn animator_update(world: &mut World, resources: &mut Resources) {
+pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resources) {
     let time = resources.get::<Time>().unwrap();
     let clips = resources.get::<Assets<Clip>>().unwrap();
-    let type_registry = resources.get::<TypeRegistry>().unwrap();
 
     // Build queries
     let animators_query = unsafe { world.query_unchecked::<(&mut Animator,), ()>() };
     let delta_time = time.delta_seconds;
 
-    // TODO: Parallelize
     for (mut animator,) in animators_query {
-        let mut animator = &mut *animator;
+        let animator = &mut *animator;
 
         // Time scales by component
         let delta_time = delta_time * animator.time_scale;
 
-        let current = &mut animator.current;
-        let clip_index = current.clip;
-        if let Some(current_clip) = animator
-            .clips
-            .get(clip_index)
-            .map(|clip_handle| clips.get(clip_handle))
-            .flatten()
-        {
-            let bind = &animator.binds[clip_index];
-            let curves_count = current_clip.curves.len();
-
-            // Ensure capacity for cached keyframe index vec
-            if current.keyframe.len() != curves_count {
-                current.keyframe.clear();
-                current
-                    .keyframe
-                    .resize_with(curves_count, || Default::default());
-            }
-
-            // Update time
-            let mut time = current.time + delta_time;
-
-            // Warp mode
-            if current_clip.warp {
-                // Warp Around
-                if time > current_clip.duration {
-                    time = (time / current_clip.duration).fract() * current_clip.duration;
-                    // Reset all keyframes cached indexes
-                    current
-                        .keyframe
-                        .iter_mut()
-                        .for_each(|x| *x = Default::default())
-                }
-            } else {
-                // Hold
-                time = time.min(current_clip.duration);
-            }
-
-            // Advance state time
-            current.time = time;
-
-            let mut entity = None;
-            let mut component = None;
-            let mut pointer = std::ptr::null_mut();
-            let mut location = Location {
-                archetype: u32::MAX,
-                index: usize::MAX,
-            };
-            for i in 0..curves_count {
-                if !bind.valid.get(i).unwrap_or(&false) {
-                    continue;
-                }
-
-                let next_entity = bind.entities[i];
-                if entity != Some(next_entity) {
-                    if let Some(l) = world.get_entity_location(next_entity) {
-                        location = l;
-                        entity = Some(next_entity);
-                        component = None; // Force component update
-                    } else {
-                        // Missing entity
-                        continue;
+        //for layer in &mut animator.layers {
+        if let Some(layer) = animator.layers.first_mut() {
+            let clip_index = layer.clip;
+            if let Some(clip) = animator
+                .clips
+                .get(clip_index as usize)
+                .map(|clip_handle| clips.get(clip_handle))
+                .flatten()
+            {
+                if let Some(bind) = &animator.binds[clip_index as usize] {
+                    let curves_count = clip.curves.len();
+
+                    // Ensure capacity for cached keyframe index vec
+                    if layer.keyframe.len() != curves_count {
+                        layer.keyframe.clear();
+                        layer
+                            .keyframe
+                            .resize_with(curves_count, || Default::default());
                     }
-                }
 
-                let next_component = bind.components[i];
-                if component != Some(next_component) {
-                    if let Some(properties) = type_registry
-                        .component
-                        .read()
-                        .get(&next_component)
-                        .map(|reg| {
-                            reg.get_component_properties(
-                                &world.archetypes[location.archetype as usize],
-                                location.index,
-                            )
-                        })
-                    {
-                        // TODO: Find a better way
-                        pointer = properties.as_ptr() as *mut u8;
-                        component = Some(next_component);
+                    // Update time
+                    let mut time = layer.time + delta_time;
+
+                    // Warp mode
+                    if clip.warp {
+                        // Warp Around
+                        if time > clip.duration {
+                            time = (time / clip.duration).fract() * clip.duration;
+                            // Reset all keyframes cached indexes
+                            layer
+                                .keyframe
+                                .iter_mut()
+                                .for_each(|x| *x = Default::default())
+                        }
                     } else {
-                        // Missing component
-                        continue;
+                        // Hold
+                        time = time.min(clip.duration);
                     }
-                }
 
-                let attr = pointer.wrapping_offset(bind.properties[i]);
-                let keyframe = &mut current.keyframe[i];
+                    // Advance state time
+                    layer.time = time;
 
-                match &current_clip.curves[i] {
-                    CurveUntyped::Float(v) => {
-                        let (k, v) = v.sample(*keyframe, time);
-                        let attr = unsafe { &mut *(attr as *mut f32) };
-                        *attr = v;
-                        *keyframe = k;
-                    }
-                    CurveUntyped::Vec3(v) => {
-                        let (k, v) = v.sample(*keyframe, time);
-                        let attr = unsafe { &mut *(attr as *mut Vec3) };
-                        *attr = v;
-                        *keyframe = k;
-                    }
-                    CurveUntyped::Vec4(v) => {
-                        let (k, v) = v.sample(*keyframe, time);
-                        let attr = unsafe { &mut *(attr as *mut Vec4) };
-                        *attr = v;
-                        *keyframe = k;
-                    }
-                    CurveUntyped::Quat(v) => {
-                        let (k, v) = v.sample(*keyframe, time);
-                        let attr = unsafe { &mut *(attr as *mut Quat) };
-                        *attr = v;
-                        *keyframe = k;
+                    for ((ptr, keyframe), curve) in bind
+                        .attributes
+                        .iter()
+                        .zip(layer.keyframe.iter_mut())
+                        .zip(clip.curves.iter())
+                    {
+                        // Skip invalid properties
+                        if *ptr == Ptr(null_mut()) {
+                            continue;
+                        }
+
+                        match curve {
+                            CurveUntyped::Float(v) => {
+                                let (k, v) = v.sample(*keyframe, time);
+                                let attr = unsafe { &mut *(ptr.0 as *mut f32) };
+                                *attr = v;
+                                *keyframe = k;
+                            }
+                            CurveUntyped::Vec3(v) => {
+                                let (k, v) = v.sample(*keyframe, time);
+                                let attr = unsafe { &mut *(ptr.0 as *mut Vec3) };
+                                *attr = v;
+                                *keyframe = k;
+                            }
+                            CurveUntyped::Vec4(v) => {
+                                let (k, v) = v.sample(*keyframe, time);
+                                let attr = unsafe { &mut *(ptr.0 as *mut Vec4) };
+                                *attr = v;
+                                *keyframe = k;
+                            }
+                            CurveUntyped::Quat(v) => {
+                                let (k, v) = v.sample(*keyframe, time);
+                                let attr = unsafe { &mut *(ptr.0 as *mut Quat) };
+                                *attr = v;
+                                *keyframe = k;
+                            }
+                        }
                     }
                 }
             }
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index c41ed9458bc39..90a3992e16981 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -19,9 +19,6 @@ pub mod prelude {
 
 pub mod stage {
     pub const ANIMATE: &'static str = "animate";
-    // ? NOTE: At this stage the Children component should be in a valid state
-    // sadly this will add a one frame startup delay for each animator
-    pub(crate) const WARM_ANIMATE: &'static str = "warm_animate";
     pub use bevy_app::stage::POST_UPDATE;
     pub use bevy_app::stage::UPDATE;
 }
@@ -32,20 +29,19 @@ pub struct AnimationPlugin;
 impl Plugin for AnimationPlugin {
     fn build(&self, app: &mut AppBuilder) {
         app.add_stage_after(stage::UPDATE, stage::ANIMATE);
-        app.add_stage_after(stage::POST_UPDATE, stage::WARM_ANIMATE);
 
         // Generic animation
         app.add_asset::<Clip>()
             //.add_asset_loader(ClipLoader)
             .register_component::<Animator>()
-            .add_system_to_stage(stage::ANIMATE, animator_update)
-            .add_system_to_stage(stage::WARM_ANIMATE, animator_fetch);
+            .add_system_to_stage(stage::ANIMATE, animator_binding_system)
+            .add_system_to_stage(stage::ANIMATE, animator_update_system);
 
         // Skinning
         app.add_asset::<MeshSkin>()
             .register_component_with::<MeshSkinBinder>(|reg| reg.map_entities())
             .register_component::<MeshSkinnerDebuger>()
             .add_system_to_stage(stage::ANIMATE, mesh_skinner_debugger_update)
-            .add_system_to_stage(stage::WARM_ANIMATE, mesh_skinner_startup);
+            .add_system_to_stage(stage::ANIMATE, mesh_skinner_startup);
     }
 }
diff --git a/crates/bevy_animation/src/skined_mesh.rs b/crates/bevy_animation/src/skined_mesh.rs
index a5377c5fecf7d..a612969fd1610 100644
--- a/crates/bevy_animation/src/skined_mesh.rs
+++ b/crates/bevy_animation/src/skined_mesh.rs
@@ -286,8 +286,6 @@ pub(crate) fn mesh_skinner_debugger_update(
                                 ..Default::default()
                             })
                             .with(Parent(*entity));
-
-                        dbg!(commands.current_entity());
                     }
                 }
 
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index a1a2781a702bc..ac08fcd151ef5 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -262,6 +262,7 @@ async fn load_gltf<'a, 'b>(
         clip.warp = true; // Enable warping by default
 
         let mut start_time = f32::MAX;
+        let mut clip_curves = vec![];
 
         // Each chanel defines how to sample the data and where it will be written
         for channel in animation.channels() {
@@ -293,17 +294,14 @@ async fn load_gltf<'a, 'b>(
             // Start time
             start_time = start_time.min(time_stamps.get(0).copied().unwrap_or(0.0));
 
-            // Figure out clip duration
-            clip.length = clip.length.max(time_stamps.last().copied().unwrap_or(0.0));
-
             match reader.read_outputs().unwrap() {
                 ReadOutputs::Translations(values) => {
                     let values = values.map(|v| Vec3::from(v)).collect::<Vec<_>>();
                     property_path += "@Transform.translation";
-                    clip.add_animated_prop(
+                    clip_curves.push((
                         property_path,
                         CurveUntyped::Vec3(Curve::new(time_stamps, values)),
-                    )
+                    ));
 
                     // TODO: This is a runtime importer so here's no place for further optimizations
                 }
@@ -338,19 +336,19 @@ async fn load_gltf<'a, 'b>(
                     }
 
                     property_path += "@Transform.rotation";
-                    clip.add_animated_prop(
+                    clip_curves.push((
                         property_path,
                         CurveUntyped::Quat(Curve::new(time_stamps, values)),
-                    );
+                    ));
                 }
                 ReadOutputs::Scales(values) => {
                     let values = values.map(|v| Vec3::from(v)).collect::<Vec<_>>();
 
                     property_path += "@Transform.scale";
-                    clip.add_animated_prop(
+                    clip_curves.push((
                         property_path,
                         CurveUntyped::Vec3(Curve::new(time_stamps, values)),
-                    )
+                    ));
                 }
                 ReadOutputs::MorphTargetWeights(_) => {
                     unimplemented!("morph targets aren't current supported")
@@ -359,14 +357,16 @@ async fn load_gltf<'a, 'b>(
         }
 
         // Make sure the start frame is always 0.0
-        for (_, value) in clip.iter_mut() {
-            value.samples_mut().for_each(|x| *x -= start_time);
-        }
-
-        clip.length -= start_time;
+        for (property_path, mut curve) in clip_curves {
+            match &mut curve {
+                CurveUntyped::Float(v) => v.add_offset_time(-start_time),
+                CurveUntyped::Vec3(v) => v.add_offset_time(-start_time),
+                CurveUntyped::Vec4(v) => v.add_offset_time(-start_time),
+                CurveUntyped::Quat(v) => v.add_offset_time(-start_time),
+            }
 
-        // Sort properties by path to optimize clip execution
-        clip.optimize();
+            clip.add_animated_prop(&property_path, curve);
+        }
 
         load_context.set_labeled_asset(&anim_label, LoadedAsset::new(clip));
 

From 2132691dca6e2fded38b3b8482031bcdcb9c388e Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Mon, 23 Nov 2020 10:09:57 -0300
Subject: [PATCH 011/153] fix bad bind meta range + some api changes

---
 crates/bevy_animation/src/generic.rs | 174 ++++++++++++++++++---------
 crates/bevy_animation/src/lib.rs     |   2 +-
 crates/bevy_gltf/src/loader.rs       |   8 +-
 3 files changed, 120 insertions(+), 64 deletions(-)

diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 377045e41b75c..743cd10b6b341 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -93,6 +93,34 @@ impl Clip {
         self.curves.push(curve);
     }
 
+    /// Number of animated properties in this clip
+    pub fn len(&self) -> u16 {
+        self.curves.len() as u16
+    }
+
+    /// Returns the property curve property path.
+    ///
+    /// The clip stores a property path in a specific way to improve search performance
+    /// thus it needs to rebuilt the curve property path in the human readable format
+    pub fn get_property_path(&self, index: u16) -> String {
+        let (entity, name) = &self.attribute[index as usize];
+        let mut path = format!("@{}", name);
+
+        let mut first = true;
+        let mut entity = *entity;
+        while let Some((parent, name)) = self.entities.get(entity as usize) {
+            if first {
+                path = format!("{}{}", name, path);
+                first = false;
+            } else {
+                path = format!("{}/{}", name, path);
+            }
+            entity = *parent;
+        }
+
+        path
+    }
+
     pub fn duration(&self) -> f32 {
         self.duration
     }
@@ -107,32 +135,29 @@ pub enum CurveUntyped {
     //Handle(Curve<HandleUntyped>), // TODO: Requires (de)serialize!
 }
 
-impl CurveUntyped {
-    pub fn duration(&self) -> f32 {
-        match self {
-            CurveUntyped::Float(v) => v.duration(),
-            CurveUntyped::Vec3(v) => v.duration(),
-            CurveUntyped::Vec4(v) => v.duration(),
-            CurveUntyped::Quat(v) => v.duration(),
+macro_rules! untyped_fn {
+    ($v:vis fn $name:ident ( &self, $( $arg:ident : $arg_ty:ty ,)* ) $(-> $ret:ty)* ) => {
+        $v fn $name(&self, $( $arg : $arg_ty ),*) $(-> $ret)* {
+            match self {
+                CurveUntyped::Float(v) => v.$name($($arg,)*),
+                CurveUntyped::Vec3(v) => v.$name($($arg,)*),
+                CurveUntyped::Vec4(v) => v.$name($($arg,)*),
+                CurveUntyped::Quat(v) => v.$name($($arg,)*),
+            }
         }
-    }
+    };
+}
 
-    // pub fn value_type_name(&self) -> &str {
-    //     use std::any::type_name;
-    //     match self {
-    //         CurveUntyped::Float(_) => type_name::<f32>(),
-    //         CurveUntyped::Vec3(_) => type_name::<Vec3>(),
-    //         CurveUntyped::Vec4(_) => type_name::<Vec4>(),
-    //         CurveUntyped::Quat(_) => type_name::<Quat>(),
-    //     }
-    // }
+impl CurveUntyped {
+    untyped_fn!(pub fn duration(&self,) -> f32);
+    untyped_fn!(pub fn value_type(&self,) -> TypeId);
 
-    pub fn value_type(&self) -> TypeId {
+    pub fn add_time_offset(&mut self, time: f32) {
         match self {
-            CurveUntyped::Float(_) => TypeId::of::<f32>(),
-            CurveUntyped::Vec3(_) => TypeId::of::<Vec3>(),
-            CurveUntyped::Vec4(_) => TypeId::of::<Vec4>(),
-            CurveUntyped::Quat(_) => TypeId::of::<Quat>(),
+            CurveUntyped::Float(v) => v.add_offset_time(time),
+            CurveUntyped::Vec3(v) => v.add_offset_time(time),
+            CurveUntyped::Vec4(v) => v.add_offset_time(time),
+            CurveUntyped::Quat(v) => v.add_offset_time(time),
         }
     }
 }
@@ -146,19 +171,28 @@ pub struct Curve<T> {
 
 impl<T> Curve<T>
 where
-    T: LerpValue + Clone,
+    T: LerpValue + Clone + 'static,
 {
+    pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
+        assert!(samples.len() == values.len());
+        Self { samples, values }
+    }
+
     pub fn duration(&self) -> f32 {
         self.samples.last().copied().unwrap_or(0.0)
     }
 
-    pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
-        assert!(samples.len() == values.len());
-        Self { samples, values }
+    /// Easer to use sampling method that don't have time restrictions or needs
+    /// the keyframe index, but is more expensive always `O(n)`. Which means
+    /// sampling takes longer to evaluate as much as time get closer to curve duration
+    /// and it get worse with more keyframes.
+    pub fn sample(&self, time: f32) -> T {
+        self.sample_forward(0, time).1
     }
 
-    /// Samples the curve beginning from the keyframe at index
-    pub fn sample(&self, mut index: usize, time: f32) -> (usize, T) {
+    /// Samples the curve starting from some keyframe index, this make the common case `O(1)`,
+    /// use only when time advancing forwards
+    pub fn sample_forward(&self, mut index: usize, time: f32) -> (usize, T) {
         // Adjust for the current keyframe index
         let last_index = self.samples.len() - 1;
         loop {
@@ -206,6 +240,10 @@ where
     pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
         self.samples.iter().copied().zip(self.values.iter_mut())
     }
+
+    pub fn value_type(&self) -> TypeId {
+        TypeId::of::<T>()
+    }
 }
 
 #[derive(Default, Debug, Clone, Properties)]
@@ -415,18 +453,11 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
                                 );
 
                                 b.curves.push(curve_index as u16);
-                                b.attributes.push(Ptr(find_target_property(path, root_props)
-                                    .and_then(|prop| {
-                                        if prop.any().type_id()
-                                            == clip.curves[curve_index].value_type()
-                                        {
-                                            Some(prop.as_ptr() as *mut _)
-                                        } else {
-                                            // TODO: Log warn wrong type
-                                            None
-                                        }
-                                    })
-                                    .unwrap_or(null_mut())));
+                                b.attributes.push(find_property_ptr(
+                                    path,
+                                    root_props,
+                                    clip.curves[curve_index].value_type(),
+                                ));
 
                                 // Group by component type
                                 commit |= prev_component != component;
@@ -449,7 +480,7 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
 
                         if commit {
                             // Close range
-                            range.1 = b.curves.len() as u16;
+                            range.1 = b.curves.len() as u16 - 1;
 
                             // Commit meta
                             b.metadata.push(BindMeta {
@@ -472,6 +503,7 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
                             prev_component = component;
                             prev_component_short_name = component_short_name;
                             range.0 = range.1;
+                            range.1 += 1;
                         }
                     }
 
@@ -525,9 +557,11 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
                             loc = world.get_entity_location(found_entity);
                         } else {
                             // Entity wasn't found, invalidate all the bind attributes
+                            meta.inner = None; // Clear inner data
                             for i in (meta.range.0)..(meta.range.1) {
                                 bind.attributes[i as usize] = Ptr(null_mut());
                             }
+                            continue;
                         }
                     }
 
@@ -536,7 +570,6 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
                         // Nothing left todo
                         continue;
                     }
-
                     if inner.component == TypeId::of::<MissingComponentMarker>() {
                         // TODO: Find component by name
                         continue;
@@ -555,13 +588,21 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
                             let curve_index = bind.curves[i] as usize;
                             let mut path = clip.attribute[curve_index].1.split('.');
                             path.next(); // Skip component
-                            if let Some(prop) = find_target_property(path, root_props) {
-                                // Found property
-                                bind.attributes[i] = Ptr(prop.as_ptr() as *mut _);
-                            } else {
-                                bind.attributes[i] = Ptr(null_mut());
-                            }
+
+                            let ptr = find_property_ptr(
+                                path,
+                                root_props,
+                                clip.curves[curve_index].value_type(),
+                            );
+                            debug_assert!(bind.attributes[i] != ptr, "pointers can't be the same");
+                            bind.attributes[i] = ptr;
                         }
+                    } else {
+                        // Component is missing
+                        for i in (meta.range.0)..(meta.range.1) {
+                            bind.attributes[i as usize] = Ptr(null_mut());
+                        }
+                        inner.component = TypeId::of::<MissingComponentMarker>();
                     }
 
                     // Update bind location
@@ -611,9 +652,10 @@ fn find_entity(
     }
 }
 
-fn find_target_property<'a, P: Iterator<Item = &'a str>>(
+fn find_property_at_path<'a, P: Iterator<Item = &'a str>>(
     path: P,
     root_props: &dyn Properties,
+    type_id: TypeId,
 ) -> Option<&dyn Property> {
     let mut target = None;
     let mut current = Some(root_props);
@@ -634,7 +676,25 @@ fn find_target_property<'a, P: Iterator<Item = &'a str>>(
             break;
         }
     }
-    target
+
+    target.and_then(|prop| {
+        if prop.any().type_id() == type_id {
+            Some(prop)
+        } else {
+            None
+        }
+    })
+}
+
+#[inline(always)]
+fn find_property_ptr<'a, P: Iterator<Item = &'a str>>(
+    path: P,
+    root_props: &dyn Properties,
+    type_id: TypeId,
+) -> Ptr {
+    Ptr(find_property_at_path(path, root_props, type_id)
+        .map(|prop| prop.as_ptr() as *mut _)
+        .unwrap_or(null_mut()))
 }
 
 #[tracing::instrument(skip(world, resources))]
@@ -694,38 +754,40 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
                     // Advance state time
                     layer.time = time;
 
-                    for ((ptr, keyframe), curve) in bind
+                    for ((ptr, keyframe), curve_index) in bind
                         .attributes
                         .iter()
                         .zip(layer.keyframe.iter_mut())
-                        .zip(clip.curves.iter())
+                        .zip(bind.curves.iter())
                     {
                         // Skip invalid properties
                         if *ptr == Ptr(null_mut()) {
                             continue;
                         }
 
+                        let curve = &clip.curves[*curve_index as usize];
+
                         match curve {
                             CurveUntyped::Float(v) => {
-                                let (k, v) = v.sample(*keyframe, time);
+                                let (k, v) = v.sample_forward(*keyframe, time);
                                 let attr = unsafe { &mut *(ptr.0 as *mut f32) };
                                 *attr = v;
                                 *keyframe = k;
                             }
                             CurveUntyped::Vec3(v) => {
-                                let (k, v) = v.sample(*keyframe, time);
+                                let (k, v) = v.sample_forward(*keyframe, time);
                                 let attr = unsafe { &mut *(ptr.0 as *mut Vec3) };
                                 *attr = v;
                                 *keyframe = k;
                             }
                             CurveUntyped::Vec4(v) => {
-                                let (k, v) = v.sample(*keyframe, time);
+                                let (k, v) = v.sample_forward(*keyframe, time);
                                 let attr = unsafe { &mut *(ptr.0 as *mut Vec4) };
                                 *attr = v;
                                 *keyframe = k;
                             }
                             CurveUntyped::Quat(v) => {
-                                let (k, v) = v.sample(*keyframe, time);
+                                let (k, v) = v.sample_forward(*keyframe, time);
                                 let attr = unsafe { &mut *(ptr.0 as *mut Quat) };
                                 *attr = v;
                                 *keyframe = k;
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 90a3992e16981..e75b1f7a6b70b 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -41,7 +41,7 @@ impl Plugin for AnimationPlugin {
         app.add_asset::<MeshSkin>()
             .register_component_with::<MeshSkinBinder>(|reg| reg.map_entities())
             .register_component::<MeshSkinnerDebuger>()
-            .add_system_to_stage(stage::ANIMATE, mesh_skinner_debugger_update)
+            .add_system_to_stage(stage::POST_UPDATE, mesh_skinner_debugger_update)
             .add_system_to_stage(stage::ANIMATE, mesh_skinner_startup);
     }
 }
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index ac08fcd151ef5..3f511efaf84d3 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -358,13 +358,7 @@ async fn load_gltf<'a, 'b>(
 
         // Make sure the start frame is always 0.0
         for (property_path, mut curve) in clip_curves {
-            match &mut curve {
-                CurveUntyped::Float(v) => v.add_offset_time(-start_time),
-                CurveUntyped::Vec3(v) => v.add_offset_time(-start_time),
-                CurveUntyped::Vec4(v) => v.add_offset_time(-start_time),
-                CurveUntyped::Quat(v) => v.add_offset_time(-start_time),
-            }
-
+            curve.add_time_offset(-start_time);
             clip.add_animated_prop(&property_path, curve);
         }
 

From b16d25adeb86113a11c08d4c66f60746dfa4ddd7 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Mon, 23 Nov 2020 10:25:27 -0300
Subject: [PATCH 012/153] comments and extra assertion to avoid dangle pointers

---
 crates/bevy_animation/src/generic.rs | 22 +++++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 743cd10b6b341..581ad6ca9eea3 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -366,7 +366,7 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
     let clip_events = resources.get::<Events<AssetEvent<Clip>>>().unwrap();
 
     // Builds query
-    // SAFETY: Only query with mutable reference the Animator component
+    // SAFETY: This is the only query with mutable reference the Animator component
     let animator_query = unsafe { world.query_unchecked::<(Entity, &mut Animator), ()>() };
 
     // ? NOTE: Changing a clip on fly is supported, but very expensive so use with caution
@@ -693,7 +693,18 @@ fn find_property_ptr<'a, P: Iterator<Item = &'a str>>(
     type_id: TypeId,
 ) -> Ptr {
     Ptr(find_property_at_path(path, root_props, type_id)
-        .map(|prop| prop.as_ptr() as *mut _)
+        .map(|prop| {
+            let ptr = prop.as_ptr() as *mut _;
+            // Perform an extra assertion to make sure this pointer is inside the component
+            // memory bounds, so no dangle pointers can be created
+            // TODO: cfg extra asserts
+            {
+                let root = root_props.as_ptr();
+                let size = std::mem::size_of_val(root_props.any()) as isize;
+                assert!(unsafe { root.offset_from(ptr).abs() } <= size);
+            }
+            ptr
+        })
         .unwrap_or(null_mut()))
 }
 
@@ -702,7 +713,7 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
     let time = resources.get::<Time>().unwrap();
     let clips = resources.get::<Assets<Clip>>().unwrap();
 
-    // Build queries
+    // SAFETY: This is the only query with mutable reference the Animator component
     let animators_query = unsafe { world.query_unchecked::<(&mut Animator,), ()>() };
     let delta_time = time.delta_seconds;
 
@@ -767,6 +778,11 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
 
                         let curve = &clip.curves[*curve_index as usize];
 
+                        // SAFETY: The `animator_binding_system` is responsible to invalidate and/or update
+                        // any ptr that no longer pointers to the right component for the right entity;
+                        // Also it will only allows to ptr to attributes by value inside the component this means
+                        // no dangle pointers
+
                         match curve {
                             CurveUntyped::Float(v) => {
                                 let (k, v) = v.sample_forward(*keyframe, time);

From e1ff392dc90a795be85bf9000d4b45e0e1701b82 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Mon, 23 Nov 2020 19:40:07 -0300
Subject: [PATCH 013/153] tests + revert mods in bevy_properties + bit more
 apis

---
 crates/bevy_animation/src/generic.rs          |  85 ++++++++++++-
 .../bevy_property_derive/src/lib.rs           |  24 ----
 .../bevy_property/src/dynamic_properties.rs   |   8 --
 .../impl_property/impl_property_smallvec.rs   |   8 --
 .../src/impl_property/impl_property_std.rs    | 120 ------------------
 crates/bevy_property/src/property.rs          |   2 -
 6 files changed, 81 insertions(+), 166 deletions(-)

diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 581ad6ca9eea3..c1c1100e6ab08 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -174,10 +174,32 @@ where
     T: LerpValue + Clone + 'static,
 {
     pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
-        assert!(samples.len() == values.len());
+        // TODO: Result?
+
+        // Make sure both have the same length
+        assert!(
+            samples.len() == values.len(),
+            "samples and values must have the same length"
+        );
+
+        // Make sure the
+        assert!(
+            samples
+                .iter()
+                .zip(samples.iter().skip(1))
+                .all(|(a, b)| a < b),
+            "time samples must be on ascending order"
+        );
         Self { samples, values }
     }
 
+    pub fn from_linear(t0: f32, t1: f32, v0: T, v1: T) -> Self {
+        Self {
+            samples: if t1 >= t0 { vec![t0, t1] } else { vec![t1, t0] },
+            values: vec![v0, v1],
+        }
+    }
+
     pub fn duration(&self) -> f32 {
         self.samples.last().copied().unwrap_or(0.0)
     }
@@ -694,13 +716,14 @@ fn find_property_ptr<'a, P: Iterator<Item = &'a str>>(
 ) -> Ptr {
     Ptr(find_property_at_path(path, root_props, type_id)
         .map(|prop| {
-            let ptr = prop.as_ptr() as *mut _;
+            let ptr = prop.any() as *const _ as *mut u8;
             // Perform an extra assertion to make sure this pointer is inside the component
             // memory bounds, so no dangle pointers can be created
             // TODO: cfg extra asserts
             {
-                let root = root_props.as_ptr();
-                let size = std::mem::size_of_val(root_props.any()) as isize;
+                let root_any = root_props.any();
+                let root = root_any as *const _ as *mut u8;
+                let size = std::mem::size_of_val(root_any) as isize;
                 assert!(unsafe { root.offset_from(ptr).abs() } <= size);
             }
             ptr
@@ -746,6 +769,8 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
                     // Update time
                     let mut time = layer.time + delta_time;
 
+                    // TODO: I notice some jitter during playback
+
                     // Warp mode
                     if clip.warp {
                         // Warp Around
@@ -835,3 +860,55 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
 //         &["anim"]
 //     }
 // }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn curve_evaluation() {
+        let curve = Curve::new(vec![0.0, 0.5, 1.0], vec![0.0, 1.0, 2.0]);
+        assert_eq!(curve.sample(0.5), 1.0);
+        assert_eq!(curve.sample_forward(0, 0.75), (1, 1.5));
+        // TODO: Backwards sampling
+    }
+
+    #[test]
+    #[should_panic]
+    fn curve_bad_length() {
+        let _ = Curve::new(vec![0.0, 0.5, 1.0], vec![0.0, 1.0]);
+    }
+
+    #[test]
+    #[should_panic]
+    fn curve_time_samples_not_sorted() {
+        let _ = Curve::new(vec![0.0, 1.5, 1.0], vec![0.0, 1.0, 2.0]);
+    }
+
+    #[test]
+    fn create_clip() {
+        let mut clip = Clip::default();
+        let curve = Curve::from_linear(0.0, 1.0, 0.0, 1.0);
+        clip.add_animated_prop("Root/Ball@Sphere.radius", CurveUntyped::Float(curve));
+    }
+
+    #[test]
+    #[should_panic]
+    fn clip_add_nested_property() {
+        let mut clip = Clip::default();
+        let position = Curve::from_linear(0.0, 1.0, Vec3::zero(), Vec3::unit_y());
+        let y = Curve::from_linear(0.0, 1.0, 0.0, 1.0);
+        clip.add_animated_prop(
+            "Root/Ball@Transform.translation",
+            CurveUntyped::Vec3(position),
+        );
+        // NOTE: Right now "Transform.translation.y" can't be accessed because Vec3 doesn't impl Properties
+        clip.add_animated_prop("Root/Ball@Transform.translation.y", CurveUntyped::Float(y));
+    }
+
+    #[test]
+    #[should_panic]
+    fn clip_get_property_path() {}
+
+    // TODO: Add tests
+}
diff --git a/crates/bevy_property/bevy_property_derive/src/lib.rs b/crates/bevy_property/bevy_property_derive/src/lib.rs
index 75a29c0f85581..6b16fda9048ea 100644
--- a/crates/bevy_property/bevy_property_derive/src/lib.rs
+++ b/crates/bevy_property/bevy_property_derive/src/lib.rs
@@ -223,14 +223,6 @@ pub fn derive_properties(input: TokenStream) -> TokenStream {
             fn property_type(&self) -> #bevy_property_path::PropertyType {
                 #bevy_property_path::PropertyType::Map
             }
-
-            fn as_ptr(&self) -> *const u8 {
-                self as *const _ as *const u8
-            }
-
-            fn as_mut_ptr(&mut self) -> *mut u8 {
-                self as *mut _ as *mut u8
-            }
         }
     })
 }
@@ -291,14 +283,6 @@ pub fn derive_property(input: TokenStream) -> TokenStream {
             fn property_type(&self) -> #bevy_property_path::PropertyType {
                 #bevy_property_path::PropertyType::Value
             }
-
-            fn as_ptr(&self) -> *const u8 {
-                self as *const _ as *const u8
-            }
-
-            fn as_mut_ptr(&mut self) -> *mut u8 {
-                self as *mut _ as *mut u8
-            }
         }
 
         impl #impl_generics #bevy_property_path::DeserializeProperty for #struct_name#ty_generics  {
@@ -433,14 +417,6 @@ pub fn impl_property(input: TokenStream) -> TokenStream {
             fn property_type(&self) -> #bevy_property_path::PropertyType {
                 #bevy_property_path::PropertyType::Value
             }
-
-            fn as_ptr(&self) -> *const u8 {
-                self as *const _ as *const u8
-            }
-
-            fn as_mut_ptr(&mut self) -> *mut u8 {
-                self as *mut _ as *mut u8
-            }
         }
 
         impl #impl_generics #bevy_property_path::DeserializeProperty for #ty#ty_generics #where_clause  {
diff --git a/crates/bevy_property/src/dynamic_properties.rs b/crates/bevy_property/src/dynamic_properties.rs
index 1967ffcd72845..6312c8ebdbac6 100644
--- a/crates/bevy_property/src/dynamic_properties.rs
+++ b/crates/bevy_property/src/dynamic_properties.rs
@@ -207,14 +207,6 @@ impl Property for DynamicProperties {
     fn property_type(&self) -> PropertyType {
         self.property_type
     }
-
-    fn as_ptr(&self) -> *const u8 {
-        panic!("as_ptr isn't supported for DynamicProperties")
-    }
-
-    fn as_mut_ptr(&mut self) -> *mut u8 {
-        panic!("as_mut_ptr isn't supported for DynamicProperties")
-    }
 }
 
 impl DeserializeProperty for DynamicProperties {
diff --git a/crates/bevy_property/src/impl_property/impl_property_smallvec.rs b/crates/bevy_property/src/impl_property/impl_property_smallvec.rs
index 7c6aa6c6c7804..caf78a6aa792a 100644
--- a/crates/bevy_property/src/impl_property/impl_property_smallvec.rs
+++ b/crates/bevy_property/src/impl_property/impl_property_smallvec.rs
@@ -47,12 +47,4 @@ where
     fn property_type(&self) -> PropertyType {
         PropertyType::Value
     }
-
-    fn as_ptr(&self) -> *const u8 {
-        self as *const _ as *const u8
-    }
-
-    fn as_mut_ptr(&mut self) -> *mut u8 {
-        self as *mut _ as *mut u8
-    }
 }
diff --git a/crates/bevy_property/src/impl_property/impl_property_std.rs b/crates/bevy_property/src/impl_property/impl_property_std.rs
index 786c63e466065..819fdd4c049cf 100644
--- a/crates/bevy_property/src/impl_property/impl_property_std.rs
+++ b/crates/bevy_property/src/impl_property/impl_property_std.rs
@@ -101,14 +101,6 @@ where
     fn property_type(&self) -> PropertyType {
         PropertyType::Seq
     }
-
-    fn as_ptr(&self) -> *const u8 {
-        self as *const _ as *const u8
-    }
-
-    fn as_mut_ptr(&mut self) -> *mut u8 {
-        self as *mut _ as *mut u8
-    }
 }
 
 // impl_property!(SEQUENCE, VecDeque<T> where T: Clone + Send + Sync + Serialize + 'static);
@@ -162,14 +154,6 @@ impl Property for String {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
-
-    fn as_ptr(&self) -> *const u8 {
-        self as *const _ as *const u8
-    }
-
-    fn as_mut_ptr(&mut self) -> *mut u8 {
-        self as *mut _ as *mut u8
-    }
 }
 
 impl Property for bool {
@@ -210,14 +194,6 @@ impl Property for bool {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
-
-    fn as_ptr(&self) -> *const u8 {
-        self as *const _ as *const u8
-    }
-
-    fn as_mut_ptr(&mut self) -> *mut u8 {
-        self as *mut _ as *mut u8
-    }
 }
 
 impl Property for usize {
@@ -276,14 +252,6 @@ impl Property for usize {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
-
-    fn as_ptr(&self) -> *const u8 {
-        self as *const _ as *const u8
-    }
-
-    fn as_mut_ptr(&mut self) -> *mut u8 {
-        self as *mut _ as *mut u8
-    }
 }
 
 impl Property for u64 {
@@ -342,14 +310,6 @@ impl Property for u64 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
-
-    fn as_ptr(&self) -> *const u8 {
-        self as *const _ as *const u8
-    }
-
-    fn as_mut_ptr(&mut self) -> *mut u8 {
-        self as *mut _ as *mut u8
-    }
 }
 
 impl Property for u32 {
@@ -408,14 +368,6 @@ impl Property for u32 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
-
-    fn as_ptr(&self) -> *const u8 {
-        self as *const _ as *const u8
-    }
-
-    fn as_mut_ptr(&mut self) -> *mut u8 {
-        self as *mut _ as *mut u8
-    }
 }
 
 impl Property for u16 {
@@ -474,14 +426,6 @@ impl Property for u16 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
-
-    fn as_ptr(&self) -> *const u8 {
-        self as *const _ as *const u8
-    }
-
-    fn as_mut_ptr(&mut self) -> *mut u8 {
-        self as *mut _ as *mut u8
-    }
 }
 
 impl Property for u8 {
@@ -540,14 +484,6 @@ impl Property for u8 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
-
-    fn as_ptr(&self) -> *const u8 {
-        self as *const _ as *const u8
-    }
-
-    fn as_mut_ptr(&mut self) -> *mut u8 {
-        self as *mut _ as *mut u8
-    }
 }
 
 impl Property for isize {
@@ -606,14 +542,6 @@ impl Property for isize {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
-
-    fn as_ptr(&self) -> *const u8 {
-        self as *const _ as *const u8
-    }
-
-    fn as_mut_ptr(&mut self) -> *mut u8 {
-        self as *mut _ as *mut u8
-    }
 }
 
 impl Property for i64 {
@@ -672,14 +600,6 @@ impl Property for i64 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
-
-    fn as_ptr(&self) -> *const u8 {
-        self as *const _ as *const u8
-    }
-
-    fn as_mut_ptr(&mut self) -> *mut u8 {
-        self as *mut _ as *mut u8
-    }
 }
 
 impl Property for i32 {
@@ -738,14 +658,6 @@ impl Property for i32 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
-
-    fn as_ptr(&self) -> *const u8 {
-        self as *const _ as *const u8
-    }
-
-    fn as_mut_ptr(&mut self) -> *mut u8 {
-        self as *mut _ as *mut u8
-    }
 }
 
 impl Property for i16 {
@@ -804,14 +716,6 @@ impl Property for i16 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
-
-    fn as_ptr(&self) -> *const u8 {
-        self as *const _ as *const u8
-    }
-
-    fn as_mut_ptr(&mut self) -> *mut u8 {
-        self as *mut _ as *mut u8
-    }
 }
 
 impl Property for i8 {
@@ -870,14 +774,6 @@ impl Property for i8 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
-
-    fn as_ptr(&self) -> *const u8 {
-        self as *const _ as *const u8
-    }
-
-    fn as_mut_ptr(&mut self) -> *mut u8 {
-        self as *mut _ as *mut u8
-    }
 }
 
 impl Property for f32 {
@@ -920,14 +816,6 @@ impl Property for f32 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
-
-    fn as_ptr(&self) -> *const u8 {
-        self as *const _ as *const u8
-    }
-
-    fn as_mut_ptr(&mut self) -> *mut u8 {
-        self as *mut _ as *mut u8
-    }
 }
 
 impl Property for f64 {
@@ -970,12 +858,4 @@ impl Property for f64 {
     fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
         Serializable::Borrowed(self)
     }
-
-    fn as_ptr(&self) -> *const u8 {
-        self as *const _ as *const u8
-    }
-
-    fn as_mut_ptr(&mut self) -> *mut u8 {
-        self as *mut _ as *mut u8
-    }
 }
diff --git a/crates/bevy_property/src/property.rs b/crates/bevy_property/src/property.rs
index 73ec4c77040e1..6385531f751de 100644
--- a/crates/bevy_property/src/property.rs
+++ b/crates/bevy_property/src/property.rs
@@ -24,8 +24,6 @@ pub trait Property: Send + Sync + Any + 'static {
         None
     }
     fn serializable<'a>(&'a self, registry: &'a PropertyTypeRegistry) -> Serializable<'a>;
-    fn as_ptr(&self) -> *const u8;
-    fn as_mut_ptr(&mut self) -> *mut u8;
 }
 
 pub trait DeserializeProperty {

From 8b23ab74c3190bec7ca8d7e56b0694051df6da43 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Mon, 23 Nov 2020 23:17:42 -0300
Subject: [PATCH 014/153] more tests + api changed + extra asserts

---
 crates/bevy_animation/Cargo.toml     |   1 +
 crates/bevy_animation/src/generic.rs | 187 ++++++++++++++++++++++-----
 2 files changed, 155 insertions(+), 33 deletions(-)

diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index 2d041e4458f26..e35c77762edf5 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -24,4 +24,5 @@ bevy_property = { path = "../bevy_property", version = "0.3.0" }
 serde = { version = "1.0", features = ["derive"] }
 smallvec = { version = "1.4", features = ["serde"] }
 anyhow = "1.0"
+float-cmp = "0.8.0"
 tracing = { version = "0.1.21", features = ["attributes"] }
\ No newline at end of file
diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index c1c1100e6ab08..83cb956ead381 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -9,20 +9,27 @@ use bevy_property::{Properties, Property, PropertyType};
 use bevy_transform::prelude::*;
 use bevy_type_registry::{TypeRegistry, TypeUuid};
 use bevy_utils::HashSet;
-use serde::{Deserialize, Serialize};
+//use serde::{Deserialize, Serialize};
 use std::any::TypeId;
+use std::collections::hash_map::DefaultHasher;
 use std::convert::TryFrom;
+use std::hash::{Hash, Hasher};
 use std::ptr::null_mut;
 
 use super::lerping::LerpValue;
 
-// TODO: Curve/Curve need a validation during deserialization because they are
+// TODO: Curve/Clip need a validation during deserialization because they are
 // structured as SOA (struct of arrays), so the vec's length must match
 
-#[derive(Debug, Serialize, Deserialize, TypeUuid)]
+/// Used to make fast string comparisons, don't serialize
+#[derive(Debug, PartialEq, Eq)]
+struct HashCode(u64);
+
+// TODO: impl Serialize, Deserialize
+#[derive(Debug, TypeUuid)]
 #[uuid = "4c76e6c3-706d-4a74-af8e-4f48033e0733"]
 pub struct Clip {
-    #[serde(default = "clip_default_warp")]
+    //#[serde(default = "clip_default_warp")]
     pub warp: bool,
     duration: f32,
     /// Entity identification parent index on this same vec and name
@@ -30,13 +37,13 @@ pub struct Clip {
     /// Attribute is made by the entity index and a string that combines
     /// component name followed by their attributes spaced by a period,
     /// like so: `"Transform.translation.x"`
-    attribute: Vec<(u16, String)>,
+    attribute: Vec<(u16, String, HashCode)>,
     curves: Vec<CurveUntyped>,
 }
 
-fn clip_default_warp() -> bool {
-    true
-}
+// fn clip_default_warp() -> bool {
+//     true
+// }
 
 impl Default for Clip {
     fn default() -> Self {
@@ -55,7 +62,7 @@ impl Clip {
     /// Property to be animated must be in the following format `"path/to/named_entity@Transform.translation.x"`
     /// where the left side `@` defines a path to the entity to animate,
     /// while the right side the path to a property to animate starting from the component.
-    pub fn add_animated_prop(&mut self, property_path: &str, curve: CurveUntyped) {
+    pub fn add_animated_prop(&mut self, property_path: &str, mut curve: CurveUntyped) {
         // Clip an only have some amount of curves and entities
         // this limitation was added to save memory (but you can increase it if you want)
         assert!(
@@ -66,8 +73,14 @@ impl Clip {
         let path =
             property_path.split_at(property_path.rfind('@').expect("property path missing @"));
 
+        let mut entity_created = false;
         let mut entity = 0; // Start search from root
         for name in path.0.split('/') {
+            // Ignore the first '/' or '///'
+            if name.is_empty() {
+                continue;
+            }
+
             if let Some(e) = self
                 .entities
                 .iter()
@@ -79,17 +92,49 @@ impl Clip {
                 // Add entity
                 let e = self.entities.len();
                 self.entities.push((entity, name.to_string()));
+                entity_created = true;
                 // Soft limit added to save memory, identical to the curve limit
                 entity = u16::try_from(e).expect("entities limit reached");
             }
         }
 
-        // TODO: also replace the curve
-        // TODO: we can only have (u16 - 1) max
-        // TODO: "...@Transform.translation" and "...@Transform.translation.x" can't live with each other
+        let property = path.1.split_at(1).1;
+
+        // Faster comparison
+        let mut hasher = DefaultHasher::default();
+        property.hash(&mut hasher);
+        let hash = HashCode(hasher.finish());
+
+        // If some entity was created it means this property is a new one
+        if !entity_created {
+            for (i, attr) in self.attribute.iter().enumerate() {
+                if attr.0 != entity {
+                    continue;
+                }
+
+                // NOTE: "...@Transform.translation" and "...@Transform.translation.x" can't live with each other
+                // but since Properties aren't implemented for f32, Vec2, Vec3, Vec4 and Quat
+                // (all relevant animated type values) the check rule could be simplified (a lot)
+                //
+                // The test case `test::unhandled_properties_implementation_for_types` will ensure that
+
+                if hash == attr.2 && property == attr.1 {
+                    // Found a property are equal the one been inserted
+                    // Replace curve, the property was already added, this is very important
+                    // because it guarantees that each property will have unique access to some
+                    // attribute during the update stages
+
+                    let inserted_duration = curve.duration();
+                    std::mem::swap(&mut self.curves[i], &mut curve);
+                    self.update_duration(curve.duration(), inserted_duration);
+
+                    return;
+                }
+            }
+        }
+
         self.duration = self.duration.max(curve.duration());
-        self.attribute
-            .push((entity, path.1.split_at(1).1.to_string()));
+        self.attribute.push((entity, property.to_owned(), hash));
         self.curves.push(curve);
     }
 
@@ -103,7 +148,7 @@ impl Clip {
     /// The clip stores a property path in a specific way to improve search performance
     /// thus it needs to rebuilt the curve property path in the human readable format
     pub fn get_property_path(&self, index: u16) -> String {
-        let (entity, name) = &self.attribute[index as usize];
+        let (entity, name, _) = &self.attribute[index as usize];
         let mut path = format!("@{}", name);
 
         let mut first = true;
@@ -124,9 +169,27 @@ impl Clip {
     pub fn duration(&self) -> f32 {
         self.duration
     }
+
+    fn update_duration(&mut self, removed_duration: f32, inserted_duration: f32) {
+        if removed_duration == inserted_duration { // Precise match
+             // Nothing left todo
+        } else if float_cmp::approx_eq!(f32, removed_duration, self.duration, ulps = 2) {
+            // TODO: Review this approximated comparison
+
+            // Heavy path, the clip duration needs
+            self.duration = self
+                .curves
+                .iter()
+                .map(|c| c.duration())
+                .fold(0.0, |acc, x| acc.max(x));
+        } else {
+            self.duration = self.duration.max(inserted_duration);
+        }
+    }
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+// TODO: impl Serialize, Deserialize
+#[derive(Debug)]
 pub enum CurveUntyped {
     Float(Curve<f32>),
     Vec3(Curve<Vec3>),
@@ -162,7 +225,8 @@ impl CurveUntyped {
     }
 }
 
-#[derive(Default, Debug, Serialize, Deserialize)]
+// TODO: impl Serialize, Deserialize
+#[derive(Default, Debug)]
 pub struct Curve<T> {
     // TODO: Linear and Spline variants
     samples: Vec<f32>,
@@ -273,6 +337,7 @@ pub struct Layer {
     pub weight: f32,
     pub clip: u16,
     pub time: f32,
+    //pub time_scale: f32, // TODO: Add time_scale
     keyframe: Vec<usize>,
 }
 
@@ -302,6 +367,7 @@ impl Animator {
         if let Some(i) = self.clips.iter().position(|c| *c == clip) {
             i as u16
         } else {
+            // TODO: assert too many clips ...
             let i = self.clips.len();
             self.clips.push(clip);
             i as u16
@@ -319,11 +385,13 @@ impl Animator {
         layer_index
     }
 
-    pub fn clips_len(&self) -> usize {
-        self.clips.len()
+    pub fn clips_len(&self) -> u16 {
+        self.clips.len() as u16
     }
 }
 
+// TODO: Bind asset properties (edge case), offset
+
 #[derive(Debug)]
 struct Binds {
     metadata: Vec<BindMeta>,
@@ -363,6 +431,7 @@ struct ClipResourceProviderState {
     clip_event_reader: EventReader<AssetEvent<Clip>>,
 }
 
+// TODO: Refactor in hope to reuse more code (maybe just create more functions)
 #[tracing::instrument(skip(world, resources))]
 pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resources) {
     let system_id = SystemId(0); // ? NOTE: shouldn't be required to match the system id
@@ -438,7 +507,7 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
                     let mut prev_component = TypeId::of::<MissingComponentMarker>();
                     let mut prev_component_short_name = "";
 
-                    for (curve_index, (entity_index, attr_path)) in
+                    for (curve_index, (entity_index, attr_path, _)) in
                         clip.attribute.iter().enumerate()
                     {
                         let mut commit = false;
@@ -790,6 +859,8 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
                     // Advance state time
                     layer.time = time;
 
+                    // TODO: handle backwards time
+
                     for ((ptr, keyframe), curve_index) in bind
                         .attributes
                         .iter()
@@ -834,6 +905,8 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
                                 *keyframe = k;
                             }
                         }
+
+                        // TODO: Make sure to update the components states to 'Changed'
                     }
                 }
             }
@@ -869,7 +942,7 @@ mod tests {
     fn curve_evaluation() {
         let curve = Curve::new(vec![0.0, 0.5, 1.0], vec![0.0, 1.0, 2.0]);
         assert_eq!(curve.sample(0.5), 1.0);
-        assert_eq!(curve.sample_forward(0, 0.75), (1, 1.5));
+        assert_eq!(curve.sample_forward(0, 0.75), (2, 1.5));
         // TODO: Backwards sampling
     }
 
@@ -889,26 +962,74 @@ mod tests {
     fn create_clip() {
         let mut clip = Clip::default();
         let curve = Curve::from_linear(0.0, 1.0, 0.0, 1.0);
-        clip.add_animated_prop("Root/Ball@Sphere.radius", CurveUntyped::Float(curve));
+        let prop = "/Root/Ball@Sphere.radius";
+        clip.add_animated_prop(prop, CurveUntyped::Float(curve));
+        assert_eq!(clip.get_property_path(0), prop);
     }
 
     #[test]
-    #[should_panic]
-    fn clip_add_nested_property() {
+    fn clip_replace_property() {
+        // NOTE: This test is very important because it guarantees that each property have unique
+        // access to some attribute during the update stages
         let mut clip = Clip::default();
-        let position = Curve::from_linear(0.0, 1.0, Vec3::zero(), Vec3::unit_y());
-        let y = Curve::from_linear(0.0, 1.0, 0.0, 1.0);
+        let prop = "/Root/Ball@Sphere.radius";
+        clip.add_animated_prop(
+            prop,
+            CurveUntyped::Float(Curve::from_linear(0.0, 1.0, 0.0, 1.0)),
+        );
         clip.add_animated_prop(
-            "Root/Ball@Transform.translation",
-            CurveUntyped::Vec3(position),
+            prop,
+            CurveUntyped::Float(Curve::from_linear(0.0, 1.2, 0.1, 2.0)),
         );
-        // NOTE: Right now "Transform.translation.y" can't be accessed because Vec3 doesn't impl Properties
-        clip.add_animated_prop("Root/Ball@Transform.translation.y", CurveUntyped::Float(y));
+        assert_eq!(clip.len(), 1);
+        assert_eq!(clip.duration(), 1.2);
     }
 
     #[test]
-    #[should_panic]
-    fn clip_get_property_path() {}
+    fn unhandled_properties_implementation_for_types() {
+        // This is take as granted to simplify the function `Clip::add_animated_prop`
+        // you can give a look into it to see more about their implications
+
+        macro_rules! check_for_properties {
+            ($t:ty) => {{
+                let v = <$t>::default();
+                let p: &dyn Property = &v;
+                assert!(
+                    p.as_properties().is_none(),
+                    "unhandled impl `Properties` for {}",
+                    stringify!($t)
+                );
+            }};
+        }
+
+        check_for_properties!(f32);
+        check_for_properties!(Vec2);
+        check_for_properties!(Vec3);
+        //check_for_properties!(Vec4); // TODO: Vec4 should implement at least Property
+        check_for_properties!(Quat);
+    }
+
+    // ? NOTE: Don't remove this test, right now we can skip this test
+    // ? because all the animated type values (Vec2, Vec3 ...) don't
+    // ? implement the `Properties` type and thus none of their inner
+    // ? can be accessed
+    // #[test]
+    // #[should_panic]
+    // fn clip_add_nested_property() {
+    //     let mut clip = Clip::default();
+    //     let position = Curve::from_linear(0.0, 1.0, Vec3::zero(), Vec3::unit_y());
+    //     let y = Curve::from_linear(0.0, 1.0, 0.0, 1.0);
+    //     clip.add_animated_prop(
+    //         "Root/Ball@Transform.translation",
+    //         CurveUntyped::Vec3(position),
+    //     );
+    //     // NOTE: Right now "Transform.translation.y" can't be accessed because Vec3 doesn't impl Properties
+    //     clip.add_animated_prop("Root/Ball@Transform.translation.y", CurveUntyped::Float(y));
+    // }
 
-    // TODO: Add tests
+    // TODO: Add tests for hierarch change (creation and deletion)
+    // TODO: Add tests for entity archetype change
+    // TODO: Add tests for entities with same Name
+    // TODO: Add tests for animated handle (impl missing)
+    // TODO: Add tests for animated asset properties (impl missing)
 }

From 6694ed72879e533d3a19a065fef44af5b29def59 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Tue, 24 Nov 2020 02:40:42 -0300
Subject: [PATCH 015/153] reverse time sampling + comments

---
 crates/bevy_animation/src/generic.rs     | 122 ++++++++++++++++-------
 crates/bevy_animation/src/skined_mesh.rs |   1 +
 2 files changed, 89 insertions(+), 34 deletions(-)

diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 83cb956ead381..eb421ec0e8e49 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -50,7 +50,7 @@ impl Default for Clip {
         Self {
             warp: true,
             duration: 0.0,
-            // NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
+            // ? NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
             entities: vec![(u16::MAX, String::default())],
             attribute: vec![],
             curves: vec![],
@@ -139,6 +139,7 @@ impl Clip {
     }
 
     /// Number of animated properties in this clip
+    #[inline(always)]
     pub fn len(&self) -> u16 {
         self.curves.len() as u16
     }
@@ -166,23 +167,32 @@ impl Clip {
         path
     }
 
+    /// Clip duration
+    #[inline(always)]
     pub fn duration(&self) -> f32 {
         self.duration
     }
 
+    /// Updates the clip duration based of the inserted and removed curve durations
+    /// *WARNING* The curve must be already replaced before call this function
     fn update_duration(&mut self, removed_duration: f32, inserted_duration: f32) {
-        if removed_duration == inserted_duration { // Precise match
-             // Nothing left todo
+        if removed_duration == inserted_duration {
+            // If precisely matches the inserted curve duration we don't need to update anything
         } else if float_cmp::approx_eq!(f32, removed_duration, self.duration, ulps = 2) {
-            // TODO: Review this approximated comparison
+            // At this point the duration for the removed curve is the same as self.duration
+            // this mean that we have to compute the clip duration from scratch;
+            //
+            // NOTE: I opted for am approximated float comparison because it's better
+            // to do all the this work than get a hard to debug glitch
+            // TODO: Review approximated comparison
 
-            // Heavy path, the clip duration needs
             self.duration = self
                 .curves
                 .iter()
                 .map(|c| c.duration())
                 .fold(0.0, |acc, x| acc.max(x));
         } else {
+            // Faster clip duration update
             self.duration = self.duration.max(inserted_duration);
         }
     }
@@ -196,6 +206,7 @@ pub enum CurveUntyped {
     Vec4(Curve<Vec4>),
     Quat(Curve<Quat>),
     //Handle(Curve<HandleUntyped>), // TODO: Requires (de)serialize!
+    // TODO: Color(Curve<Color>),
 }
 
 macro_rules! untyped_fn {
@@ -246,6 +257,8 @@ where
             "samples and values must have the same length"
         );
 
+        assert!(samples.len() > 0, "empty curve");
+
         // Make sure the
         assert!(
             samples
@@ -273,38 +286,57 @@ where
     /// sampling takes longer to evaluate as much as time get closer to curve duration
     /// and it get worse with more keyframes.
     pub fn sample(&self, time: f32) -> T {
-        self.sample_forward(0, time).1
+        // Index guessing gives a small search optimization
+        let index = if time < self.duration() * 0.5 {
+            0
+        } else {
+            self.samples.len() - 1
+        };
+
+        self.sample_indexed(index, time).1
     }
 
     /// Samples the curve starting from some keyframe index, this make the common case `O(1)`,
     /// use only when time advancing forwards
-    pub fn sample_forward(&self, mut index: usize, time: f32) -> (usize, T) {
+    pub fn sample_indexed(&self, mut index: usize, time: f32) -> (usize, T) {
         // Adjust for the current keyframe index
         let last_index = self.samples.len() - 1;
-        loop {
-            if index > last_index {
-                return (last_index, self.values.last().unwrap().clone());
-            }
 
-            if self.samples[index] < time {
+        index = index.max(0).min(last_index);
+        if self.samples[index] < time {
+            // Forward search
+            loop {
+                if index == last_index {
+                    return (last_index, self.values.last().unwrap().clone());
+                }
                 index += 1;
-            } else {
-                break;
+
+                if self.samples[index] >= time {
+                    break;
+                }
+            }
+        } else {
+            // Backward search
+            loop {
+                if index == 0 {
+                    return (0, self.values.last().unwrap().clone());
+                }
+
+                let i = index - 1;
+                if self.samples[i] <= time {
+                    break;
+                }
+
+                index = i;
             }
         }
 
-        let value = if index == 0 {
-            self.values[0].clone()
-        } else {
-            // Lerp the value
-            let i = index - 1;
-            let previous_time = self.samples[i];
-            let t = (time - previous_time) / (self.samples[index] - previous_time);
-            //println!("{} => ({}, {}) => {}", time, i, index, t);
-            //let t = t.max(0.0).min(1.0);
-            debug_assert!(t >= 0.0 && t <= 1.0); // Checks if it's required to normalize t
-            T::lerp(&self.values[i], &self.values[index], t)
-        };
+        // Lerp the value
+        let i = index - 1;
+        let previous_time = self.samples[i];
+        let t = (time - previous_time) / (self.samples[index] - previous_time);
+        debug_assert!(t >= 0.0 && t <= 1.0, "t = {} but should be normalized", t); // Checks if it's required to normalize t
+        let value = T::lerp(&self.values[i], &self.values[index], t);
 
         (index, value)
     }
@@ -317,6 +349,7 @@ where
     // }
 
     // pub fn remove(&mut self, index: usize) {
+    //assert!(samples.len() > 1, "curve can't be empty");
     // }
 
     pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
@@ -390,7 +423,9 @@ impl Animator {
     }
 }
 
-// TODO: Bind asset properties (edge case), offset
+// TODO: Bind asset properties (edge case), notice that this feature will be in hold
+// until the atelier assets get through. I will probably just store pointers offsets
+// because it's safe with less conditions and not that expensive
 
 #[derive(Debug)]
 struct Binds {
@@ -815,6 +850,8 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
         // Time scales by component
         let delta_time = delta_time * animator.time_scale;
 
+        // TODO: Add layer mask or a trimmed clip with reused curves and stuff
+        // TODO: Add layer blending
         //for layer in &mut animator.layers {
         if let Some(layer) = animator.layers.first_mut() {
             let clip_index = layer.clip;
@@ -881,25 +918,25 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
 
                         match curve {
                             CurveUntyped::Float(v) => {
-                                let (k, v) = v.sample_forward(*keyframe, time);
+                                let (k, v) = v.sample_indexed(*keyframe, time);
                                 let attr = unsafe { &mut *(ptr.0 as *mut f32) };
                                 *attr = v;
                                 *keyframe = k;
                             }
                             CurveUntyped::Vec3(v) => {
-                                let (k, v) = v.sample_forward(*keyframe, time);
+                                let (k, v) = v.sample_indexed(*keyframe, time);
                                 let attr = unsafe { &mut *(ptr.0 as *mut Vec3) };
                                 *attr = v;
                                 *keyframe = k;
                             }
                             CurveUntyped::Vec4(v) => {
-                                let (k, v) = v.sample_forward(*keyframe, time);
+                                let (k, v) = v.sample_indexed(*keyframe, time);
                                 let attr = unsafe { &mut *(ptr.0 as *mut Vec4) };
                                 *attr = v;
                                 *keyframe = k;
                             }
                             CurveUntyped::Quat(v) => {
-                                let (k, v) = v.sample_forward(*keyframe, time);
+                                let (k, v) = v.sample_indexed(*keyframe, time);
                                 let attr = unsafe { &mut *(ptr.0 as *mut Quat) };
                                 *attr = v;
                                 *keyframe = k;
@@ -940,10 +977,26 @@ mod tests {
 
     #[test]
     fn curve_evaluation() {
-        let curve = Curve::new(vec![0.0, 0.5, 1.0], vec![0.0, 1.0, 2.0]);
+        let curve = Curve::new(
+            vec![0.0, 0.25, 0.5, 0.75, 1.0],
+            vec![0.0, 0.5, 1.0, 1.5, 2.0],
+        );
         assert_eq!(curve.sample(0.5), 1.0);
-        assert_eq!(curve.sample_forward(0, 0.75), (2, 1.5));
-        // TODO: Backwards sampling
+
+        let mut i0 = 0;
+        let mut e0 = 0.0;
+        for v in &[0.1, 0.3, 0.7, 0.4, 0.2, 0.0, 0.4, 0.85, 1.0] {
+            let v = *v;
+            let (i1, e1) = curve.sample_indexed(i0, v);
+            assert_eq!(e1, 2.0 * v);
+            if e1 > e0 {
+                assert!(i1 >= i0);
+            } else {
+                assert!(i1 <= i0);
+            }
+            e0 = e1;
+            i0 = i1;
+        }
     }
 
     #[test]
@@ -1007,6 +1060,7 @@ mod tests {
         check_for_properties!(Vec3);
         //check_for_properties!(Vec4); // TODO: Vec4 should implement at least Property
         check_for_properties!(Quat);
+        //check_for_properties!(Color); // TODO: sRGB Color
     }
 
     // ? NOTE: Don't remove this test, right now we can skip this test
diff --git a/crates/bevy_animation/src/skined_mesh.rs b/crates/bevy_animation/src/skined_mesh.rs
index a612969fd1610..479cb3c7aca48 100644
--- a/crates/bevy_animation/src/skined_mesh.rs
+++ b/crates/bevy_animation/src/skined_mesh.rs
@@ -299,6 +299,7 @@ pub(crate) fn mesh_skinner_debugger_update(
                 debugger.entity = commands
                     .spawn(PbrBundle {
                         mesh: mesh_handle.clone(),
+                        // TODO: Ignore depth test and draw skeleton on top of everything
                         ..Default::default()
                     })
                     .current_entity()

From 682e7205e41dcb1066cd10eb66c582c650725fba Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Tue, 24 Nov 2020 09:21:20 -0300
Subject: [PATCH 016/153] name component with hash (faster eq) + refactor

---
 crates/bevy_animation/src/generic.rs     | 169 +++++++++++++----------
 crates/bevy_animation/src/skined_mesh.rs |   3 +-
 crates/bevy_core/src/name.rs             |  74 ++++++++--
 crates/bevy_gltf/src/loader.rs           |   4 +-
 4 files changed, 162 insertions(+), 88 deletions(-)

diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index eb421ec0e8e49..3e2c8fa59bc7c 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -11,9 +11,7 @@ use bevy_type_registry::{TypeRegistry, TypeUuid};
 use bevy_utils::HashSet;
 //use serde::{Deserialize, Serialize};
 use std::any::TypeId;
-use std::collections::hash_map::DefaultHasher;
 use std::convert::TryFrom;
-use std::hash::{Hash, Hasher};
 use std::ptr::null_mut;
 
 use super::lerping::LerpValue;
@@ -21,23 +19,19 @@ use super::lerping::LerpValue;
 // TODO: Curve/Clip need a validation during deserialization because they are
 // structured as SOA (struct of arrays), so the vec's length must match
 
-/// Used to make fast string comparisons, don't serialize
-#[derive(Debug, PartialEq, Eq)]
-struct HashCode(u64);
-
 // TODO: impl Serialize, Deserialize
-#[derive(Debug, TypeUuid)]
+#[derive(Debug, Clone, TypeUuid)]
 #[uuid = "4c76e6c3-706d-4a74-af8e-4f48033e0733"]
 pub struct Clip {
     //#[serde(default = "clip_default_warp")]
     pub warp: bool,
     duration: f32,
-    /// Entity identification parent index on this same vec and name
-    entities: Vec<(u16, String)>,
+    /// Entity identification made by parent index and name
+    entities: Vec<(u16, Name)>,
     /// Attribute is made by the entity index and a string that combines
     /// component name followed by their attributes spaced by a period,
     /// like so: `"Transform.translation.x"`
-    attribute: Vec<(u16, String, HashCode)>,
+    attribute: Vec<(u16, Name)>,
     curves: Vec<CurveUntyped>,
 }
 
@@ -51,7 +45,7 @@ impl Default for Clip {
             warp: true,
             duration: 0.0,
             // ? NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
-            entities: vec![(u16::MAX, String::default())],
+            entities: vec![(u16::MAX, Name::default())],
             attribute: vec![],
             curves: vec![],
         }
@@ -91,19 +85,14 @@ impl Clip {
             } else {
                 // Add entity
                 let e = self.entities.len();
-                self.entities.push((entity, name.to_string()));
+                self.entities.push((entity, Name::new(name.to_string())));
                 entity_created = true;
                 // Soft limit added to save memory, identical to the curve limit
                 entity = u16::try_from(e).expect("entities limit reached");
             }
         }
 
-        let property = path.1.split_at(1).1;
-
-        // Faster comparison
-        let mut hasher = DefaultHasher::default();
-        property.hash(&mut hasher);
-        let hash = HashCode(hasher.finish());
+        let insert_attr = Name::new(path.1.split_at(1).1.to_string());
 
         // If some entity was created it means this property is a new one
         if !entity_created {
@@ -118,7 +107,7 @@ impl Clip {
                 //
                 // The test case `test::unhandled_properties_implementation_for_types` will ensure that
 
-                if hash == attr.2 && property == attr.1 {
+                if insert_attr == attr.1 {
                     // Found a property are equal the one been inserted
                     // Replace curve, the property was already added, this is very important
                     // because it guarantees that each property will have unique access to some
@@ -134,7 +123,7 @@ impl Clip {
         }
 
         self.duration = self.duration.max(curve.duration());
-        self.attribute.push((entity, property.to_owned(), hash));
+        self.attribute.push((entity, insert_attr));
         self.curves.push(curve);
     }
 
@@ -149,17 +138,17 @@ impl Clip {
     /// The clip stores a property path in a specific way to improve search performance
     /// thus it needs to rebuilt the curve property path in the human readable format
     pub fn get_property_path(&self, index: u16) -> String {
-        let (entity, name, _) = &self.attribute[index as usize];
-        let mut path = format!("@{}", name);
+        let (entity, name) = &self.attribute[index as usize];
+        let mut path = format!("@{}", name.as_str());
 
         let mut first = true;
         let mut entity = *entity;
         while let Some((parent, name)) = self.entities.get(entity as usize) {
             if first {
-                path = format!("{}{}", name, path);
+                path = format!("{}{}", name.as_str(), path);
                 first = false;
             } else {
-                path = format!("{}/{}", name, path);
+                path = format!("{}/{}", name.as_str(), path);
             }
             entity = *parent;
         }
@@ -198,8 +187,16 @@ impl Clip {
     }
 }
 
+// TODO: Not found clip masks very useful, right now you can slone the cu
+// /// Masks clip
+// pub struct ClipMask {
+//     /// Entity identification made by parent index and name
+//     entities: Vec<(u16, String)>,
+//     masked: Vec<u16>,
+// }
+
 // TODO: impl Serialize, Deserialize
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum CurveUntyped {
     Float(Curve<f32>),
     Vec3(Curve<Vec3>),
@@ -239,11 +236,21 @@ impl CurveUntyped {
 // TODO: impl Serialize, Deserialize
 #[derive(Default, Debug)]
 pub struct Curve<T> {
-    // TODO: Linear and Spline variants
+    // TODO: Step / Linear / Spline variants
     samples: Vec<f32>,
+    //tangents: Vec<(f32, f32)>,
     values: Vec<T>,
 }
 
+impl<T: Clone> Clone for Curve<T> {
+    fn clone(&self) -> Self {
+        Self {
+            samples: self.samples.clone(),
+            values: self.values.clone(),
+        }
+    }
+}
+
 impl<T> Curve<T>
 where
     T: LerpValue + Clone + 'static,
@@ -378,17 +385,21 @@ pub struct Layer {
 pub struct Animator {
     clips: Vec<Handle<Clip>>,
     #[property(ignore)]
-    binds: Vec<Option<Binds>>,
+    bind_clips: Vec<Option<ClipBind>>,
+    // masks: Vec<Handle<ClipMask>>,
+    // #[property(ignore)]
+    // bind_masks: Vec<ClipMaskBind>,
     pub time_scale: f32,
     pub layers: Vec<Layer>,
-    // TODO: Transitions to simplify layer blending
 }
 
+// TODO: AnimatorStateMachine + Transitions to simplify layer blending but in another file
+
 impl Default for Animator {
     fn default() -> Self {
         Self {
             clips: vec![],
-            binds: vec![],
+            bind_clips: vec![],
             time_scale: 1.0,
             layers: vec![],
         }
@@ -407,7 +418,7 @@ impl Animator {
         }
     }
 
-    pub fn add_layer(&mut self, clip: Handle<Clip>, weight: f32) -> usize {
+    pub fn add_layer(&mut self, clip: Handle<Clip>, weight: f32) -> u16 {
         let clip = self.add_clip(clip);
         let layer_index = self.layers.len();
         self.layers.push(Layer {
@@ -415,7 +426,7 @@ impl Animator {
             weight,
             ..Default::default()
         });
-        layer_index
+        layer_index as u16
     }
 
     pub fn clips_len(&self) -> u16 {
@@ -423,17 +434,40 @@ impl Animator {
     }
 }
 
-// TODO: Bind asset properties (edge case), notice that this feature will be in hold
+// TODO: Bind asset properties (edge case), notice that this feature will be on hold
 // until the atelier assets get through. I will probably just store pointers offsets
-// because it's safe with less conditions and not that expensive
+// because require less conditions to be safe and is not too much that expensive to store
+// direct pointers
 
 #[derive(Debug)]
-struct Binds {
-    metadata: Vec<BindMeta>,
+struct ClipBindMetadataInner {
+    parent: Option<Entity>,
+    entity: Entity,
+    location: Location,
+    component: TypeId,
+}
+
+/// Metadata is used to check the bind validity
+#[derive(Debug)]
+struct ClipBindMetadata {
+    entity_index: u16,
+    inner: Option<ClipBindMetadataInner>,
+    range: (u16, u16),
+}
+
+#[derive(Debug)]
+struct ClipBind {
+    metadata: Vec<ClipBindMetadata>,
     curves: Vec<u16>,
     attributes: Vec<Ptr>,
 }
 
+// #[derive(Debug)]
+// struct ClipMaskBind {
+//     metadata: Vec<(Option<Entity>, Entity)>
+//     allowed_entities: HashMap<Entity>,
+// }
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 struct Ptr(*mut u8);
 
@@ -445,22 +479,6 @@ unsafe impl Sync for Ptr {}
 /// Marker type for missing component
 struct MissingComponentMarker;
 
-/// Meta data is used to check the bind validity
-#[derive(Debug)]
-struct BindMeta {
-    entity_index: u16,
-    inner: Option<BindInner>,
-    range: (u16, u16),
-}
-
-#[derive(Debug)]
-struct BindInner {
-    parent: Option<Entity>,
-    entity: Entity,
-    location: Location,
-    component: TypeId,
-}
-
 #[derive(Default)]
 struct ClipResourceProviderState {
     clip_event_reader: EventReader<AssetEvent<Clip>>,
@@ -510,12 +528,14 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
         let animator = &mut *animator; // Make sure the borrow checker is happy
 
         // Make room for binds or deallocate unused
-        animator.binds.resize_with(animator.clips.len(), || None);
+        animator
+            .bind_clips
+            .resize_with(animator.clips.len(), || None);
 
         // Used for entity translation
         let mut entities_table_cache = vec![];
 
-        for (clip_handle, bind) in animator.clips.iter().zip(animator.binds.iter_mut()) {
+        for (clip_handle, bind) in animator.clips.iter().zip(animator.bind_clips.iter_mut()) {
             // Invalidate binds for clips that where modified
             if modified.contains(clip_handle) {
                 *bind = None;
@@ -531,7 +551,7 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
                 if bind.is_none() {
                     // Build binds from scratch
                     // Allocate the minium enough of memory on right at the begin
-                    let mut b = Binds {
+                    let mut b = ClipBind {
                         metadata: Vec::with_capacity(clip.entities.len()),
                         curves: Vec::with_capacity(clip.attribute.len()),
                         attributes: Vec::with_capacity(clip.attribute.len()),
@@ -542,7 +562,7 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
                     let mut prev_component = TypeId::of::<MissingComponentMarker>();
                     let mut prev_component_short_name = "";
 
-                    for (curve_index, (entity_index, attr_path, _)) in
+                    for (curve_index, (entity_index, attr_path)) in
                         clip.attribute.iter().enumerate()
                     {
                         let mut commit = false;
@@ -609,17 +629,19 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
                             range.1 = b.curves.len() as u16 - 1;
 
                             // Commit meta
-                            b.metadata.push(BindMeta {
+                            b.metadata.push(ClipBindMetadata {
                                 entity_index: *entity_index,
-                                inner: prev_partial_info.map(|(entity, location)| BindInner {
-                                    // An entity will always have parent unless is the root entity
-                                    parent: entities_table_cache
-                                        .get(clip.entities[*entity_index as usize].0 as usize)
-                                        .copied()
-                                        .flatten(),
-                                    entity,
-                                    location,
-                                    component,
+                                inner: prev_partial_info.map(|(entity, location)| {
+                                    ClipBindMetadataInner {
+                                        // An entity will always have parent unless is the root entity
+                                        parent: entities_table_cache
+                                            .get(clip.entities[*entity_index as usize].0 as usize)
+                                            .copied()
+                                            .flatten(),
+                                        entity,
+                                        location,
+                                        component,
+                                    }
                                 }),
                                 range,
                             });
@@ -741,7 +763,7 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
 
 fn find_entity(
     entity_index: u16,
-    entities_ids: &Vec<(u16, String)>,
+    entities_ids: &Vec<(u16, Name)>,
     entities_table_cache: &mut Vec<Option<Entity>>,
     world: &World,
 ) -> Option<Entity> {
@@ -758,7 +780,7 @@ fn find_entity(
                         .iter()
                         .find(|entity| {
                             if let Ok(name) = world.get::<Name>(**entity) {
-                                if &name.0 == entity_name {
+                                if name == entity_name {
                                     // Update cache
                                     entities_table_cache[entity_index as usize] = Some(**entity);
                                     true
@@ -820,15 +842,13 @@ fn find_property_ptr<'a, P: Iterator<Item = &'a str>>(
 ) -> Ptr {
     Ptr(find_property_at_path(path, root_props, type_id)
         .map(|prop| {
-            let ptr = prop.any() as *const _ as *mut u8;
+            let ptr = prop as *const _ as *mut u8;
             // Perform an extra assertion to make sure this pointer is inside the component
             // memory bounds, so no dangle pointers can be created
-            // TODO: cfg extra asserts
             {
-                let root_any = root_props.any();
-                let root = root_any as *const _ as *mut u8;
-                let size = std::mem::size_of_val(root_any) as isize;
-                assert!(unsafe { root.offset_from(ptr).abs() } <= size);
+                let root = root_props as *const _ as *mut u8;
+                let size = std::mem::size_of_val(root_props) as isize;
+                debug_assert!(unsafe { root.offset_from(ptr).abs() } <= size);
             }
             ptr
         })
@@ -861,7 +881,7 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
                 .map(|clip_handle| clips.get(clip_handle))
                 .flatten()
             {
-                if let Some(bind) = &animator.binds[clip_index as usize] {
+                if let Some(bind) = &animator.bind_clips[clip_index as usize] {
                     let curves_count = clip.curves.len();
 
                     // Ensure capacity for cached keyframe index vec
@@ -1084,6 +1104,7 @@ mod tests {
     // TODO: Add tests for hierarch change (creation and deletion)
     // TODO: Add tests for entity archetype change
     // TODO: Add tests for entities with same Name
+    // TODO: Add tests for mutated events
     // TODO: Add tests for animated handle (impl missing)
     // TODO: Add tests for animated asset properties (impl missing)
 }
diff --git a/crates/bevy_animation/src/skined_mesh.rs b/crates/bevy_animation/src/skined_mesh.rs
index 479cb3c7aca48..5c3dd6f9e0407 100644
--- a/crates/bevy_animation/src/skined_mesh.rs
+++ b/crates/bevy_animation/src/skined_mesh.rs
@@ -118,6 +118,7 @@ pub(crate) fn mesh_skinner_startup(
             // Ensure bone capacity
             mesh_skinner.bones.resize(skin.bone_count(), None);
 
+            // TODO: Uee the find_entity function instead!
             let mut root = true;
             let mut stack = vec![mesh_skinner.skeleton];
             while let Some(entity) = stack.pop() {
@@ -133,7 +134,7 @@ pub(crate) fn mesh_skinner_startup(
                         .bones_names
                         .iter()
                         .enumerate()
-                        .find(|(_, n)| name.eq(*n))
+                        .find(|(_, n)| name.as_str().eq(n.as_str()))
                     {
                         mesh_skinner.bones[bone_index] = Some(bone_entity);
                         children.map(|c| stack.extend(c.iter()));
diff --git a/crates/bevy_core/src/name.rs b/crates/bevy_core/src/name.rs
index 0f6721ad910c9..8fd6952ddad0f 100644
--- a/crates/bevy_core/src/name.rs
+++ b/crates/bevy_core/src/name.rs
@@ -1,22 +1,74 @@
 use bevy_property::Properties;
-use std::ops::{Deref, DerefMut};
+use std::ops::Deref;
 
 // NOTE: This is used by the animation system to find the right entity to animate
 
-/// Component containing the name used to uniquely identify a entity
-#[derive(Default, Debug, Properties)]
-pub struct Name(pub String);
+use std::collections::hash_map::DefaultHasher;
+use std::hash::{Hash, Hasher};
 
-impl Deref for Name {
-    type Target = String;
+/// Component containing the name used to identify a entity. Keep in mind that
+/// multiple entities may have the same name.
+///
+/// *NOTE* Once created you can't change it's contents because this `Name`
+/// component also stores the string hash to drastically improve performance comparison
+#[derive(Debug, Clone, Properties)]
+pub struct Name {
+    hash: u64, // TODO: Shouldn't be serialized
+    name: String,
+}
 
-    fn deref(&self) -> &Self::Target {
-        &self.0
+impl Default for Name {
+    fn default() -> Self {
+        Name::new("".to_string())
     }
 }
 
-impl DerefMut for Name {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
+impl Name {
+    pub fn new(name: String) -> Self {
+        let mut hasher = DefaultHasher::default();
+        name.hash(&mut hasher);
+        let hash = hasher.finish();
+
+        Name { name, hash }
+    }
+
+    #[inline(always)]
+    pub fn as_str(&self) -> &str {
+        self.name.as_str()
+    }
+}
+
+impl PartialEq for Name {
+    fn eq(&self, other: &Self) -> bool {
+        if self.hash != other.hash {
+            // Makes the common case of two strings not been equal very fast
+            return false;
+        }
+
+        self.name.eq(&other.name)
+    }
+}
+
+impl Eq for Name {}
+
+impl PartialOrd for Name {
+    #[inline(always)]
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        self.name.partial_cmp(&other.name)
+    }
+}
+
+impl Ord for Name {
+    #[inline(always)]
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.name.cmp(&other.name)
+    }
+}
+
+impl Deref for Name {
+    type Target = String;
+
+    fn deref(&self) -> &Self::Target {
+        &self.name
     }
 }
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 3f511efaf84d3..5619a9ffab85d 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -376,7 +376,7 @@ async fn load_gltf<'a, 'b>(
         world_builder.spawn((Transform::default(), GlobalTransform::default()));
 
         if let Some(name) = scene.name() {
-            world_builder.with(Name(name.to_string()));
+            world_builder.with(Name::new(name.to_string()));
         }
 
         // Animator component
@@ -428,7 +428,7 @@ fn load_node(
     entity_lookup[node.index()] = Some(node_entity);
 
     if let Some(name) = node.name() {
-        world_builder.with(Name(name.to_string()));
+        world_builder.with(Name::new(name.to_string()));
     }
 
     if let Some(skin) = node.skin() {

From dbe08d6a79b7c7f4446ec1cd15cd8a432891ebcd Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Wed, 25 Nov 2020 19:28:12 -0300
Subject: [PATCH 017/153] fixed nlerp (always take the short path) + animation
 blening

---
 crates/bevy_animation/Cargo.toml     |   1 -
 crates/bevy_animation/src/generic.rs | 149 ++++++++++--
 crates/bevy_animation/src/lerping.rs |   9 +-
 crates/bevy_animation/src/util.rs    | 350 ---------------------------
 crates/bevy_core/src/name.rs         |   9 +-
 crates/bevy_gltf/src/loader.rs       |  54 +----
 6 files changed, 139 insertions(+), 433 deletions(-)
 delete mode 100644 crates/bevy_animation/src/util.rs

diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index e35c77762edf5..5bbe5d66e6653 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -14,7 +14,6 @@ bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
 bevy_pbr = { path = "../bevy_pbr", version = "0.3.0" }
 bevy_math = { path = "../bevy_math", version = "0.3.0" }
 bevy_render = { path = "../bevy_render", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
 #bevy_tasks = { path = "../bevy_tasks", version = "0.3.0" }
 bevy_transform = { path = "../bevy_transform", version = "0.3.0" }
 bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 3e2c8fa59bc7c..8451c7e91b6cb 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -8,11 +8,11 @@ use bevy_math::prelude::*;
 use bevy_property::{Properties, Property, PropertyType};
 use bevy_transform::prelude::*;
 use bevy_type_registry::{TypeRegistry, TypeUuid};
-use bevy_utils::HashSet;
+use std::collections::HashSet;
 //use serde::{Deserialize, Serialize};
-use std::any::TypeId;
 use std::convert::TryFrom;
 use std::ptr::null_mut;
+use std::{any::TypeId, hash::Hash};
 
 use super::lerping::LerpValue;
 
@@ -372,15 +372,27 @@ where
     }
 }
 
-#[derive(Default, Debug, Clone, Properties)]
+#[derive(Debug, Clone, Properties)]
 pub struct Layer {
     pub weight: f32,
     pub clip: u16,
     pub time: f32,
-    //pub time_scale: f32, // TODO: Add time_scale
+    pub time_scale: f32,
     keyframe: Vec<usize>,
 }
 
+impl Default for Layer {
+    fn default() -> Self {
+        Layer {
+            weight: 1.0,
+            clip: 0,
+            time: 0.0,
+            time_scale: 1.0,
+            keyframe: vec![],
+        }
+    }
+}
+
 #[derive(Debug, Properties)]
 pub struct Animator {
     clips: Vec<Handle<Clip>>,
@@ -476,6 +488,23 @@ struct Ptr(*mut u8);
 unsafe impl Send for Ptr {}
 unsafe impl Sync for Ptr {}
 
+// /// Hash and equality by pointer not the value it self
+// struct HashPtr<'a, T>(&'a mut T);
+
+// impl<'a, T> Hash for HashPtr<'a, T> {
+//     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+//         (self.0 as *const T).hash(state);
+//     }
+// }
+
+// impl<'a, T> PartialEq for HashPtr<'a, T> {
+//     fn eq(&self, other: &Self) -> bool {
+//         (self.0 as *const T) == (other.0 as *const T)
+//     }
+// }
+
+// impl<'a, T> Eq for HashPtr<'a, T> {}
+
 /// Marker type for missing component
 struct MissingComponentMarker;
 
@@ -515,7 +544,7 @@ pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resourc
 
     // ? NOTE: Changing a clip on fly is supported, but very expensive so use with caution
     // Query all clips that changed and remove their binds from the animator
-    let mut modified = HashSet::default();
+    let mut modified = HashSet::new();
     for event in state.clip_event_reader.iter(&clip_events) {
         match event {
             AssetEvent::Removed { handle } => modified.insert(handle),
@@ -848,7 +877,12 @@ fn find_property_ptr<'a, P: Iterator<Item = &'a str>>(
             {
                 let root = root_props as *const _ as *mut u8;
                 let size = std::mem::size_of_val(root_props) as isize;
-                debug_assert!(unsafe { root.offset_from(ptr).abs() } <= size);
+                // With the new bevy_reflect we can ref properties inside vectors and other things
+                if unsafe { root.offset_from(ptr).abs() } >= size {
+                    // TODO: log also the full property path
+                    tracing::warn!("property outside component");
+                    return null_mut();
+                }
             }
             ptr
         })
@@ -857,6 +891,9 @@ fn find_property_ptr<'a, P: Iterator<Item = &'a str>>(
 
 #[tracing::instrument(skip(world, resources))]
 pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resources) {
+    /// Small value
+    const SMOL: f32 = 1e-8;
+
     let time = resources.get::<Time>().unwrap();
     let clips = resources.get::<Assets<Clip>>().unwrap();
 
@@ -864,16 +901,36 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
     let animators_query = unsafe { world.query_unchecked::<(&mut Animator,), ()>() };
     let delta_time = time.delta_seconds;
 
+    // TODO: System local?
+    let mut visited = HashSet::new();
+
+    // ? NOTE: Keep in mind that one hierarchy tree could have many `Animator`s thus
+    // ? we can't parallelize over the animators easily without creating a race condition
     for (mut animator,) in animators_query {
         let animator = &mut *animator;
 
         // Time scales by component
         let delta_time = delta_time * animator.time_scale;
 
-        // TODO: Add layer mask or a trimmed clip with reused curves and stuff
-        // TODO: Add layer blending
-        //for layer in &mut animator.layers {
-        if let Some(layer) = animator.layers.first_mut() {
+        let w_total = animator
+            .layers
+            .iter()
+            .fold(0.0, |w, layer| w + layer.weight);
+
+        let norm = 1.0 / w_total;
+
+        // Normalize all states weights
+        for layer in &mut animator.layers {
+            layer.weight *= norm;
+        }
+
+        visited.clear();
+        for layer in &mut animator.layers {
+            let w = layer.weight;
+            if w < SMOL {
+                continue;
+            }
+
             let clip_index = layer.clip;
             if let Some(clip) = animator
                 .clips
@@ -881,6 +938,8 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
                 .map(|clip_handle| clips.get(clip_handle))
                 .flatten()
             {
+                // TODO: Add layer mask
+
                 if let Some(bind) = &animator.bind_clips[clip_index as usize] {
                     let curves_count = clip.curves.len();
 
@@ -893,7 +952,7 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
                     }
 
                     // Update time
-                    let mut time = layer.time + delta_time;
+                    let mut time = layer.time + delta_time * layer.time_scale;
 
                     // TODO: I notice some jitter during playback
 
@@ -916,8 +975,6 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
                     // Advance state time
                     layer.time = time;
 
-                    // TODO: handle backwards time
-
                     for ((ptr, keyframe), curve_index) in bind
                         .attributes
                         .iter()
@@ -931,6 +988,13 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
 
                         let curve = &clip.curves[*curve_index as usize];
 
+                        let viz = if visited.contains(&ptr.0) {
+                            true
+                        } else {
+                            visited.insert(ptr.0);
+                            false
+                        };
+
                         // SAFETY: The `animator_binding_system` is responsible to invalidate and/or update
                         // any ptr that no longer pointers to the right component for the right entity;
                         // Also it will only allows to ptr to attributes by value inside the component this means
@@ -939,35 +1003,69 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
                         match curve {
                             CurveUntyped::Float(v) => {
                                 let (k, v) = v.sample_indexed(*keyframe, time);
-                                let attr = unsafe { &mut *(ptr.0 as *mut f32) };
-                                *attr = v;
                                 *keyframe = k;
+
+                                unsafe {
+                                    let ptr = ptr.0 as *mut f32;
+                                    if viz {
+                                        *ptr = LerpValue::lerp(&*ptr, &v, w);
+                                    } else {
+                                        *ptr = v;
+                                    }
+                                }
                             }
                             CurveUntyped::Vec3(v) => {
                                 let (k, v) = v.sample_indexed(*keyframe, time);
-                                let attr = unsafe { &mut *(ptr.0 as *mut Vec3) };
-                                *attr = v;
                                 *keyframe = k;
+
+                                unsafe {
+                                    let ptr = ptr.0 as *mut Vec3;
+                                    if viz {
+                                        *ptr = LerpValue::lerp(&*ptr, &v, w);
+                                    } else {
+                                        *ptr = v;
+                                    }
+                                }
                             }
-                            CurveUntyped::Vec4(v) => {
-                                let (k, v) = v.sample_indexed(*keyframe, time);
-                                let attr = unsafe { &mut *(ptr.0 as *mut Vec4) };
-                                *attr = v;
+                            CurveUntyped::Vec4(c) => {
+                                let (k, v) = c.sample_indexed(*keyframe, time);
                                 *keyframe = k;
+
+                                unsafe {
+                                    let ptr = ptr.0 as *mut Vec4;
+                                    if viz {
+                                        *ptr = LerpValue::lerp(&*ptr, &v, w);
+                                    } else {
+                                        *ptr = v;
+                                    }
+                                }
                             }
                             CurveUntyped::Quat(v) => {
                                 let (k, v) = v.sample_indexed(*keyframe, time);
-                                let attr = unsafe { &mut *(ptr.0 as *mut Quat) };
-                                *attr = v;
                                 *keyframe = k;
+
+                                // if v.w < 0.0 {
+                                //     v = -v;
+                                // }
+
+                                // TODO: normalize is killing the performance?
+                                unsafe {
+                                    let ptr = ptr.0 as *mut Quat;
+                                    if viz {
+                                        // ? NOTE: Blending must be commutative above so nlerp is always the way to go here
+                                        *ptr = LerpValue::lerp(&*ptr, &v, w);
+                                    } else {
+                                        *ptr = v;
+                                    }
+                                }
                             }
                         }
-
-                        // TODO: Make sure to update the components states to 'Changed'
                     }
                 }
             }
         }
+
+        // TODO: Make sure to update the components states to trigger 'Mutated'
     }
 }
 
@@ -1107,4 +1205,5 @@ mod tests {
     // TODO: Add tests for mutated events
     // TODO: Add tests for animated handle (impl missing)
     // TODO: Add tests for animated asset properties (impl missing)
+    // TODO: Add tests for animated components should trigger 'Mutated' queries filters (impl missing)
 }
diff --git a/crates/bevy_animation/src/lerping.rs b/crates/bevy_animation/src/lerping.rs
index b1344dddeb917..f5c449f7b84ae 100644
--- a/crates/bevy_animation/src/lerping.rs
+++ b/crates/bevy_animation/src/lerping.rs
@@ -34,9 +34,16 @@ impl LerpValue for Quat {
     /// Actually performs an nlerp, because it's much cheaper and easer to combine with other animations,
     /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        // Make sure is always the short path
+        let mut b = *b;
+        if a.dot(b) < 0.0 {
+            b = -b;
+        }
+
+        Vec4::lerp((*a).into(), b.into(), t).normalize().into()
+
         // ! NOTE: slerp is nice if you want to debug the animation code
         // a.slerp(b, t)
-        Vec4::lerp((*a).into(), (*b).into(), t).normalize().into()
     }
 }
 
diff --git a/crates/bevy_animation/src/util.rs b/crates/bevy_animation/src/util.rs
deleted file mode 100644
index 0ef130acf0b6d..0000000000000
--- a/crates/bevy_animation/src/util.rs
+++ /dev/null
@@ -1,350 +0,0 @@
-use std::mem::{self, size_of};
-use std::ptr;
-
-////////////////////////////////////////////////////////////////////////////////
-// Sorting for SOA
-////////////////////////////////////////////////////////////////////////////////
-
-/// Inserts `v[0]` into pre-sorted sequence `v[1..]` so that whole `v[..]` becomes sorted.
-///
-/// This is the integral subroutine of insertion sort.
-fn insert_head<T, U, F>(v: &mut [T], u: &mut [U], is_less: &mut F)
-where
-    F: FnMut(&T, &T) -> bool,
-{
-    if v.len() >= 2 && is_less(&v[1], &v[0]) {
-        unsafe {
-            // There are three ways to implement insertion here:
-            //
-            // 1. Swap adjacent elements until the first one gets to its final destination.
-            //    However, this way we copy data around more than is necessary. If elements are big
-            //    structures (costly to copy), this method will be slow.
-            //
-            // 2. Iterate until the right place for the first element is found. Then shift the
-            //    elements succeeding it to make room for it and finally place it into the
-            //    remaining hole. This is a good method.
-            //
-            // 3. Copy the first element into a temporary variable. Iterate until the right place
-            //    for it is found. As we go along, copy every traversed element into the slot
-            //    preceding it. Finally, copy data from the temporary variable into the remaining
-            //    hole. This method is very good. Benchmarks demonstrated slightly better
-            //    performance than with the 2nd method.
-            //
-            // All methods were benchmarked, and the 3rd showed best results. So we chose that one.
-            let mut tmp = mem::ManuallyDrop::new(ptr::read(&v[0]));
-
-            // Intermediate state of the insertion process is always tracked by `hole`, which
-            // serves two purposes:
-            // 1. Protects integrity of `v` from panics in `is_less`.
-            // 2. Fills the remaining hole in `v` in the end.
-            //
-            // Panic safety:
-            //
-            // If `is_less` panics at any point during the process, `hole` will get dropped and
-            // fill the hole in `v` with `tmp`, thus ensuring that `v` still holds every object it
-            // initially held exactly once.
-            let mut hole = InsertionHole {
-                src: &mut *tmp,
-                dest: &mut v[1],
-            };
-            ptr::copy_nonoverlapping(&v[1], &mut v[0], 1);
-
-            for i in 2..v.len() {
-                if !is_less(&v[i], &*tmp) {
-                    break;
-                }
-                ptr::copy_nonoverlapping(&v[i], &mut v[i - 1], 1);
-                hole.dest = &mut v[i];
-            }
-            // `hole` gets dropped and thus copies `tmp` into the remaining hole in `v`.
-        }
-    }
-
-    // When dropped, copies from `src` into `dest`.
-    struct InsertionHole<T> {
-        src: *mut T,
-        dest: *mut T,
-    }
-
-    impl<T> Drop for InsertionHole<T> {
-        fn drop(&mut self) {
-            unsafe {
-                ptr::copy_nonoverlapping(self.src, self.dest, 1);
-            }
-        }
-    }
-}
-
-/// Merges non-decreasing runs `v[..mid]` and `v[mid..]` using `buf` as temporary storage, and
-/// stores the result into `v[..]`.
-///
-/// # Safety
-///
-/// The two slices must be non-empty and `mid` must be in bounds. Buffer `buf` must be long enough
-/// to hold a copy of the shorter slice. Also, `T` must not be a zero-sized type.
-unsafe fn merge<T, U, F>(v: &mut [T], u: &mut [U], mid: usize, buf: *mut T, is_less: &mut F)
-where
-    F: FnMut(&T, &T) -> bool,
-{
-    let len = v.len();
-    let v = v.as_mut_ptr();
-    let (v_mid, v_end) = unsafe { (v.add(mid), v.add(len)) };
-
-    // The merge process first copies the shorter run into `buf`. Then it traces the newly copied
-    // run and the longer run forwards (or backwards), comparing their next unconsumed elements and
-    // copying the lesser (or greater) one into `v`.
-    //
-    // As soon as the shorter run is fully consumed, the process is done. If the longer run gets
-    // consumed first, then we must copy whatever is left of the shorter run into the remaining
-    // hole in `v`.
-    //
-    // Intermediate state of the process is always tracked by `hole`, which serves two purposes:
-    // 1. Protects integrity of `v` from panics in `is_less`.
-    // 2. Fills the remaining hole in `v` if the longer run gets consumed first.
-    //
-    // Panic safety:
-    //
-    // If `is_less` panics at any point during the process, `hole` will get dropped and fill the
-    // hole in `v` with the unconsumed range in `buf`, thus ensuring that `v` still holds every
-    // object it initially held exactly once.
-    let mut hole;
-
-    if mid <= len - mid {
-        // The left run is shorter.
-        unsafe {
-            ptr::copy_nonoverlapping(v, buf, mid);
-            hole = MergeHole {
-                start: buf,
-                end: buf.add(mid),
-                dest: v,
-            };
-        }
-
-        // Initially, these pointers point to the beginnings of their arrays.
-        let left = &mut hole.start;
-        let mut right = v_mid;
-        let out = &mut hole.dest;
-
-        while *left < hole.end && right < v_end {
-            // Consume the lesser side.
-            // If equal, prefer the left run to maintain stability.
-            unsafe {
-                let to_copy = if is_less(&*right, &**left) {
-                    get_and_increment(&mut right)
-                } else {
-                    get_and_increment(left)
-                };
-                ptr::copy_nonoverlapping(to_copy, get_and_increment(out), 1);
-            }
-        }
-    } else {
-        // The right run is shorter.
-        unsafe {
-            ptr::copy_nonoverlapping(v_mid, buf, len - mid);
-            hole = MergeHole {
-                start: buf,
-                end: buf.add(len - mid),
-                dest: v_mid,
-            };
-        }
-
-        // Initially, these pointers point past the ends of their arrays.
-        let left = &mut hole.dest;
-        let right = &mut hole.end;
-        let mut out = v_end;
-
-        while v < *left && buf < *right {
-            // Consume the greater side.
-            // If equal, prefer the right run to maintain stability.
-            unsafe {
-                let to_copy = if is_less(&*right.offset(-1), &*left.offset(-1)) {
-                    decrement_and_get(left)
-                } else {
-                    decrement_and_get(right)
-                };
-                ptr::copy_nonoverlapping(to_copy, decrement_and_get(&mut out), 1);
-            }
-        }
-    }
-    // Finally, `hole` gets dropped. If the shorter run was not fully consumed, whatever remains of
-    // it will now be copied into the hole in `v`.
-
-    unsafe fn get_and_increment<T>(ptr: &mut *mut T) -> *mut T {
-        let old = *ptr;
-        *ptr = unsafe { ptr.offset(1) };
-        old
-    }
-
-    unsafe fn decrement_and_get<T>(ptr: &mut *mut T) -> *mut T {
-        *ptr = unsafe { ptr.offset(-1) };
-        *ptr
-    }
-
-    // When dropped, copies the range `start..end` into `dest..`.
-    struct MergeHole<T> {
-        start: *mut T,
-        end: *mut T,
-        dest: *mut T,
-    }
-
-    impl<T> Drop for MergeHole<T> {
-        fn drop(&mut self) {
-            // `T` is not a zero-sized type, so it's okay to divide by its size.
-            let len = (self.end as usize - self.start as usize) / mem::size_of::<T>();
-            unsafe {
-                ptr::copy_nonoverlapping(self.start, self.dest, len);
-            }
-        }
-    }
-}
-
-/// This merge sort borrows some (but not all) ideas from TimSort, which is described in detail
-/// [here](http://svn.python.org/projects/python/trunk/Objects/listsort.txt).
-///
-/// The algorithm identifies strictly descending and non-descending subsequences, which are called
-/// natural runs. There is a stack of pending runs yet to be merged. Each newly found run is pushed
-/// onto the stack, and then some pairs of adjacent runs are merged until these two invariants are
-/// satisfied:
-///
-/// 1. for every `i` in `1..runs.len()`: `runs[i - 1].len > runs[i].len`
-/// 2. for every `i` in `2..runs.len()`: `runs[i - 2].len > runs[i - 1].len + runs[i].len`
-///
-/// The invariants ensure that the total running time is `O(n * log(n))` worst-case.
-pub fn merge_sort2<T, U, F>(v: &mut [T], u: &mut [U], mut is_less: F)
-where
-    F: FnMut(&T, &T) -> bool,
-{
-    debug_assert!(u.len() == v.len());
-
-    // Slices of up to this length get sorted using insertion sort.
-    const MAX_INSERTION: usize = 20;
-    // Very short runs are extended using insertion sort to span at least this many elements.
-    const MIN_RUN: usize = 10;
-
-    // Sorting has no meaningful behavior on zero-sized types.
-    if size_of::<T>() == 0 {
-        return;
-    }
-
-    let len = v.len();
-
-    // Short arrays get sorted in-place via insertion sort to avoid allocations.
-    if len <= MAX_INSERTION {
-        if len >= 2 {
-            for i in (0..len - 1).rev() {
-                insert_head(&mut v[i..], &mut u[i..], &mut is_less);
-            }
-        }
-        return;
-    }
-
-    // Allocate a buffer to use as scratch memory. We keep the length 0 so we can keep in it
-    // shallow copies of the contents of `v` without risking the dtors running on copies if
-    // `is_less` panics. When merging two sorted runs, this buffer holds a copy of the shorter run,
-    // which will always have length at most `len / 2`.
-    let mut buf = Vec::with_capacity(len / 2);
-
-    // In order to identify natural runs in `v`, we traverse it backwards. That might seem like a
-    // strange decision, but consider the fact that merges more often go in the opposite direction
-    // (forwards). According to benchmarks, merging forwards is slightly faster than merging
-    // backwards. To conclude, identifying runs by traversing backwards improves performance.
-    let mut runs = vec![];
-    let mut end = len;
-    while end > 0 {
-        // Find the next natural run, and reverse it if it's strictly descending.
-        let mut start = end - 1;
-        if start > 0 {
-            start -= 1;
-            unsafe {
-                if is_less(v.get_unchecked(start + 1), v.get_unchecked(start)) {
-                    while start > 0 && is_less(v.get_unchecked(start), v.get_unchecked(start - 1)) {
-                        start -= 1;
-                    }
-                    v[start..end].reverse();
-                    u[start..end].reverse();
-                } else {
-                    while start > 0 && !is_less(v.get_unchecked(start), v.get_unchecked(start - 1))
-                    {
-                        start -= 1;
-                    }
-                }
-            }
-        }
-
-        // Insert some more elements into the run if it's too short. Insertion sort is faster than
-        // merge sort on short sequences, so this significantly improves performance.
-        while start > 0 && end - start < MIN_RUN {
-            start -= 1;
-            insert_head(&mut v[start..end], &mut u[start..end], &mut is_less);
-        }
-
-        // Push this run onto the stack.
-        runs.push(Run {
-            start,
-            len: end - start,
-        });
-        end = start;
-
-        // Merge some pairs of adjacent runs to satisfy the invariants.
-        while let Some(r) = collapse(&runs) {
-            let left = runs[r + 1];
-            let right = runs[r];
-            unsafe {
-                merge(
-                    &mut v[left.start..right.start + right.len],
-                    &mut u[left.start..right.start + right.len],
-                    left.len,
-                    buf.as_mut_ptr(),
-                    &mut is_less,
-                );
-            }
-            runs[r] = Run {
-                start: left.start,
-                len: left.len + right.len,
-            };
-            runs.remove(r + 1);
-        }
-    }
-
-    // Finally, exactly one run must remain in the stack.
-    debug_assert!(runs.len() == 1 && runs[0].start == 0 && runs[0].len == len);
-
-    // Examines the stack of runs and identifies the next pair of runs to merge. More specifically,
-    // if `Some(r)` is returned, that means `runs[r]` and `runs[r + 1]` must be merged next. If the
-    // algorithm should continue building a new run instead, `None` is returned.
-    //
-    // TimSort is infamous for its buggy implementations, as described here:
-    // http://envisage-project.eu/timsort-specification-and-verification/
-    //
-    // The gist of the story is: we must enforce the invariants on the top four runs on the stack.
-    // Enforcing them on just top three is not sufficient to ensure that the invariants will still
-    // hold for *all* runs in the stack.
-    //
-    // This function correctly checks invariants for the top four runs. Additionally, if the top
-    // run starts at index 0, it will always demand a merge operation until the stack is fully
-    // collapsed, in order to complete the sort.
-    #[inline]
-    fn collapse(runs: &[Run]) -> Option<usize> {
-        let n = runs.len();
-        if n >= 2
-            && (runs[n - 1].start == 0
-                || runs[n - 2].len <= runs[n - 1].len
-                || (n >= 3 && runs[n - 3].len <= runs[n - 2].len + runs[n - 1].len)
-                || (n >= 4 && runs[n - 4].len <= runs[n - 3].len + runs[n - 2].len))
-        {
-            if n >= 3 && runs[n - 3].len < runs[n - 1].len {
-                Some(n - 3)
-            } else {
-                Some(n - 2)
-            }
-        } else {
-            None
-        }
-    }
-
-    #[derive(Clone, Copy)]
-    struct Run {
-        start: usize,
-        len: usize,
-    }
-}
diff --git a/crates/bevy_core/src/name.rs b/crates/bevy_core/src/name.rs
index 8fd6952ddad0f..0545df02c341a 100644
--- a/crates/bevy_core/src/name.rs
+++ b/crates/bevy_core/src/name.rs
@@ -32,12 +32,17 @@ impl Name {
         Name { name, hash }
     }
 
-    #[inline(always)]
     pub fn as_str(&self) -> &str {
         self.name.as_str()
     }
 }
 
+impl Hash for Name {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.name.hash(state);
+    }
+}
+
 impl PartialEq for Name {
     fn eq(&self, other: &Self) -> bool {
         if self.hash != other.hash {
@@ -52,14 +57,12 @@ impl PartialEq for Name {
 impl Eq for Name {}
 
 impl PartialOrd for Name {
-    #[inline(always)]
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
         self.name.partial_cmp(&other.name)
     }
 }
 
 impl Ord for Name {
-    #[inline(always)]
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
         self.name.cmp(&other.name)
     }
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 5619a9ffab85d..2a9b7c17860e0 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -306,35 +306,7 @@ async fn load_gltf<'a, 'b>(
                     // TODO: This is a runtime importer so here's no place for further optimizations
                 }
                 ReadOutputs::Rotations(values) => {
-                    let mut values = values.into_f32().map(|v| Quat::from(v)).collect::<Vec<_>>();
-
-                    // NOTE: To avoid 2pi rotations in between frames we keep the w value always positive
-                    // this happens when decomposing frames from Mat4, each frame snapshot by it self is
-                    // correct but the motion is wrong, causing a in between frames 360º spin around the
-                    // quaternion axis;
-                    //
-                    // When quaternion changes its sign: https://math.stackexchange.com/questions/2016282/negative-quaternion
-
-                    // NOTE: Making sure w > 0 is not enough
-                    // for r in rotation.iter_mut() {
-                    //     if r[3] < 0.0 {
-                    //         *r = -*r;
-                    //     }
-                    //     // NODE: No need to normalize the quaternion
-                    // }
-
-                    // NOTE: Same problem than before but in a different way, some times the quaternion
-                    // axis will flip in between frames (even ensuring w > 0). So the function `is_axis_flipped`
-                    // will check if they are colinear and if they flipped their sing.
-                    if values.len() > 1 {
-                        for i in 0..values.len() - 1 {
-                            if is_axis_flipped(values[i], values[i + 1]) {
-                                let r = &mut values[i + 1];
-                                *r = -(*r);
-                            }
-                        }
-                    }
-
+                    let values = values.into_f32().map(|v| Quat::from(v)).collect::<Vec<_>>();
                     property_path += "@Transform.rotation";
                     clip_curves.push((
                         property_path,
@@ -646,27 +618,3 @@ async fn load_buffers(
 
     Ok(buffer_data)
 }
-
-const EPSILON: f32 = 1.0e-8;
-const EPSILON_SQUARED: f32 = EPSILON * EPSILON;
-
-fn axis(a: Quat) -> Vec3 {
-    let (x, y, z, w) = Vec4::from(a).into();
-    let scale_sq = (1.0 - w * w).max(0.0);
-    if scale_sq >= EPSILON_SQUARED {
-        Vec3::new(x, y, z) / scale_sq.sqrt()
-    } else {
-        Vec3::unit_x()
-    }
-}
-
-fn is_axis_flipped(a: Quat, b: Quat) -> bool {
-    let dot = axis(a).dot(axis(b));
-    if (1.0 - dot.abs()) > 0.1 {
-        false
-    } else {
-        // Quaternion axis are (almost) colinear
-        // but heir axis are opposing to each other
-        dot < 0.0
-    }
-}

From acc1b336e2cad1338609077919beb806e1dcf24f Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Wed, 25 Nov 2020 23:14:44 -0300
Subject: [PATCH 018/153] most comments

---
 crates/bevy_animation/src/generic.rs          | 57 +++++++++--
 crates/bevy_animation/src/lerping.rs          |  7 +-
 crates/bevy_animation/src/lib.rs              |  8 +-
 .../src/{skined_mesh.rs => skinned_mesh.rs}   | 99 +------------------
 crates/bevy_gltf/src/loader.rs                |  2 +-
 5 files changed, 57 insertions(+), 116 deletions(-)
 rename crates/bevy_animation/src/{skined_mesh.rs => skinned_mesh.rs} (73%)

diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 8451c7e91b6cb..444633f4e7a19 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -67,6 +67,7 @@ impl Clip {
         let path =
             property_path.split_at(property_path.rfind('@').expect("property path missing @"));
 
+        // TODO: Prepare for bevy_reflect
         let mut entity_created = false;
         let mut entity = 0; // Start search from root
         for name in path.0.split('/') {
@@ -202,7 +203,7 @@ pub enum CurveUntyped {
     Vec3(Curve<Vec3>),
     Vec4(Curve<Vec4>),
     Quat(Curve<Quat>),
-    //Handle(Curve<HandleUntyped>), // TODO: Requires (de)serialize!
+    //Handle(Curve<HandleUntyped>),
     // TODO: Color(Curve<Color>),
 }
 
@@ -901,8 +902,9 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
     let animators_query = unsafe { world.query_unchecked::<(&mut Animator,), ()>() };
     let delta_time = time.delta_seconds;
 
-    // TODO: System local?
-    let mut visited = HashSet::new();
+    // TODO: Warp in a tread_local! to parallelize the property lerping
+    // NOTE: Allocate a big chunk where to avoid doing any extra allocations during the property lerp
+    let mut visited = HashSet::with_capacity(1069);
 
     // ? NOTE: Keep in mind that one hierarchy tree could have many `Animator`s thus
     // ? we can't parallelize over the animators easily without creating a race condition
@@ -975,6 +977,7 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
                     // Advance state time
                     layer.time = time;
 
+                    // TODO: can be done in bached_parallel when visited warped inside a thread_local!
                     for ((ptr, keyframe), curve_index) in bind
                         .attributes
                         .iter()
@@ -1044,15 +1047,11 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
                                 let (k, v) = v.sample_indexed(*keyframe, time);
                                 *keyframe = k;
 
-                                // if v.w < 0.0 {
-                                //     v = -v;
-                                // }
-
-                                // TODO: normalize is killing the performance?
                                 unsafe {
                                     let ptr = ptr.0 as *mut Quat;
                                     if viz {
-                                        // ? NOTE: Blending must be commutative above so nlerp is always the way to go here
+                                        // ? NOTE: Blending two clips no matter the order
+                                        // ? should give the same results, so nlerp must be used
                                         *ptr = LerpValue::lerp(&*ptr, &v, w);
                                     } else {
                                         *ptr = v;
@@ -1144,18 +1143,56 @@ mod tests {
         // access to some attribute during the update stages
         let mut clip = Clip::default();
         let prop = "/Root/Ball@Sphere.radius";
+        clip.add_animated_prop(
+            "/Root/Ball@Transform.translate.y",
+            CurveUntyped::Float(Curve::from_linear(0.0, 1.0, 0.0, 1.0)),
+        );
         clip.add_animated_prop(
             prop,
             CurveUntyped::Float(Curve::from_linear(0.0, 1.0, 0.0, 1.0)),
         );
+        assert_eq!(clip.duration(), 1.0);
         clip.add_animated_prop(
             prop,
             CurveUntyped::Float(Curve::from_linear(0.0, 1.2, 0.1, 2.0)),
         );
-        assert_eq!(clip.len(), 1);
+        assert_eq!(clip.len(), 2);
+        assert_eq!(clip.get_property_path(1), prop);
         assert_eq!(clip.duration(), 1.2);
     }
 
+    #[test]
+    fn clip_fine_grain_properties() {
+        let mut clip = Clip::default();
+        clip.add_animated_prop(
+            "/Root/Ball@Transform.translate.y",
+            CurveUntyped::Float(Curve::from_linear(0.0, 1.0, 0.0, 1.0)),
+        );
+        assert_eq!(clip.duration(), 1.0);
+        clip.add_animated_prop(
+            "/Root/Ball@Transform.translate.x",
+            CurveUntyped::Float(Curve::from_linear(0.0, 1.2, 0.0, 2.0)),
+        );
+        assert_eq!(clip.len(), 2);
+        assert_eq!(clip.duration(), 1.2);
+    }
+
+    #[test]
+    #[should_panic]
+    fn clip_nested_properties() {
+        // Maybe required by `bevy_reflect` this guarantees are necessary
+        // because the way we execute
+        let mut clip = Clip::default();
+        clip.add_animated_prop(
+            "/Root/Ball@Transform.translate",
+            CurveUntyped::Vec3(Curve::from_linear(0.0, 1.0, Vec3::zero(), Vec3::unit_y())),
+        );
+        clip.add_animated_prop(
+            "/Root/Ball@Transform.translate.x",
+            CurveUntyped::Float(Curve::from_linear(0.0, 1.2, 0.0, 2.0)),
+        );
+    }
+
     #[test]
     fn unhandled_properties_implementation_for_types() {
         // This is take as granted to simplify the function `Clip::add_animated_prop`
diff --git a/crates/bevy_animation/src/lerping.rs b/crates/bevy_animation/src/lerping.rs
index f5c449f7b84ae..ffa1fcf3b6bc4 100644
--- a/crates/bevy_animation/src/lerping.rs
+++ b/crates/bevy_animation/src/lerping.rs
@@ -31,19 +31,16 @@ impl LerpValue for Vec4 {
 }
 
 impl LerpValue for Quat {
-    /// Actually performs an nlerp, because it's much cheaper and easer to combine with other animations,
+    /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
     /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        // Make sure is always the short path
+        // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
         let mut b = *b;
         if a.dot(b) < 0.0 {
             b = -b;
         }
 
         Vec4::lerp((*a).into(), b.into(), t).normalize().into()
-
-        // ! NOTE: slerp is nice if you want to debug the animation code
-        // a.slerp(b, t)
     }
 }
 
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index e75b1f7a6b70b..68c71480aa66c 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -5,16 +5,16 @@ use bevy_type_registry::RegisterType;
 
 pub mod generic;
 pub mod lerping;
-mod skined_mesh;
+mod skinned_mesh;
 
 pub use crate::generic::*;
-pub use crate::skined_mesh::*;
+pub use crate::skinned_mesh::*;
 //mod util;
 
 pub mod prelude {
     pub use crate::generic::{Animator, Clip, Curve, CurveUntyped};
     pub use crate::lerping::LerpValue;
-    pub use crate::skined_mesh::{MeshSkin, MeshSkinBinder, MeshSkinnerDebuger};
+    pub use crate::skinned_mesh::{MeshSkin, MeshSkinBinder, MeshSkinnerDebugger};
 }
 
 pub mod stage {
@@ -40,7 +40,7 @@ impl Plugin for AnimationPlugin {
         // Skinning
         app.add_asset::<MeshSkin>()
             .register_component_with::<MeshSkinBinder>(|reg| reg.map_entities())
-            .register_component::<MeshSkinnerDebuger>()
+            .register_component::<MeshSkinnerDebugger>()
             .add_system_to_stage(stage::POST_UPDATE, mesh_skinner_debugger_update)
             .add_system_to_stage(stage::ANIMATE, mesh_skinner_startup);
     }
diff --git a/crates/bevy_animation/src/skined_mesh.rs b/crates/bevy_animation/src/skinned_mesh.rs
similarity index 73%
rename from crates/bevy_animation/src/skined_mesh.rs
rename to crates/bevy_animation/src/skinned_mesh.rs
index 5c3dd6f9e0407..bd221b63ee004 100644
--- a/crates/bevy_animation/src/skined_mesh.rs
+++ b/crates/bevy_animation/src/skinned_mesh.rs
@@ -17,7 +17,7 @@ use smallvec::SmallVec;
 #[uuid = "129d54f5-4ee7-456f-9340-32e71469cdaf"]
 pub struct MeshSkin {
     pub inverse_bind_matrices: Vec<Mat4>,
-    pub bones_names: Vec<String>,
+    pub bones_names: Vec<String>, // TODO: Use the Name component instead
     /// Each bone as an entry that specifies their parent bone, maybe used to reconstruct
     /// the bone hierarchy when missing
     pub bones_parents: Vec<Option<usize>>,
@@ -147,103 +147,10 @@ pub(crate) fn mesh_skinner_startup(
     }
 }
 
-// TODO: MeshSkinBinder system
-// fn mesh_skin_binder_update() {
-//     // TODO: have to send the matrices into each entity
-// }
-
-///////////////////////////////////////////////////////////////////////////////
-
-// TODO: Should I implement a SkeletalAnimator for better performance for mesh animations
-// // Similar to Animator but only works for transforms
-// pub struct SkeletalAnimator {}
-
-// pub(crate) fn skeletal_animator_update(
-//     time: Res<Time>,
-//     // keyboard: Res<Input<KeyCode>>,
-//     clips: Res<Assets<Clip>>,
-//     mut animators_query: Query<(Mut<Animator>,)>,
-//     mut transforms_query: Query<(Mut<Transform>,)>,
-// ) {
-//     // let delta_time = if keyboard.just_pressed(KeyCode::Right) {
-//     //     1.0 / 60.0
-//     // } else {
-//     //     0.0
-//     // };
-
-//     let delta_time = time.delta_seconds;
-
-//     for (mut debugger,) in animators_query.iter_mut() {
-//         let debugger = debugger.deref_mut();
-
-//         if !debugger.builded {
-//             return;
-//         }
-
-//         // Time scales by component
-//         let delta_time = delta_time * debugger.time_scale;
-
-//         // Ensure capacity for cached keyframe index vec
-//         let nodes_count = debugger.hierarchy.len();
-//         if debugger.current.keyframe.len() != nodes_count {
-//             debugger.current.keyframe.clear();
-//             debugger
-//                 .current
-//                 .keyframe
-//                 .resize_with(nodes_count, || Default::default());
-//         }
-
-//         if let Some(clip) = clips.get(&debugger.clip) {
-//             // Update time
-//             let mut time = debugger.current.time + delta_time;
-
-//             // Warp mode
-//             if clip.warp {
-//                 // Warp Around
-//                 if time > clip.length {
-//                     time = (time / clip.length).fract() * clip.length;
-//                     // Reset all keyframes cached indexes
-//                     debugger
-//                         .current
-//                         .keyframe
-//                         .iter_mut()
-//                         .for_each(|x| *x = Default::default())
-//                 }
-//             } else {
-//                 // Hold
-//                 time = time.min(clip.length);
-//             }
-
-//             // Advance state time
-//             debugger.current.time = time;
-
-//             for (i, entity) in debugger.hierarchy.iter().enumerate() {
-//                 if let Ok((mut transform,)) = transforms_query.get_mut(*entity) {
-//                     // Get cached keyframe info
-//                     let keyframe = &mut debugger.current.keyframe[i];
-
-//                     // Sample animation
-//                     let (k, v) = clip.bones[i].position.sample(keyframe.position, time);
-//                     keyframe.position = k;
-//                     transform.translation = v;
-
-//                     let (k, v) = clip.bones[i].rotation.sample(keyframe.rotation, time);
-//                     keyframe.rotation = k;
-//                     transform.rotation = v;
-
-//                     let (k, v) = clip.bones[i].scale.sample(keyframe.scale, time);
-//                     keyframe.scale = k;
-//                     transform.scale = v;
-//                 }
-//             }
-//         }
-//     }
-// }
-
 ///////////////////////////////////////////////////////////////////////////////
 
 #[derive(Default, Debug, Properties)]
-pub struct MeshSkinnerDebuger {
+pub struct MeshSkinnerDebugger {
     //pub enabled: bool,
     #[property(ignore)]
     started: bool,
@@ -257,7 +164,7 @@ pub(crate) fn mesh_skinner_debugger_update(
     commands: &mut Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     skins: Res<Assets<MeshSkin>>,
-    mut debugger_query: Query<(&Handle<MeshSkin>, &MeshSkinBinder, &mut MeshSkinnerDebuger)>,
+    mut debugger_query: Query<(&Handle<MeshSkin>, &MeshSkinBinder, &mut MeshSkinnerDebugger)>,
     bones_query: Query<(&GlobalTransform,)>,
 ) {
     for (skin_handle, skinner, mut debugger) in debugger_query.iter_mut() {
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 2a9b7c17860e0..9dae0010dc80c 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -416,7 +416,7 @@ fn load_node(
             entity_lookup[skeleton_root].expect("missing skeleton root entity"),
         ));
 
-        world_builder.with(MeshSkinnerDebuger::default());
+        world_builder.with(MeshSkinnerDebugger::default());
     }
 
     // create camera node

From 71ed2d64e159c25f107b5d05cdb21f17b917d63b Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Fri, 27 Nov 2020 18:57:38 -0300
Subject: [PATCH 019/153] bench + optimizations

---
 crates/bevy_animation/Cargo.toml          |  15 +-
 crates/bevy_animation/benches/animator.rs | 164 ++++++++++++++++++
 crates/bevy_animation/src/generic.rs      | 197 ++++++++++++++++++----
 crates/bevy_core/src/name.rs              |  27 ++-
 4 files changed, 365 insertions(+), 38 deletions(-)
 create mode 100644 crates/bevy_animation/benches/animator.rs

diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index 5bbe5d66e6653..1355205989f7b 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -14,7 +14,7 @@ bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
 bevy_pbr = { path = "../bevy_pbr", version = "0.3.0" }
 bevy_math = { path = "../bevy_math", version = "0.3.0" }
 bevy_render = { path = "../bevy_render", version = "0.3.0" }
-#bevy_tasks = { path = "../bevy_tasks", version = "0.3.0" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.3.0" }
 bevy_transform = { path = "../bevy_transform", version = "0.3.0" }
 bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
 bevy_property = { path = "../bevy_property", version = "0.3.0" }
@@ -24,4 +24,15 @@ serde = { version = "1.0", features = ["derive"] }
 smallvec = { version = "1.4", features = ["serde"] }
 anyhow = "1.0"
 float-cmp = "0.8.0"
-tracing = { version = "0.1.21", features = ["attributes"] }
\ No newline at end of file
+fnv = "1.0.7"
+tracing = { version = "0.1.21", features = ["attributes"] }
+
+[dev-dependencies]
+criterion = "0.3.3"
+
+[profile.release]
+debug = true
+
+[[bench]]
+name = "animator"
+harness = false
\ No newline at end of file
diff --git a/crates/bevy_animation/benches/animator.rs b/crates/bevy_animation/benches/animator.rs
new file mode 100644
index 0000000000000..c4be18fda7307
--- /dev/null
+++ b/crates/bevy_animation/benches/animator.rs
@@ -0,0 +1,164 @@
+use bevy_animation::prelude::*;
+use bevy_asset::prelude::*;
+use bevy_core::prelude::*;
+use bevy_ecs::prelude::*;
+use bevy_math::prelude::*;
+use bevy_transform::prelude::*;
+use core::time::Duration;
+
+use criterion::{
+    black_box, criterion_group, criterion_main, BatchSize, Criterion, ParameterizedBenchmark,
+};
+
+const LEN: usize = 100_000;
+const TICKS: usize = 100_000;
+const WARM_UP_TIME: Duration = Duration::from_secs(5);
+const MEASUREMENT_TIME: Duration = Duration::from_secs(55);
+
+fn criterion_benchmark(c: &mut Criterion) {
+    c.bench(
+        "animator",
+        ParameterizedBenchmark::new(
+            "update",
+            |b, _| {
+                b.iter_batched(
+                    || AnimtorTestBench::new(),
+                    |mut value| black_box(value.update(black_box(TICKS))),
+                    BatchSize::NumIterations(LEN as u64),
+                )
+            },
+            vec![()],
+        )
+        .warm_up_time(WARM_UP_TIME)
+        .measurement_time(MEASUREMENT_TIME),
+    );
+}
+
+struct AnimtorTestBench {
+    app: bevy_app::App,
+    //binding_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>>,
+    update_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>>,
+}
+
+impl AnimtorTestBench {
+    fn new() -> Self {
+        let mut app_builder = bevy_app::App::build();
+        app_builder
+            .add_plugin(bevy_type_registry::TypeRegistryPlugin::default())
+            .add_plugin(bevy_core::CorePlugin::default())
+            .add_plugin(bevy_app::ScheduleRunnerPlugin::default())
+            .add_plugin(bevy_asset::AssetPlugin)
+            .add_plugin(bevy_transform::TransformPlugin)
+            .add_plugin(bevy_animation::AnimationPlugin);
+
+        let mut world = World::new();
+        let mut world_builder = world.build();
+        let base = (
+            GlobalTransform::default(),
+            Transform::from_translation(Vec3::new(0.0, 1.0, 0.0)),
+        );
+
+        // Create animator and assign some clips
+        let mut animator = Animator::default();
+        {
+            let mut clip_a = Clip::default();
+            clip_a.add_animated_prop(
+                "@Transform.translation",
+                CurveUntyped::Vec3(Curve::from_linear(
+                    0.0,
+                    1.0,
+                    Vec3::unit_x(),
+                    -Vec3::unit_x(),
+                )),
+            );
+            let rot = CurveUntyped::Quat(Curve::from_constant(Quat::identity()));
+            clip_a.add_animated_prop("@Transform.rotation", rot.clone());
+            clip_a.add_animated_prop("/Hode1@Transform.rotation", rot.clone());
+            clip_a.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
+
+            let mut clip_b = Clip::default();
+            clip_b.add_animated_prop(
+                "@Transform.translation",
+                CurveUntyped::Vec3(Curve::from_constant(Vec3::zero())),
+            );
+            let rot = CurveUntyped::Quat(Curve::from_linear(
+                0.0,
+                1.0,
+                Quat::from_axis_angle(Vec3::unit_z(), 0.1),
+                Quat::from_axis_angle(Vec3::unit_z(), -0.1),
+            ));
+            clip_b.add_animated_prop("@Transform.rotation", rot.clone());
+            clip_b.add_animated_prop("/Hode1@Transform.rotation", rot.clone());
+            clip_b.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
+
+            let mut clips = app_builder
+                .resources_mut()
+                .get_mut::<Assets<Clip>>()
+                .unwrap();
+            let clip_a = clips.add(clip_a);
+            let clip_b = clips.add(clip_b);
+
+            animator.add_layer(clip_a, 0.5);
+            animator.add_layer(clip_b, 0.5);
+        }
+
+        world_builder
+            .spawn(base.clone())
+            .with(Name::from_str("Root"))
+            .with(animator)
+            .with_children(|world_builder| {
+                world_builder
+                    .spawn(base.clone())
+                    .with(Name::from_str("Node1"))
+                    .with_children(|world_builder| {
+                        world_builder
+                            .spawn(base.clone())
+                            .with(Name::from_str("Node2"))
+                            .with_children(|world_builder| {
+                                world_builder
+                                    .spawn(base.clone())
+                                    .with(Name::from_str("Node3"));
+                            });
+                    });
+            });
+
+        app_builder.set_world(world);
+
+        // let mut parent_update_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>> =
+        //     Box::new(bevy_transform::hierarchy::parent_update_system.system());
+
+        let mut binding_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>> =
+            Box::new(bevy_animation::animator_binding_system.system());
+
+        let update_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>> =
+            Box::new(bevy_animation::animator_update_system.system());
+
+        let mut app = app_builder.app;
+
+        //parent_update_system.run((), &mut app.world, &mut app.resources);
+        binding_system.run_thread_local(&mut app.world, &mut app.resources);
+
+        Self { app, update_system }
+    }
+
+    fn update(&mut self, ticks: usize) {
+        for _ in 0..ticks {
+            // Time tick
+            {
+                let mut time = self.app.resources.get_mut::<Time>().unwrap();
+                time.delta_seconds += 0.016;
+                time.delta_seconds_f64 += 0.016;
+            }
+
+            black_box(
+                self.update_system
+                    .run_thread_local(&mut self.app.world, &mut self.app.resources),
+            );
+
+            //dbg!(app.world.get::<Transform>(root_entity).unwrap());
+        }
+    }
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 444633f4e7a19..ce158eb60f4cf 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -10,9 +10,10 @@ use bevy_transform::prelude::*;
 use bevy_type_registry::{TypeRegistry, TypeUuid};
 use std::collections::HashSet;
 //use serde::{Deserialize, Serialize};
+use std::any::TypeId;
 use std::convert::TryFrom;
+use std::hash::Hash;
 use std::ptr::null_mut;
-use std::{any::TypeId, hash::Hash};
 
 use super::lerping::LerpValue;
 
@@ -86,14 +87,14 @@ impl Clip {
             } else {
                 // Add entity
                 let e = self.entities.len();
-                self.entities.push((entity, Name::new(name.to_string())));
+                self.entities.push((entity, Name::from_str(name)));
                 entity_created = true;
                 // Soft limit added to save memory, identical to the curve limit
                 entity = u16::try_from(e).expect("entities limit reached");
             }
         }
 
-        let insert_attr = Name::new(path.1.split_at(1).1.to_string());
+        let insert_attr = Name::from_str(path.1.split_at(1).1);
 
         // If some entity was created it means this property is a new one
         if !entity_created {
@@ -223,6 +224,7 @@ macro_rules! untyped_fn {
 impl CurveUntyped {
     untyped_fn!(pub fn duration(&self,) -> f32);
     untyped_fn!(pub fn value_type(&self,) -> TypeId);
+    //untyped_fn!(pub fn add_time_offset(&mut self, time: f32,) -> ());
 
     pub fn add_time_offset(&mut self, time: f32) {
         match self {
@@ -285,6 +287,13 @@ where
         }
     }
 
+    pub fn from_constant(v: T) -> Self {
+        Self {
+            samples: vec![0.0],
+            values: vec![v],
+        }
+    }
+
     pub fn duration(&self) -> f32 {
         self.samples.last().copied().unwrap_or(0.0)
     }
@@ -402,6 +411,13 @@ pub struct Animator {
     // masks: Vec<Handle<ClipMask>>,
     // #[property(ignore)]
     // bind_masks: Vec<ClipMaskBind>,
+    /// Used to blend all the active layers, durning the frame update each pointers
+    /// can only be set once, by the second time then need to perform blended with the next layer
+    ///
+    // ? NOTE: We may need to change this approach when blending more than 2 layers
+    // ? NOTE: It takes more memory but it's faster than having a local resource with a big chunk of data or even allocating at every frame
+    #[property(ignore)]
+    visited: fnv::FnvHashSet<Ptr>,
     pub time_scale: f32,
     pub layers: Vec<Layer>,
 }
@@ -413,6 +429,7 @@ impl Default for Animator {
         Self {
             clips: vec![],
             bind_clips: vec![],
+            visited: fnv::FnvHashSet::default(),
             time_scale: 1.0,
             layers: vec![],
         }
@@ -489,23 +506,6 @@ struct Ptr(*mut u8);
 unsafe impl Send for Ptr {}
 unsafe impl Sync for Ptr {}
 
-// /// Hash and equality by pointer not the value it self
-// struct HashPtr<'a, T>(&'a mut T);
-
-// impl<'a, T> Hash for HashPtr<'a, T> {
-//     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-//         (self.0 as *const T).hash(state);
-//     }
-// }
-
-// impl<'a, T> PartialEq for HashPtr<'a, T> {
-//     fn eq(&self, other: &Self) -> bool {
-//         (self.0 as *const T) == (other.0 as *const T)
-//     }
-// }
-
-// impl<'a, T> Eq for HashPtr<'a, T> {}
-
 /// Marker type for missing component
 struct MissingComponentMarker;
 
@@ -516,9 +516,10 @@ struct ClipResourceProviderState {
 
 // TODO: Refactor in hope to reuse more code (maybe just create more functions)
 #[tracing::instrument(skip(world, resources))]
-pub(crate) fn animator_binding_system(world: &mut World, resources: &mut Resources) {
+pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
     let system_id = SystemId(0); // ? NOTE: shouldn't be required to match the system id
 
+    // TODO: These local resources seams to be quite slow, maybe I need a random system id?
     // Fetch resources
     let mut state = {
         let state = resources.get_local_mut::<ClipResourceProviderState>(system_id);
@@ -891,7 +892,7 @@ fn find_property_ptr<'a, P: Iterator<Item = &'a str>>(
 }
 
 #[tracing::instrument(skip(world, resources))]
-pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resources) {
+pub fn animator_update_system(world: &mut World, resources: &mut Resources) {
     /// Small value
     const SMOL: f32 = 1e-8;
 
@@ -902,10 +903,6 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
     let animators_query = unsafe { world.query_unchecked::<(&mut Animator,), ()>() };
     let delta_time = time.delta_seconds;
 
-    // TODO: Warp in a tread_local! to parallelize the property lerping
-    // NOTE: Allocate a big chunk where to avoid doing any extra allocations during the property lerp
-    let mut visited = HashSet::with_capacity(1069);
-
     // ? NOTE: Keep in mind that one hierarchy tree could have many `Animator`s thus
     // ? we can't parallelize over the animators easily without creating a race condition
     for (mut animator,) in animators_query {
@@ -926,7 +923,7 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
             layer.weight *= norm;
         }
 
-        visited.clear();
+        animator.visited.clear();
         for layer in &mut animator.layers {
             let w = layer.weight;
             if w < SMOL {
@@ -977,7 +974,7 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
                     // Advance state time
                     layer.time = time;
 
-                    // TODO: can be done in bached_parallel when visited warped inside a thread_local!
+                    // TODO: can be done in bached_parallel if is visited warped inside a mutex
                     for ((ptr, keyframe), curve_index) in bind
                         .attributes
                         .iter()
@@ -991,10 +988,10 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
 
                         let curve = &clip.curves[*curve_index as usize];
 
-                        let viz = if visited.contains(&ptr.0) {
+                        let viz = if animator.visited.contains(&ptr) {
                             true
                         } else {
-                            visited.insert(ptr.0);
+                            animator.visited.insert(*ptr);
                             false
                         };
 
@@ -1050,8 +1047,10 @@ pub(crate) fn animator_update_system(world: &mut World, resources: &mut Resource
                                 unsafe {
                                     let ptr = ptr.0 as *mut Quat;
                                     if viz {
-                                        // ? NOTE: Blending two clips no matter the order
-                                        // ? should give the same results, so nlerp must be used
+                                        // ? NOTE: Always nlerp, because blending the same clips in different order must yield the same results
+                                        // ! NOTE: This now one of (if not) the most expensive thing been executed in the animator_update_system
+                                        // ! blending more layers will increase the cost, change this behavior will result in change of the final motion
+                                        // ! in unexpected ways (maybe not by much but still)
                                         *ptr = LerpValue::lerp(&*ptr, &v, w);
                                     } else {
                                         *ptr = v;
@@ -1243,4 +1242,138 @@ mod tests {
     // TODO: Add tests for animated handle (impl missing)
     // TODO: Add tests for animated asset properties (impl missing)
     // TODO: Add tests for animated components should trigger 'Mutated' queries filters (impl missing)
+
+    struct AnimtorTestBench {
+        app: bevy_app::App,
+        //binding_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>>,
+        update_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>>,
+    }
+
+    impl AnimtorTestBench {
+        fn new() -> Self {
+            let mut app_builder = bevy_app::App::build();
+            app_builder
+                .add_plugin(bevy_type_registry::TypeRegistryPlugin::default())
+                .add_plugin(bevy_core::CorePlugin::default())
+                .add_plugin(bevy_app::ScheduleRunnerPlugin::default())
+                .add_plugin(bevy_asset::AssetPlugin)
+                .add_plugin(bevy_transform::TransformPlugin)
+                .add_plugin(crate::AnimationPlugin);
+
+            let mut world = World::new();
+            let mut world_builder = world.build();
+            let base = (
+                GlobalTransform::default(),
+                Transform::from_translation(Vec3::new(0.0, 1.0, 0.0)),
+            );
+
+            // Create animator and assign some clips
+            let mut animator = Animator::default();
+            {
+                let mut clip_a = Clip::default();
+                clip_a.add_animated_prop(
+                    "@Transform.translation",
+                    CurveUntyped::Vec3(Curve::from_linear(
+                        0.0,
+                        1.0,
+                        Vec3::unit_x(),
+                        -Vec3::unit_x(),
+                    )),
+                );
+                let rot = CurveUntyped::Quat(Curve::from_constant(Quat::identity()));
+                clip_a.add_animated_prop("@Transform.rotation", rot.clone());
+                clip_a.add_animated_prop("/Hode1@Transform.rotation", rot.clone());
+                clip_a.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
+
+                let mut clip_b = Clip::default();
+                clip_b.add_animated_prop(
+                    "@Transform.translation",
+                    CurveUntyped::Vec3(Curve::from_constant(Vec3::zero())),
+                );
+                let rot = CurveUntyped::Quat(Curve::from_linear(
+                    0.0,
+                    1.0,
+                    Quat::from_axis_angle(Vec3::unit_z(), 0.1),
+                    Quat::from_axis_angle(Vec3::unit_z(), -0.1),
+                ));
+                clip_b.add_animated_prop("@Transform.rotation", rot.clone());
+                clip_b.add_animated_prop("/Hode1@Transform.rotation", rot.clone());
+                clip_b.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
+
+                let mut clips = app_builder
+                    .resources_mut()
+                    .get_mut::<Assets<Clip>>()
+                    .unwrap();
+                let clip_a = clips.add(clip_a);
+                let clip_b = clips.add(clip_b);
+
+                animator.add_layer(clip_a, 0.5);
+                animator.add_layer(clip_b, 0.5);
+            }
+
+            world_builder
+                .spawn(base.clone())
+                .with(Name::from_str("Root"))
+                .with(animator)
+                .with_children(|world_builder| {
+                    world_builder
+                        .spawn(base.clone())
+                        .with(Name::from_str("Node1"))
+                        .with_children(|world_builder| {
+                            world_builder
+                                .spawn(base.clone())
+                                .with(Name::from_str("Node2"))
+                                .with_children(|world_builder| {
+                                    world_builder
+                                        .spawn(base.clone())
+                                        .with(Name::from_str("Node3"));
+                                });
+                        });
+                });
+
+            app_builder.set_world(world);
+
+            // let mut parent_update_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>> =
+            //     Box::new(bevy_transform::hierarchy::parent_update_system.system());
+
+            let mut binding_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>> =
+                Box::new(crate::animator_binding_system.system());
+
+            let update_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>> =
+                Box::new(crate::animator_update_system.system());
+
+            let mut app = app_builder.app;
+
+            //parent_update_system.run((), &mut app.world, &mut app.resources);
+            binding_system.run_thread_local(&mut app.world, &mut app.resources);
+
+            Self { app, update_system }
+        }
+
+        fn update(&mut self, ticks: usize) {
+            for _ in 0..ticks {
+                // Time tick
+                {
+                    let mut time = self.app.resources.get_mut::<Time>().unwrap();
+                    time.delta_seconds += 0.016;
+                    time.delta_seconds_f64 += 0.016;
+                }
+
+                self.update_system
+                    .run_thread_local(&mut self.app.world, &mut self.app.resources);
+
+                //dbg!(app.world.get::<Transform>(root_entity).unwrap());
+            }
+        }
+    }
+
+    #[test]
+    fn test_bench_update() {
+        // ? NOTE: Mimics a basic system update behavior good for pref since criterion will pollute the
+        // ? annotations with many expensive instructions
+        let mut a = AnimtorTestBench::new();
+        a.update(1_000_000);
+    }
+
+    // TODO: 5 layers or more ...
 }
diff --git a/crates/bevy_core/src/name.rs b/crates/bevy_core/src/name.rs
index 0545df02c341a..79ff54d60c8c0 100644
--- a/crates/bevy_core/src/name.rs
+++ b/crates/bevy_core/src/name.rs
@@ -25,16 +25,35 @@ impl Default for Name {
 
 impl Name {
     pub fn new(name: String) -> Self {
-        let mut hasher = DefaultHasher::default();
-        name.hash(&mut hasher);
-        let hash = hasher.finish();
+        let mut name = Name { name, hash: 0 };
+        name.update_hash();
+        name
+    }
 
-        Name { name, hash }
+    #[inline(always)]
+    pub fn from_str(name: &str) -> Self {
+        Name::new(name.to_owned())
+    }
+
+    #[inline(always)]
+    pub fn set(&mut self, name: String) {
+        *self = Name::new(name);
+    }
+
+    pub fn mutate<F: FnOnce(&mut String)>(&mut self, f: F) {
+        f(&mut self.name);
+        self.update_hash();
     }
 
     pub fn as_str(&self) -> &str {
         self.name.as_str()
     }
+
+    fn update_hash(&mut self) {
+        let mut hasher = DefaultHasher::default();
+        self.name.hash(&mut hasher);
+        self.hash = hasher.finish();
+    }
 }
 
 impl Hash for Name {

From 7aa7d69f25fdca3b4941dd79b3a8351e0533c4cd Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sat, 28 Nov 2020 21:42:20 -0300
Subject: [PATCH 020/153] binding rewrite, support for rebind attrs +
 NamedHierarchy

---
 crates/bevy_animation/Cargo.toml       |   2 +-
 crates/bevy_animation/src/generic.rs   | 696 ++++++++++++-------------
 crates/bevy_animation/src/hierarchy.rs | 199 +++++++
 crates/bevy_animation/src/lib.rs       |   3 +-
 4 files changed, 528 insertions(+), 372 deletions(-)
 create mode 100644 crates/bevy_animation/src/hierarchy.rs

diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index 1355205989f7b..e473e621487e0 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -19,7 +19,7 @@ bevy_transform = { path = "../bevy_transform", version = "0.3.0" }
 bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
 bevy_property = { path = "../bevy_property", version = "0.3.0" }
 
-# # other
+# other
 serde = { version = "1.0", features = ["derive"] }
 smallvec = { version = "1.4", features = ["serde"] }
 anyhow = "1.0"
diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index ce158eb60f4cf..1378e01300fd1 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -8,13 +8,12 @@ use bevy_math::prelude::*;
 use bevy_property::{Properties, Property, PropertyType};
 use bevy_transform::prelude::*;
 use bevy_type_registry::{TypeRegistry, TypeUuid};
-use std::collections::HashSet;
 //use serde::{Deserialize, Serialize};
 use std::any::TypeId;
-use std::convert::TryFrom;
 use std::hash::Hash;
 use std::ptr::null_mut;
 
+use super::hierarchy::NamedHierarchy;
 use super::lerping::LerpValue;
 
 // TODO: Curve/Clip need a validation during deserialization because they are
@@ -28,7 +27,7 @@ pub struct Clip {
     pub warp: bool,
     duration: f32,
     /// Entity identification made by parent index and name
-    entities: Vec<(u16, Name)>,
+    hierarchy: NamedHierarchy,
     /// Attribute is made by the entity index and a string that combines
     /// component name followed by their attributes spaced by a period,
     /// like so: `"Transform.translation.x"`
@@ -46,7 +45,7 @@ impl Default for Clip {
             warp: true,
             duration: 0.0,
             // ? NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
-            entities: vec![(u16::MAX, Name::default())],
+            hierarchy: NamedHierarchy::default(),
             attribute: vec![],
             curves: vec![],
         }
@@ -68,46 +67,19 @@ impl Clip {
         let path =
             property_path.split_at(property_path.rfind('@').expect("property path missing @"));
 
-        // TODO: Prepare for bevy_reflect
-        let mut entity_created = false;
-        let mut entity = 0; // Start search from root
-        for name in path.0.split('/') {
-            // Ignore the first '/' or '///'
-            if name.is_empty() {
-                continue;
-            }
-
-            if let Some(e) = self
-                .entities
-                .iter()
-                .position(|(p, n)| (*p, n.as_str()) == (entity, name))
-            {
-                // Found entity
-                entity = e as u16;
-            } else {
-                // Add entity
-                let e = self.entities.len();
-                self.entities.push((entity, Name::from_str(name)));
-                entity_created = true;
-                // Soft limit added to save memory, identical to the curve limit
-                entity = u16::try_from(e).expect("entities limit reached");
-            }
-        }
+        let (entity, entity_created) = self.hierarchy.get_or_insert_entity(path.0);
 
         let insert_attr = Name::from_str(path.1.split_at(1).1);
 
-        // If some entity was created it means this property is a new one
+        // If some entity was created it means this property is a new one so we can safely skip the attribute testing
         if !entity_created {
             for (i, attr) in self.attribute.iter().enumerate() {
                 if attr.0 != entity {
                     continue;
                 }
 
-                // NOTE: "...@Transform.translation" and "...@Transform.translation.x" can't live with each other
-                // but since Properties aren't implemented for f32, Vec2, Vec3, Vec4 and Quat
-                // (all relevant animated type values) the check rule could be simplified (a lot)
-                //
-                // The test case `test::unhandled_properties_implementation_for_types` will ensure that
+                // TODO: Prepare for bevy_reflect
+                // TODO: "...@Transform.translation" and "...@Transform.translation.x" can't live with each other
 
                 if insert_attr == attr.1 {
                     // Found a property are equal the one been inserted
@@ -140,22 +112,14 @@ impl Clip {
     /// The clip stores a property path in a specific way to improve search performance
     /// thus it needs to rebuilt the curve property path in the human readable format
     pub fn get_property_path(&self, index: u16) -> String {
-        let (entity, name) = &self.attribute[index as usize];
-        let mut path = format!("@{}", name.as_str());
-
-        let mut first = true;
-        let mut entity = *entity;
-        while let Some((parent, name)) = self.entities.get(entity as usize) {
-            if first {
-                path = format!("{}{}", name.as_str(), path);
-                first = false;
-            } else {
-                path = format!("{}/{}", name.as_str(), path);
-            }
-            entity = *parent;
-        }
-
-        path
+        let (entity_index, name) = &self.attribute[index as usize];
+        format!(
+            "{}@{}",
+            self.hierarchy
+                .get_entity_path_at(*entity_index)
+                .expect("property as an invalid entity"),
+            name.as_str()
+        )
     }
 
     /// Clip duration
@@ -470,31 +434,23 @@ impl Animator {
 // direct pointers
 
 #[derive(Debug)]
-struct ClipBindMetadataInner {
+struct ClipBindEntity {
     parent: Option<Entity>,
     entity: Entity,
     location: Location,
-    component: TypeId,
-}
-
-/// Metadata is used to check the bind validity
-#[derive(Debug)]
-struct ClipBindMetadata {
-    entity_index: u16,
-    inner: Option<ClipBindMetadataInner>,
-    range: (u16, u16),
 }
 
 #[derive(Debug)]
 struct ClipBind {
-    metadata: Vec<ClipBindMetadata>,
-    curves: Vec<u16>,
+    entities: Vec<Option<ClipBindEntity>>,
+    /// True only when all the attributes are binded
+    all_binded: bool,
+    /// Attributes pointers
     attributes: Vec<Ptr>,
 }
 
 // #[derive(Debug)]
 // struct ClipMaskBind {
-//     metadata: Vec<(Option<Entity>, Entity)>
 //     allowed_entities: HashMap<Entity>,
 // }
 
@@ -506,20 +462,29 @@ struct Ptr(*mut u8);
 unsafe impl Send for Ptr {}
 unsafe impl Sync for Ptr {}
 
-/// Marker type for missing component
-struct MissingComponentMarker;
+// /// Marker type for missing component
+// struct MissingComponentMarker;
 
+/// State info for the system `animator_binding_system`
 #[derive(Default)]
 struct ClipResourceProviderState {
     clip_event_reader: EventReader<AssetEvent<Clip>>,
+    modified: fnv::FnvHashSet<Handle<Clip>>,
+}
+
+/// Creates a new vector with a given size filled with the values returned by the given default function
+#[inline(always)]
+fn vec_filled<T, F: Fn() -> T>(size: usize, default: F) -> Vec<T> {
+    let mut v = vec![];
+    v.resize_with(size, default);
+    v
 }
 
-// TODO: Refactor in hope to reuse more code (maybe just create more functions)
 #[tracing::instrument(skip(world, resources))]
 pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
     let system_id = SystemId(0); // ? NOTE: shouldn't be required to match the system id
 
-    // TODO: These local resources seams to be quite slow, maybe I need a random system id?
+    // ! FIXME: These local resources seams to be quite slow, maybe I need a random system id?
     // Fetch resources
     let mut state = {
         let state = resources.get_local_mut::<ClipResourceProviderState>(system_id);
@@ -546,11 +511,11 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
 
     // ? NOTE: Changing a clip on fly is supported, but very expensive so use with caution
     // Query all clips that changed and remove their binds from the animator
-    let mut modified = HashSet::new();
+    state.modified.clear();
     for event in state.clip_event_reader.iter(&clip_events) {
         match event {
-            AssetEvent::Removed { handle } => modified.insert(handle),
-            AssetEvent::Modified { handle } => modified.insert(handle),
+            AssetEvent::Removed { handle } => state.modified.insert(handle.clone()),
+            AssetEvent::Modified { handle } => state.modified.insert(handle.clone()),
             _ => false,
         };
     }
@@ -568,269 +533,170 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
 
         for (clip_handle, bind) in animator.clips.iter().zip(animator.bind_clips.iter_mut()) {
             // Invalidate binds for clips that where modified
-            if modified.contains(clip_handle) {
+            if state.modified.contains(clip_handle) {
                 *bind = None;
             }
 
-            if let Some(clip) = clips.get(clip_handle) {
-                // Prepare the entities table cache
-                entities_table_cache.clear();
-                entities_table_cache.resize(clip.entities.len(), None);
-                // Assign the root entity as the first element
-                entities_table_cache[0] = Some(root);
-
-                if bind.is_none() {
-                    // Build binds from scratch
-                    // Allocate the minium enough of memory on right at the begin
-                    let mut b = ClipBind {
-                        metadata: Vec::with_capacity(clip.entities.len()),
-                        curves: Vec::with_capacity(clip.attribute.len()),
-                        attributes: Vec::with_capacity(clip.attribute.len()),
-                    };
-
-                    let mut range = (0, 0);
-                    let mut prev_partial_info = None;
-                    let mut prev_component = TypeId::of::<MissingComponentMarker>();
-                    let mut prev_component_short_name = "";
-
-                    for (curve_index, (entity_index, attr_path)) in
-                        clip.attribute.iter().enumerate()
-                    {
-                        let mut commit = false;
-                        let mut partial_info = None;
-                        let mut component = TypeId::of::<MissingComponentMarker>();
-
-                        // Query component by name
-                        let mut path = attr_path.split('.');
-                        let component_short_name =
-                            path.next().expect("missing component short name");
-
-                        if let Some(entity) = find_entity(
-                            *entity_index,
-                            &clip.entities,
-                            &mut entities_table_cache,
-                            &world,
-                        ) {
-                            let location = world.get_entity_location(entity).unwrap();
-
-                            // Commit is needed
-                            partial_info = Some((entity, location));
-                            if prev_partial_info != partial_info {
-                                commit = true;
-                            }
+            let clip = clips.get(clip_handle);
+            if clip.is_none() {
+                // Clip missing, invalidate binds if any
+                *bind = None;
+                continue;
+            }
 
-                            if let Some(component_reg) =
-                                type_registry_read_guard.get_with_short_name(component_short_name)
-                            {
-                                component = component_reg.ty;
-
-                                let root_props = component_reg.get_component_properties(
-                                    &world.archetypes[location.archetype as usize],
-                                    location.index,
-                                );
-
-                                b.curves.push(curve_index as u16);
-                                b.attributes.push(find_property_ptr(
-                                    path,
-                                    root_props,
-                                    clip.curves[curve_index].value_type(),
-                                ));
-
-                                // Group by component type
-                                commit |= prev_component != component;
+            // Unwraps the clip
+            let clip = clip.unwrap();
+
+            // Prepare the entities table cache
+            entities_table_cache.clear();
+            entities_table_cache.resize(clip.hierarchy.len(), None);
+            // Assign the root entity as the first element
+            entities_table_cache[0] = Some(root);
+
+            let bind = if let Some(bind) = bind.as_mut() {
+                // Invalidate previously binded attributes
+
+                let done = &mut bind.all_binded;
+                let attrs = &mut bind.attributes;
+
+                bind.entities
+                    .iter_mut()
+                    .enumerate()
+                    // Find entities that changed
+                    .filter(|(entity_index, entry)| {
+                        if entry.is_none() {
+                            // Already invalid
+                            return false;
+                        }
+                        let inner = entry.as_ref().unwrap();
+
+                        // Not root
+                        if *entity_index > 0 {
+                            if let Ok(Parent(parent)) = world.query_one::<&Parent>(inner.entity) {
+                                // Parent changed
+                                if inner.parent != Some(*parent) {
+                                    return true;
+                                }
                             } else {
-                                // Missing component
-                                b.curves.push(curve_index as u16);
-                                b.attributes.push(Ptr(null_mut()));
+                                // Parent removed
+                                return true;
+                            }
+                        }
 
-                                // Group by component name
-                                commit |= prev_component_short_name != component_short_name;
+                        if let Some(loc) = world.get_entity_location(inner.entity) {
+                            if inner.location != loc {
+                                // Entity archetype changed
+                                return true;
                             }
                         } else {
-                            // Missing entity
-                            commit = prev_partial_info != partial_info;
-                            commit |= prev_component_short_name != component_short_name;
-
-                            b.curves.push(curve_index as u16);
-                            b.attributes.push(Ptr(null_mut()));
+                            // Entity deleted
+                            return true;
                         }
 
-                        if commit {
-                            // Close range
-                            range.1 = b.curves.len() as u16 - 1;
-
-                            // Commit meta
-                            b.metadata.push(ClipBindMetadata {
-                                entity_index: *entity_index,
-                                inner: prev_partial_info.map(|(entity, location)| {
-                                    ClipBindMetadataInner {
-                                        // An entity will always have parent unless is the root entity
-                                        parent: entities_table_cache
-                                            .get(clip.entities[*entity_index as usize].0 as usize)
-                                            .copied()
-                                            .flatten(),
-                                        entity,
-                                        location,
-                                        component,
-                                    }
-                                }),
-                                range,
-                            });
-
-                            // Jump to the next range
-                            prev_partial_info = partial_info;
-                            prev_component = component;
-                            prev_component_short_name = component_short_name;
-                            range.0 = range.1;
-                            range.1 += 1;
+                        // Entity didn't change
+                        false
+                    })
+                    // Invalidate all entities that changed
+                    .for_each(|(entity_index, entry)| {
+                        *entry = None;
+                        // ? NOTE: Will only run if the bind was invalidated in this frame
+                        for (descriptor, attr) in clip.attribute.iter().zip(attrs.iter_mut()) {
+                            if descriptor.0 as usize == entity_index {
+                                *attr = Ptr(null_mut());
+                            }
                         }
-                    }
+                        *done = false;
+                    });
 
-                    *bind = Some(b);
+                bind
+            } else {
+                // Create empty binds
+                *bind = Some(ClipBind {
+                    entities: vec_filled(clip.hierarchy.len(), || None),
+                    all_binded: false,
+                    attributes: vec_filled(clip.attribute.len(), || Ptr(null_mut())),
+                });
 
-                    // No need to continue because binds are fresh
-                    continue;
-                }
+                bind.as_mut().unwrap()
+            };
 
-                // Check bind state and update the necessary parts
-                let bind = bind.as_mut().unwrap();
-                for meta in bind.metadata.iter_mut() {
-                    if meta.inner.is_none() {
-                        // TODO: Handle missing entity
-                        continue;
-                    }
+            // All attributes are binded
+            if bind.all_binded {
+                continue;
+            }
 
-                    let inner = meta.inner.as_mut().unwrap();
+            // Will be cleared if any attribute fail to bind
+            bind.all_binded = true;
 
-                    // Handle `Parent` changed
-                    if let Some(parent) = inner.parent {
-                        // Not root
-                        if let Ok(Parent(new_parent)) =
-                            world.query_one_filtered::<&Parent, Changed<Parent>>(inner.entity)
-                        {
-                            if parent != *new_parent {
-                                // TODO: Look again for the entity
-
-                                // Invalidate bind ...
-                                meta.inner = None;
-                                for i in (meta.range.0)..(meta.range.1) {
-                                    bind.attributes[i as usize] = Ptr(null_mut());
-                                }
-                                continue;
-                            }
-                        }
-                    }
+            // Bind attributes
+            for (attr_index, (attr, descriptor)) in bind
+                .attributes
+                .iter_mut()
+                .zip(clip.attribute.iter())
+                .enumerate()
+            {
+                let (entity_index, attr_path) = descriptor;
 
-                    let mut loc = world.get_entity_location(inner.entity);
-                    if loc.is_none() {
-                        // Missing entity
-                        if let Some(found_entity) = find_entity(
-                            meta.entity_index,
-                            &clip.entities,
-                            &mut entities_table_cache,
-                            &world,
-                        ) {
-                            // Found new entity
-                            inner.entity = found_entity;
-                            // Fetch it's location
-                            loc = world.get_entity_location(found_entity);
-                        } else {
-                            // Entity wasn't found, invalidate all the bind attributes
-                            meta.inner = None; // Clear inner data
-                            for i in (meta.range.0)..(meta.range.1) {
-                                bind.attributes[i as usize] = Ptr(null_mut());
-                            }
-                            continue;
-                        }
-                    }
+                if *attr != Ptr(null_mut()) {
+                    // Already binded
+                    continue;
+                }
 
-                    let loc = loc.unwrap();
-                    if inner.location == loc {
-                        // Nothing left todo
-                        continue;
-                    }
-                    if inner.component == TypeId::of::<MissingComponentMarker>() {
-                        // TODO: Find component by name
-                        continue;
-                    }
+                // ! NOTE: Unbinded attributes will trigger this code path every frame,
+                // ! so missing attributes will make a dent in the performance,
+
+                // Query component by name
+                // TODO: Log error instead of panic ...
+                let mut path = attr_path.split('.');
+                let component_short_name = path.next().expect("missing component short name");
+
+                if let Some(entity) = clip.hierarchy.find_entity_in_world(
+                    *entity_index,
+                    &mut entities_table_cache,
+                    &world,
+                ) {
+                    let location = world.get_entity_location(entity).unwrap();
+
+                    bind.entities[*entity_index as usize].get_or_insert_with(|| {
+                        ClipBindEntity {
+                            // If the entity was found the parent was as well (unless if the root which will be always None)
+                            parent: entities_table_cache
+                                [clip.hierarchy.get_entity(*entity_index).0 as usize],
+                            entity,
+                            location,
+                        }
+                    });
 
-                    // Entity archetype changed
-                    if let Some(component_reg) = type_registry_read_guard.get(&inner.component) {
+                    if let Some(component_reg) =
+                        type_registry_read_guard.get_with_short_name(component_short_name)
+                    {
+                        // ! FIXME: This function should fail, if the entity doesn't have the component
                         let root_props = component_reg.get_component_properties(
-                            &world.archetypes[loc.archetype as usize],
-                            loc.index,
+                            &world.archetypes[location.archetype as usize],
+                            location.index,
                         );
 
-                        // Update pointers to reflect the new entity memory location
-                        for i in (meta.range.0)..(meta.range.1) {
-                            let i = i as usize;
-                            let curve_index = bind.curves[i] as usize;
-                            let mut path = clip.attribute[curve_index].1.split('.');
-                            path.next(); // Skip component
-
-                            let ptr = find_property_ptr(
-                                path,
-                                root_props,
-                                clip.curves[curve_index].value_type(),
-                            );
-                            debug_assert!(bind.attributes[i] != ptr, "pointers can't be the same");
-                            bind.attributes[i] = ptr;
-                        }
+                        *attr = find_property_ptr(
+                            path,
+                            root_props,
+                            clip.curves[attr_index].value_type(),
+                        );
+
+                        // Clear binded bit if not fully binded
+                        bind.all_binded &= *attr != Ptr(null_mut());
                     } else {
-                        // Component is missing
-                        for i in (meta.range.0)..(meta.range.1) {
-                            bind.attributes[i as usize] = Ptr(null_mut());
-                        }
-                        inner.component = TypeId::of::<MissingComponentMarker>();
+                        bind.all_binded = false;
+                        panic!("component `{}` not registered", component_short_name);
                     }
-
-                    // Update bind location
-                    inner.location = loc;
+                } else {
+                    // Missing entity
+                    bind.all_binded = false;
                 }
             }
         }
     }
 }
 
-fn find_entity(
-    entity_index: u16,
-    entities_ids: &Vec<(u16, Name)>,
-    entities_table_cache: &mut Vec<Option<Entity>>,
-    world: &World,
-) -> Option<Entity> {
-    if let Some(entity) = &entities_table_cache[entity_index as usize] {
-        Some(*entity)
-    } else {
-        let (parent_index, entity_name) = &entities_ids[entity_index as usize];
-
-        // Use recursion to find the entity parent
-        find_entity(*parent_index, entities_ids, entities_table_cache, world).and_then(
-            |parent_entity| {
-                if let Ok(children) = world.get::<Children>(parent_entity) {
-                    children
-                        .iter()
-                        .find(|entity| {
-                            if let Ok(name) = world.get::<Name>(**entity) {
-                                if name == entity_name {
-                                    // Update cache
-                                    entities_table_cache[entity_index as usize] = Some(**entity);
-                                    true
-                                } else {
-                                    false
-                                }
-                            } else {
-                                false
-                            }
-                        })
-                        .copied()
-                } else {
-                    None
-                }
-            },
-        )
-    }
-}
-
 fn find_property_at_path<'a, P: Iterator<Item = &'a str>>(
     path: P,
     root_props: &dyn Properties,
@@ -975,18 +841,18 @@ pub fn animator_update_system(world: &mut World, resources: &mut Resources) {
                     layer.time = time;
 
                     // TODO: can be done in bached_parallel if is visited warped inside a mutex
-                    for ((ptr, keyframe), curve_index) in bind
+                    for (curve_index, (ptr, keyframe)) in bind
                         .attributes
                         .iter()
                         .zip(layer.keyframe.iter_mut())
-                        .zip(bind.curves.iter())
+                        .enumerate()
                     {
                         // Skip invalid properties
                         if *ptr == Ptr(null_mut()) {
                             continue;
                         }
 
-                        let curve = &clip.curves[*curve_index as usize];
+                        let curve = &clip.curves[curve_index];
 
                         let viz = if animator.visited.contains(&ptr) {
                             true
@@ -1217,39 +1083,13 @@ mod tests {
         //check_for_properties!(Color); // TODO: sRGB Color
     }
 
-    // ? NOTE: Don't remove this test, right now we can skip this test
-    // ? because all the animated type values (Vec2, Vec3 ...) don't
-    // ? implement the `Properties` type and thus none of their inner
-    // ? can be accessed
-    // #[test]
-    // #[should_panic]
-    // fn clip_add_nested_property() {
-    //     let mut clip = Clip::default();
-    //     let position = Curve::from_linear(0.0, 1.0, Vec3::zero(), Vec3::unit_y());
-    //     let y = Curve::from_linear(0.0, 1.0, 0.0, 1.0);
-    //     clip.add_animated_prop(
-    //         "Root/Ball@Transform.translation",
-    //         CurveUntyped::Vec3(position),
-    //     );
-    //     // NOTE: Right now "Transform.translation.y" can't be accessed because Vec3 doesn't impl Properties
-    //     clip.add_animated_prop("Root/Ball@Transform.translation.y", CurveUntyped::Float(y));
-    // }
-
-    // TODO: Add tests for hierarch change (creation and deletion)
-    // TODO: Add tests for entity archetype change
-    // TODO: Add tests for entities with same Name
-    // TODO: Add tests for mutated events
-    // TODO: Add tests for animated handle (impl missing)
-    // TODO: Add tests for animated asset properties (impl missing)
-    // TODO: Add tests for animated components should trigger 'Mutated' queries filters (impl missing)
-
-    struct AnimtorTestBench {
+    #[allow(dead_code)]
+    struct AnimatorTestBench {
         app: bevy_app::App,
-        //binding_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>>,
-        update_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>>,
+        entities: Vec<Entity>,
     }
 
-    impl AnimtorTestBench {
+    impl AnimatorTestBench {
         fn new() -> Self {
             let mut app_builder = bevy_app::App::build();
             app_builder
@@ -1311,43 +1151,55 @@ mod tests {
                 animator.add_layer(clip_b, 0.5);
             }
 
-            world_builder
-                .spawn(base.clone())
-                .with(Name::from_str("Root"))
-                .with(animator)
-                .with_children(|world_builder| {
+            let mut entities = vec![];
+            entities.push(
+                world_builder
+                    .spawn(base.clone())
+                    .with(Name::from_str("Root"))
+                    .with(animator)
+                    .current_entity
+                    .unwrap(),
+            );
+            world_builder.with_children(|world_builder| {
+                entities.push(
                     world_builder
                         .spawn(base.clone())
                         .with(Name::from_str("Node1"))
-                        .with_children(|world_builder| {
+                        .current_entity()
+                        .unwrap(),
+                );
+
+                world_builder.with_children(|world_builder| {
+                    entities.push(
+                        world_builder
+                            .spawn(base.clone())
+                            .with(Name::from_str("Node2"))
+                            .current_entity()
+                            .unwrap(),
+                    );
+
+                    world_builder.with_children(|world_builder| {
+                        entities.push(
                             world_builder
                                 .spawn(base.clone())
-                                .with(Name::from_str("Node2"))
-                                .with_children(|world_builder| {
-                                    world_builder
-                                        .spawn(base.clone())
-                                        .with(Name::from_str("Node3"));
-                                });
-                        });
+                                .with(Name::from_str("Node3"))
+                                .current_entity()
+                                .unwrap(),
+                        );
+                    });
                 });
+            });
 
             app_builder.set_world(world);
 
-            // let mut parent_update_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>> =
-            //     Box::new(bevy_transform::hierarchy::parent_update_system.system());
-
-            let mut binding_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>> =
-                Box::new(crate::animator_binding_system.system());
-
-            let update_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>> =
-                Box::new(crate::animator_update_system.system());
-
-            let mut app = app_builder.app;
-
-            //parent_update_system.run((), &mut app.world, &mut app.resources);
-            binding_system.run_thread_local(&mut app.world, &mut app.resources);
+            Self {
+                app: app_builder.app,
+                entities,
+            }
+        }
 
-            Self { app, update_system }
+        fn bind(&mut self) {
+            animator_binding_system(&mut self.app.world, &mut self.app.resources);
         }
 
         fn update(&mut self, ticks: usize) {
@@ -1359,21 +1211,125 @@ mod tests {
                     time.delta_seconds_f64 += 0.016;
                 }
 
-                self.update_system
-                    .run_thread_local(&mut self.app.world, &mut self.app.resources);
-
-                //dbg!(app.world.get::<Transform>(root_entity).unwrap());
+                animator_update_system(&mut self.app.world, &mut self.app.resources);
             }
         }
     }
 
+    #[test]
+    fn hierarch_change() {
+        // Tests for hierarch change deletion and creation of some entity that is been animated
+        let mut test_bench = AnimatorTestBench::new();
+        test_bench.bind();
+
+        {
+            let animator = test_bench
+                .app
+                .world
+                .get::<Animator>(test_bench.entities[0])
+                .expect("missing animator");
+
+            animator
+                .bind_clips
+                .iter()
+                .map(|b| b.as_ref().expect("missing clip bind"))
+                .for_each(|b| {
+                    b.attributes.iter().for_each(|attr| {
+                        assert_ne!(*attr, Ptr(null_mut()), "missing attribute bind")
+                    })
+                });
+        }
+
+        // TODO: delete "Node2"
+        test_bench.bind();
+
+        {
+            let animator = test_bench
+                .app
+                .world
+                .get::<Animator>(test_bench.entities[0])
+                .expect("missing animator");
+
+            // TODO: Checks
+        }
+
+        // TODO: Re-add "Node2"
+        test_bench.bind();
+
+        {
+            let animator = test_bench
+                .app
+                .world
+                .get::<Animator>(test_bench.entities[0])
+                .expect("missing animator");
+
+            animator
+                .bind_clips
+                .iter()
+                .map(|b| b.as_ref().expect("missing clip bind"))
+                .for_each(|b| {
+                    b.attributes.iter().for_each(|attr| {
+                        assert_ne!(*attr, Ptr(null_mut()), "missing attribute bind")
+                    })
+                });
+        }
+    }
+
+    #[test]
+    fn entity_archetype_change() {
+        // Add tests for entity archetype change
+        unimplemented!()
+    }
+
+    #[test]
+    fn entity_renamed() {
+        unimplemented!()
+    }
+
+    #[test]
+    fn missing_component_in_entity() {
+        // TODO: try to bind a property against a existent entity that doesn't have the target component
+        unimplemented!()
+    }
+
+    #[test]
+    fn entity_with_same_name() {
+        // TODO: Add tests for entities with same Name
+        unimplemented!()
+    }
+
+    #[test]
+    fn clip_changed() {
+        // TODO: Add tests for mutated events
+        unimplemented!()
+    }
+
+    #[test]
+    fn animated_components_are_marked_as_mutated() {
+        // TODO: Add tests for animated components should trigger 'Mutated' queries filters (impl missing)
+        unimplemented!()
+    }
+
+    #[test]
+    fn swapping_handle_animation() {
+        // TODO: Add tests for animated handle (impl missing)
+        unimplemented!()
+    }
+
+    #[test]
+    fn animate_asset_properties() {
+        // TODO: Add tests for animated asset properties (impl missing)
+        unimplemented!()
+    }
+
     #[test]
     fn test_bench_update() {
         // ? NOTE: Mimics a basic system update behavior good for pref since criterion will pollute the
         // ? annotations with many expensive instructions
-        let mut a = AnimtorTestBench::new();
+        let mut a = AnimatorTestBench::new();
+        a.bind();
         a.update(1_000_000);
     }
 
-    // TODO: 5 layers or more ...
+    // TODO: test update with 5 layers or more ...
 }
diff --git a/crates/bevy_animation/src/hierarchy.rs b/crates/bevy_animation/src/hierarchy.rs
new file mode 100644
index 0000000000000..da29b50e263b4
--- /dev/null
+++ b/crates/bevy_animation/src/hierarchy.rs
@@ -0,0 +1,199 @@
+use bevy_core::prelude::*;
+use bevy_ecs::prelude::*;
+use bevy_transform::prelude::*;
+//use serde::{Deserialize, Serialize};
+use std::convert::TryFrom;
+
+pub type Index = u16;
+
+/// Provides a way of describing a hierarchy or named entities
+/// and means for finding then in the world
+#[derive(Debug, Clone)]
+pub struct NamedHierarchy {
+    /// Entity identification made by parent index and name
+    entities: Vec<(Index, Name)>,
+}
+
+impl Default for NamedHierarchy {
+    fn default() -> Self {
+        Self {
+            // ? NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
+            entities: vec![(Index::MAX, Name::default())],
+        }
+    }
+}
+
+impl NamedHierarchy {
+    /// Number of entities registered.
+    #[inline(always)]
+    pub fn len(&self) -> usize {
+        self.entities.len()
+    }
+
+    /// Gets the entity parent index and `Name` components
+    #[inline(always)]
+    pub fn get_entity(&self, entity_index: Index) -> &(Index, Name) {
+        &self.entities[entity_index as usize]
+    }
+
+    /// Adds a new entity hierarchy path separated by backslashes (`'/'`)
+    /// return the entity index and if was or not inserted
+    pub fn get_or_insert_entity(&mut self, entity_path: &str) -> (Index, bool) {
+        let mut entity_created = false;
+        let mut entity = 0; // Start search from root
+        for name in entity_path.split('/') {
+            // Ignore the first '/' or '///'
+            if name.is_empty() {
+                continue;
+            }
+
+            if let Some(e) = self
+                .entities
+                .iter()
+                .position(|(p, n)| (*p, n.as_str()) == (entity, name))
+            {
+                // Found entity
+                // ? NOTE: Conversion will never panic because the collection
+                // ? size will only increase in the else branch where a
+                // ? safe cast is performed
+                entity = e as Index;
+            } else {
+                // Add entity
+                let e = self.entities.len();
+                self.entities.push((entity, Name::from_str(name)));
+                entity_created = true;
+                // Soft limit added to save memory, identical to the curve limit
+                entity = Index::try_from(e).expect("entities limit reached");
+            }
+        }
+
+        (entity, entity_created)
+    }
+
+    /// Returns the entity path if found.
+    ///
+    /// The `NamedHierarchy` stores a the entity path in a specific way to improve search performance
+    /// thus it needs to rebuilt in the human readable format
+    pub fn get_entity_path_at(&self, mut entity_index: Index) -> Option<String> {
+        let mut path = None;
+
+        while let Some((parent_index, name)) = self.entities.get(entity_index as usize) {
+            if let Some(path) = path.as_mut() {
+                *path = format!("{}/{}", name.as_str(), path);
+            } else {
+                path = Some(name.as_str().to_string());
+            }
+
+            entity_index = *parent_index;
+        }
+
+        path
+    }
+
+    // TODO: Docs of how to proper use the find_* functions
+
+    /// Finds an entity given a set of queries, see the example bellow
+    /// how to proper call this function,
+    ///
+    /// ```rust
+    /// let mut entities_table_cache = vec![];
+    /// entities_table_cache.resize(clip.hierarchy.len(), None);
+    /// // Assign the root entity as the first element
+    /// entities_table_cache[0] = Some(root);
+    ///
+    /// let found_entity = named_hierarchy.find_entity(2, &mut entities_table_cache, children_query, name_query);
+    /// ```
+    pub fn find_entity(
+        &self,
+        entity_index: Index,
+        entities_table_cache: &mut Vec<Option<Entity>>,
+        children_query: &mut Query<(&Children,)>,
+        name_query: &mut Query<(&Name,)>,
+    ) -> Option<Entity> {
+        if let Some(entity) = &entities_table_cache[entity_index as usize] {
+            Some(*entity)
+        } else {
+            let (parent_index, entity_name) = &self.entities[entity_index as usize];
+
+            // Use recursion to find the entity parent
+            self.find_entity(
+                *parent_index,
+                entities_table_cache,
+                children_query,
+                name_query,
+            )
+            .and_then(|parent_entity| {
+                if let Ok((children,)) = children_query.get(parent_entity) {
+                    children
+                        .iter()
+                        .find(|entity| {
+                            if let Ok((name,)) = name_query.get(**entity) {
+                                if name == entity_name {
+                                    // Update cache
+                                    entities_table_cache[entity_index as usize] = Some(**entity);
+                                    true
+                                } else {
+                                    false
+                                }
+                            } else {
+                                false
+                            }
+                        })
+                        .copied()
+                } else {
+                    None
+                }
+            })
+        }
+    }
+
+    /// Finds an entity given a reference to the (`World`)[bevy_ecs::World], see the example bellow
+    /// how to proper call this function,
+    ///
+    /// ```rust
+    /// let mut entities_table_cache = vec![];
+    /// entities_table_cache.resize(clip.hierarchy.len(), None);
+    /// // Assign the root entity as the first element
+    /// entities_table_cache[0] = Some(root);
+    ///
+    /// let found_entity = named_hierarchy.find_entity_in_world(2, &mut entities_table_cache, &world);
+    /// ```
+    pub fn find_entity_in_world(
+        &self,
+        entity_index: Index,
+        entities_table_cache: &mut Vec<Option<Entity>>,
+        world: &World,
+    ) -> Option<Entity> {
+        if let Some(entity) = &entities_table_cache[entity_index as usize] {
+            Some(*entity)
+        } else {
+            let (parent_index, entity_name) = &self.entities[entity_index as usize];
+
+            // Use recursion to find the entity parent
+            self.find_entity_in_world(*parent_index, entities_table_cache, world)
+                .and_then(|parent_entity| {
+                    if let Ok(children) = world.get::<Children>(parent_entity) {
+                        children
+                            .iter()
+                            .find(|entity| {
+                                if let Ok(name) = world.get::<Name>(**entity) {
+                                    if name == entity_name {
+                                        // Update cache
+                                        entities_table_cache[entity_index as usize] =
+                                            Some(**entity);
+                                        true
+                                    } else {
+                                        false
+                                    }
+                                } else {
+                                    false
+                                }
+                            })
+                            .copied()
+                    } else {
+                        None
+                    }
+                })
+        }
+    }
+}
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 68c71480aa66c..1b3723be4f355 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -4,12 +4,13 @@ use bevy_asset::AddAsset;
 use bevy_type_registry::RegisterType;
 
 pub mod generic;
+mod hierarchy;
 pub mod lerping;
 mod skinned_mesh;
 
 pub use crate::generic::*;
+pub use crate::hierarchy::NamedHierarchy;
 pub use crate::skinned_mesh::*;
-//mod util;
 
 pub mod prelude {
     pub use crate::generic::{Animator, Clip, Curve, CurveUntyped};

From 3c996000e2ee5c9c07e0e6ec1958384e75b82e0d Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sun, 29 Nov 2020 02:28:37 -0300
Subject: [PATCH 021/153] handle nested clip properties + hierarch tests

---
 crates/bevy_animation/src/generic.rs | 178 ++++++++++++++++++---------
 1 file changed, 122 insertions(+), 56 deletions(-)

diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 1378e01300fd1..f7f70b05afd8b 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -31,7 +31,7 @@ pub struct Clip {
     /// Attribute is made by the entity index and a string that combines
     /// component name followed by their attributes spaced by a period,
     /// like so: `"Transform.translation.x"`
-    attribute: Vec<(u16, Name)>,
+    properties: Vec<(u16, String)>,
     curves: Vec<CurveUntyped>,
 }
 
@@ -46,7 +46,7 @@ impl Default for Clip {
             duration: 0.0,
             // ? NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
             hierarchy: NamedHierarchy::default(),
-            attribute: vec![],
+            properties: vec![],
             curves: vec![],
         }
     }
@@ -56,6 +56,8 @@ impl Clip {
     /// Property to be animated must be in the following format `"path/to/named_entity@Transform.translation.x"`
     /// where the left side `@` defines a path to the entity to animate,
     /// while the right side the path to a property to animate starting from the component.
+    ///
+    /// *NOTE* This is a expensive function
     pub fn add_animated_prop(&mut self, property_path: &str, mut curve: CurveUntyped) {
         // Clip an only have some amount of curves and entities
         // this limitation was added to save memory (but you can increase it if you want)
@@ -64,40 +66,53 @@ impl Clip {
             "curve limit reached"
         );
 
+        // Split in entity and attribute path,
+        // NOTE: use rfind because it's expected the latter to be generally shorter
         let path =
             property_path.split_at(property_path.rfind('@').expect("property path missing @"));
 
-        let (entity, entity_created) = self.hierarchy.get_or_insert_entity(path.0);
-
-        let insert_attr = Name::from_str(path.1.split_at(1).1);
+        let (entity1, just_created) = self.hierarchy.get_or_insert_entity(path.0);
+        let name1 = path.1.split_at(1).1;
 
         // If some entity was created it means this property is a new one so we can safely skip the attribute testing
-        if !entity_created {
-            for (i, attr) in self.attribute.iter().enumerate() {
-                if attr.0 != entity {
+        if !just_created {
+            for (i, entry) in self.properties.iter().enumerate() {
+                let (entity0, name0) = entry;
+
+                if *entity0 != entity1 {
                     continue;
                 }
 
-                // TODO: Prepare for bevy_reflect
-                // TODO: "...@Transform.translation" and "...@Transform.translation.x" can't live with each other
-
-                if insert_attr == attr.1 {
-                    // Found a property are equal the one been inserted
-                    // Replace curve, the property was already added, this is very important
-                    // because it guarantees that each property will have unique access to some
-                    // attribute during the update stages
-
-                    let inserted_duration = curve.duration();
-                    std::mem::swap(&mut self.curves[i], &mut curve);
-                    self.update_duration(curve.duration(), inserted_duration);
-
-                    return;
+                let mid = name1.len().min(name0.len());
+                let (head0, tail0) = name0.split_at(mid);
+                let (head1, tail1) = name1.split_at(mid);
+
+                if head0 == head1 {
+                    // Replace
+                    if tail0.len() == 0 && tail1.len() == 0 {
+                        // Found a property are equal the one been inserted
+                        // Replace curve, the property was already added, this is very important
+                        // because it guarantees that each property will have unique access to some
+                        // attribute during the update stages
+
+                        let inserted_duration = curve.duration();
+                        std::mem::swap(&mut self.curves[i], &mut curve);
+                        self.update_duration(curve.duration(), inserted_duration);
+                        return;
+                    } else {
+                        // Check the inserted attribute is nested of an already present attribute
+                        // NOTE: ".../Enity0@Transform.translation" and ".../Enity0@Transform.translation.x"
+                        // can't coexist because it may cause a problems of non unique access
+                        if tail0.starts_with('.') || tail1.starts_with('.') {
+                            panic!("nesting properties");
+                        }
+                    }
                 }
             }
         }
 
         self.duration = self.duration.max(curve.duration());
-        self.attribute.push((entity, insert_attr));
+        self.properties.push((entity1, name1.to_string()));
         self.curves.push(curve);
     }
 
@@ -112,7 +127,7 @@ impl Clip {
     /// The clip stores a property path in a specific way to improve search performance
     /// thus it needs to rebuilt the curve property path in the human readable format
     pub fn get_property_path(&self, index: u16) -> String {
-        let (entity_index, name) = &self.attribute[index as usize];
+        let (entity_index, name) = &self.properties[index as usize];
         format!(
             "{}@{}",
             self.hierarchy
@@ -600,7 +615,7 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
                     .for_each(|(entity_index, entry)| {
                         *entry = None;
                         // ? NOTE: Will only run if the bind was invalidated in this frame
-                        for (descriptor, attr) in clip.attribute.iter().zip(attrs.iter_mut()) {
+                        for (descriptor, attr) in clip.properties.iter().zip(attrs.iter_mut()) {
                             if descriptor.0 as usize == entity_index {
                                 *attr = Ptr(null_mut());
                             }
@@ -614,7 +629,7 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
                 *bind = Some(ClipBind {
                     entities: vec_filled(clip.hierarchy.len(), || None),
                     all_binded: false,
-                    attributes: vec_filled(clip.attribute.len(), || Ptr(null_mut())),
+                    attributes: vec_filled(clip.properties.len(), || Ptr(null_mut())),
                 });
 
                 bind.as_mut().unwrap()
@@ -632,7 +647,7 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
             for (attr_index, (attr, descriptor)) in bind
                 .attributes
                 .iter_mut()
-                .zip(clip.attribute.iter())
+                .zip(clip.properties.iter())
                 .enumerate()
             {
                 let (entity_index, attr_path) = descriptor;
@@ -659,9 +674,11 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
 
                     bind.entities[*entity_index as usize].get_or_insert_with(|| {
                         ClipBindEntity {
-                            // If the entity was found the parent was as well (unless if the root which will be always None)
+                            // If the entity was found the parent was as well (unless is the root which will always be None)
                             parent: entities_table_cache
-                                [clip.hierarchy.get_entity(*entity_index).0 as usize],
+                                .get(clip.hierarchy.get_entity(*entity_index).0 as usize)
+                                .copied()
+                                .flatten(),
                             entity,
                             location,
                         }
@@ -1087,6 +1104,7 @@ mod tests {
     struct AnimatorTestBench {
         app: bevy_app::App,
         entities: Vec<Entity>,
+        schedule: bevy_ecs::Schedule,
     }
 
     impl AnimatorTestBench {
@@ -1122,7 +1140,7 @@ mod tests {
                 );
                 let rot = CurveUntyped::Quat(Curve::from_constant(Quat::identity()));
                 clip_a.add_animated_prop("@Transform.rotation", rot.clone());
-                clip_a.add_animated_prop("/Hode1@Transform.rotation", rot.clone());
+                clip_a.add_animated_prop("/Node1@Transform.rotation", rot.clone());
                 clip_a.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
 
                 let mut clip_b = Clip::default();
@@ -1137,7 +1155,7 @@ mod tests {
                     Quat::from_axis_angle(Vec3::unit_z(), -0.1),
                 ));
                 clip_b.add_animated_prop("@Transform.rotation", rot.clone());
-                clip_b.add_animated_prop("/Hode1@Transform.rotation", rot.clone());
+                clip_b.add_animated_prop("/Node1@Transform.rotation", rot.clone());
                 clip_b.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
 
                 let mut clips = app_builder
@@ -1192,27 +1210,27 @@ mod tests {
 
             app_builder.set_world(world);
 
+            let mut schedule = bevy_ecs::Schedule::default();
+            schedule.add_stage("update");
+            schedule.add_stage_after("update", "post_update");
+            schedule.add_system_to_stage("update", animator_binding_system);
+            schedule.add_system_to_stage("update", animator_update_system);
+            schedule.add_system_to_stage("post_update", parent_update_system);
+            //schedule.add_system_to_stage("update", transform_propagate_system);
+
+            schedule.initialize(&mut app_builder.app.world, &mut app_builder.app.resources);
+            schedule.run(&mut app_builder.app.world, &mut app_builder.app.resources);
+
             Self {
                 app: app_builder.app,
                 entities,
+                schedule,
             }
         }
 
-        fn bind(&mut self) {
-            animator_binding_system(&mut self.app.world, &mut self.app.resources);
-        }
-
-        fn update(&mut self, ticks: usize) {
-            for _ in 0..ticks {
-                // Time tick
-                {
-                    let mut time = self.app.resources.get_mut::<Time>().unwrap();
-                    time.delta_seconds += 0.016;
-                    time.delta_seconds_f64 += 0.016;
-                }
-
-                animator_update_system(&mut self.app.world, &mut self.app.resources);
-            }
+        fn run(&mut self) {
+            self.schedule
+                .run(&mut self.app.world, &mut self.app.resources);
         }
     }
 
@@ -1220,7 +1238,6 @@ mod tests {
     fn hierarch_change() {
         // Tests for hierarch change deletion and creation of some entity that is been animated
         let mut test_bench = AnimatorTestBench::new();
-        test_bench.bind();
 
         {
             let animator = test_bench
@@ -1240,8 +1257,15 @@ mod tests {
                 });
         }
 
-        // TODO: delete "Node2"
-        test_bench.bind();
+        // delete "Node1"
+        test_bench
+            .app
+            .world
+            .despawn(test_bench.entities[1])
+            .unwrap();
+
+        // Tick
+        test_bench.run();
 
         {
             let animator = test_bench
@@ -1250,11 +1274,43 @@ mod tests {
                 .get::<Animator>(test_bench.entities[0])
                 .expect("missing animator");
 
-            // TODO: Checks
+            animator
+                .bind_clips
+                .iter()
+                .map(|b| b.as_ref().expect("missing clip bind"))
+                .zip([2, 2].iter())
+                .for_each(|(b, skip)| {
+                    b.attributes.iter().skip(*skip).for_each(|attr| {
+                        assert_eq!(*attr, Ptr(null_mut()), "attribute still binded")
+                    })
+                });
         }
 
-        // TODO: Re-add "Node2"
-        test_bench.bind();
+        // Re-add "Node1"
+        test_bench.entities[1] = test_bench
+            .app
+            .world
+            .build()
+            .spawn((
+                GlobalTransform::default(),
+                Transform::from_translation(Vec3::new(0.0, 1.0, 0.0)),
+                Name::from_str("Node1"),
+                Parent(test_bench.entities[0]),
+            ))
+            .current_entity
+            .unwrap();
+
+        *test_bench
+            .app
+            .world
+            .get_mut::<Parent>(test_bench.entities[2])
+            .unwrap() = Parent(test_bench.entities[1]);
+
+        // Tick
+        // ! FIXME: May take one frame to bind the missing properties because
+        // ! the `parent_update_system` must run in order to update the `Children` component
+        test_bench.run();
+        test_bench.run();
 
         {
             let animator = test_bench
@@ -1269,7 +1325,7 @@ mod tests {
                 .map(|b| b.as_ref().expect("missing clip bind"))
                 .for_each(|b| {
                     b.attributes.iter().for_each(|attr| {
-                        assert_ne!(*attr, Ptr(null_mut()), "missing attribute bind")
+                        assert_ne!(*attr, Ptr(null_mut()), "attribute didn't rebinded")
                     })
                 });
         }
@@ -1326,9 +1382,19 @@ mod tests {
     fn test_bench_update() {
         // ? NOTE: Mimics a basic system update behavior good for pref since criterion will pollute the
         // ? annotations with many expensive instructions
-        let mut a = AnimatorTestBench::new();
-        a.bind();
-        a.update(1_000_000);
+        let mut test_bench = AnimatorTestBench::new();
+        test_bench.run();
+
+        for _ in 0..100_000 {
+            // Time tick
+            {
+                let mut time = test_bench.app.resources.get_mut::<Time>().unwrap();
+                time.delta_seconds += 0.016;
+                time.delta_seconds_f64 += 0.016;
+            }
+
+            animator_update_system(&mut test_bench.app.world, &mut test_bench.app.resources);
+        }
     }
 
     // TODO: test update with 5 layers or more ...

From 3e3c1123e9c7d84d0c89d909bb8a465622e15fe5 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sun, 29 Nov 2020 13:08:28 -0300
Subject: [PATCH 022/153] handle parent change + tests

---
 crates/bevy_animation/Cargo.toml       |   8 +-
 crates/bevy_animation/src/generic.rs   | 238 ++++++++++++++++++-------
 crates/bevy_animation/src/hierarchy.rs |  41 +++--
 3 files changed, 209 insertions(+), 78 deletions(-)

diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index e473e621487e0..7b20216674d87 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -35,4 +35,10 @@ debug = true
 
 [[bench]]
 name = "animator"
-harness = false
\ No newline at end of file
+harness = false
+
+[features]
+default = []
+
+# Used to enable custom tests designed to profile certain aspects of the animation system
+extra-profiling-tests = []
\ No newline at end of file
diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index f7f70b05afd8b..349ab03c13689 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -482,9 +482,10 @@ unsafe impl Sync for Ptr {}
 
 /// State info for the system `animator_binding_system`
 #[derive(Default)]
-struct ClipResourceProviderState {
-    clip_event_reader: EventReader<AssetEvent<Clip>>,
-    modified: fnv::FnvHashSet<Handle<Clip>>,
+struct BindingState {
+    clips_event_reader: EventReader<AssetEvent<Clip>>,
+    clips_modified: fnv::FnvHashSet<Handle<Clip>>,
+    entities_parent_changed: Vec<u16>,
 }
 
 /// Creates a new vector with a given size filled with the values returned by the given default function
@@ -502,13 +503,11 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
     // ! FIXME: These local resources seams to be quite slow, maybe I need a random system id?
     // Fetch resources
     let mut state = {
-        let state = resources.get_local_mut::<ClipResourceProviderState>(system_id);
+        let state = resources.get_local_mut::<BindingState>(system_id);
         if state.is_none() {
             std::mem::drop(state); // ? NOTE: Makes the borrow checker happy
-            resources.insert_local(system_id, ClipResourceProviderState::default());
-            resources
-                .get_local_mut::<ClipResourceProviderState>(system_id)
-                .unwrap()
+            resources.insert_local(system_id, BindingState::default());
+            resources.get_local_mut::<BindingState>(system_id).unwrap()
         } else {
             state.unwrap()
         }
@@ -526,11 +525,11 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
 
     // ? NOTE: Changing a clip on fly is supported, but very expensive so use with caution
     // Query all clips that changed and remove their binds from the animator
-    state.modified.clear();
-    for event in state.clip_event_reader.iter(&clip_events) {
+    state.clips_modified.clear();
+    for event in state.clips_event_reader.iter(&clip_events) {
         match event {
-            AssetEvent::Removed { handle } => state.modified.insert(handle.clone()),
-            AssetEvent::Modified { handle } => state.modified.insert(handle.clone()),
+            AssetEvent::Removed { handle } => state.clips_modified.insert(handle.clone()),
+            AssetEvent::Modified { handle } => state.clips_modified.insert(handle.clone()),
             _ => false,
         };
     }
@@ -548,7 +547,7 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
 
         for (clip_handle, bind) in animator.clips.iter().zip(animator.bind_clips.iter_mut()) {
             // Invalidate binds for clips that where modified
-            if state.modified.contains(clip_handle) {
+            if state.clips_modified.contains(clip_handle) {
                 *bind = None;
             }
 
@@ -574,6 +573,13 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
                 let done = &mut bind.all_binded;
                 let attrs = &mut bind.attributes;
 
+                // NOTE: Must be empty in this next function, if not it means
+                // something went wrong in the previous iteration
+                debug_assert!(
+                    state.entities_parent_changed.len() == 0,
+                    "parent changes have not been properly handled"
+                );
+
                 bind.entities
                     .iter_mut()
                     .enumerate()
@@ -588,8 +594,9 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
                         // Not root
                         if *entity_index > 0 {
                             if let Ok(Parent(parent)) = world.query_one::<&Parent>(inner.entity) {
-                                // Parent changed
+                                // Parent changed or removed
                                 if inner.parent != Some(*parent) {
+                                    state.entities_parent_changed.push(*entity_index as u16);
                                     return true;
                                 }
                             } else {
@@ -623,6 +630,40 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
                         *done = false;
                     });
 
+                // Handle entities that had theirs parents changed
+                // ? NOTE: Heavy code path triggered when an animated hierarchy changes
+                while let Some(entity_index) = state.entities_parent_changed.pop() {
+                    let entry = &mut bind.entities[entity_index as usize];
+
+                    if entry.is_some() {
+                        // Yet not invalidated
+                        for (descriptor, attr) in clip.properties.iter().zip(attrs.iter_mut()) {
+                            if descriptor.0 == entity_index {
+                                *attr = Ptr(null_mut());
+                            }
+                        }
+                    }
+
+                    *entry = None;
+                    *done = false;
+
+                    // Find children to invalidate their binds as well
+                    // ? NOTE: The `NamedHierarch` isn't optimized for travel the hierarchy
+                    // ? tree from top to bottom, so this operation is quite inefficient
+                    state.entities_parent_changed.extend(
+                        clip.hierarchy
+                            .iter()
+                            .enumerate()
+                            .filter_map(|(i, (parent_index, _))| {
+                                if *parent_index == entity_index {
+                                    Some(i as u16)
+                                } else {
+                                    None
+                                }
+                            }),
+                    );
+                }
+
                 bind
             } else {
                 // Create empty binds
@@ -1232,30 +1273,41 @@ mod tests {
             self.schedule
                 .run(&mut self.app.world, &mut self.app.resources);
         }
-    }
-
-    #[test]
-    fn hierarch_change() {
-        // Tests for hierarch change deletion and creation of some entity that is been animated
-        let mut test_bench = AnimatorTestBench::new();
 
-        {
-            let animator = test_bench
+        fn validate_binds<F: Fn(usize, usize, &Ptr)>(&self, validation: F) {
+            let animator = self
                 .app
                 .world
-                .get::<Animator>(test_bench.entities[0])
+                .get::<Animator>(self.entities[0])
                 .expect("missing animator");
 
             animator
                 .bind_clips
                 .iter()
                 .map(|b| b.as_ref().expect("missing clip bind"))
-                .for_each(|b| {
-                    b.attributes.iter().for_each(|attr| {
-                        assert_ne!(*attr, Ptr(null_mut()), "missing attribute bind")
-                    })
+                .enumerate()
+                .for_each(|(i, b)| {
+                    b.attributes
+                        .iter()
+                        .enumerate()
+                        .for_each(|(j, attr)| validation(i, j, attr));
                 });
         }
+    }
+
+    #[test]
+    fn entity_deleted() {
+        // Tests for hierarch change deletion and creation of some entity that is been animated
+        let mut test_bench = AnimatorTestBench::new();
+
+        test_bench.validate_binds(|curve_index, prop_index, ptr| {
+            assert!(
+                *ptr != Ptr(null_mut()),
+                "property {} unbinded in curve {}",
+                prop_index,
+                curve_index,
+            )
+        });
 
         // delete "Node1"
         test_bench
@@ -1267,24 +1319,23 @@ mod tests {
         // Tick
         test_bench.run();
 
-        {
-            let animator = test_bench
-                .app
-                .world
-                .get::<Animator>(test_bench.entities[0])
-                .expect("missing animator");
-
-            animator
-                .bind_clips
-                .iter()
-                .map(|b| b.as_ref().expect("missing clip bind"))
-                .zip([2, 2].iter())
-                .for_each(|(b, skip)| {
-                    b.attributes.iter().skip(*skip).for_each(|attr| {
-                        assert_eq!(*attr, Ptr(null_mut()), "attribute still binded")
-                    })
-                });
-        }
+        test_bench.validate_binds(|curve_index, prop_index, ptr| {
+            if prop_index < [2, 2][curve_index] {
+                assert!(
+                    *ptr != Ptr(null_mut()),
+                    "property {} unbinded in curve {}",
+                    prop_index,
+                    curve_index,
+                )
+            } else {
+                assert!(
+                    *ptr == Ptr(null_mut()),
+                    "property {} still binded in curve {}",
+                    prop_index,
+                    curve_index,
+                )
+            }
+        });
 
         // Re-add "Node1"
         test_bench.entities[1] = test_bench
@@ -1312,23 +1363,87 @@ mod tests {
         test_bench.run();
         test_bench.run();
 
-        {
-            let animator = test_bench
-                .app
-                .world
-                .get::<Animator>(test_bench.entities[0])
-                .expect("missing animator");
+        test_bench.validate_binds(|curve_index, prop_index, ptr| {
+            assert!(
+                *ptr != Ptr(null_mut()),
+                "property {} wasn't rebinded in curve {}",
+                prop_index,
+                curve_index,
+            )
+        });
+    }
 
-            animator
-                .bind_clips
-                .iter()
-                .map(|b| b.as_ref().expect("missing clip bind"))
-                .for_each(|b| {
-                    b.attributes.iter().for_each(|attr| {
-                        assert_ne!(*attr, Ptr(null_mut()), "attribute didn't rebinded")
-                    })
-                });
-        }
+    #[test]
+    fn entity_parent_changed() {
+        // Tests for hierarch change deletion and creation of some entity that is been animated
+        let mut test_bench = AnimatorTestBench::new();
+
+        test_bench.validate_binds(|curve_index, prop_index, ptr| {
+            assert!(
+                *ptr != Ptr(null_mut()),
+                "property {} unbinded in curve {}",
+                prop_index,
+                curve_index,
+            )
+        });
+
+        // Change parent of node "Node1"
+        let new_parent = test_bench
+            .app
+            .world
+            .build()
+            .spawn(())
+            .current_entity
+            .unwrap();
+
+        *test_bench
+            .app
+            .world
+            .get_mut::<Parent>(test_bench.entities[1])
+            .unwrap() = Parent(new_parent);
+
+        // Tick
+        test_bench.run();
+
+        test_bench.validate_binds(|curve_index, prop_index, ptr| {
+            if prop_index < [2, 2][curve_index] {
+                assert!(
+                    *ptr != Ptr(null_mut()),
+                    "property {} unbinded in curve {}",
+                    prop_index,
+                    curve_index,
+                )
+            } else {
+                assert!(
+                    *ptr == Ptr(null_mut()),
+                    "property {} still binded in curve {}",
+                    prop_index,
+                    curve_index,
+                )
+            }
+        });
+
+        // Re-parent "Node1"
+        *test_bench
+            .app
+            .world
+            .get_mut::<Parent>(test_bench.entities[1])
+            .unwrap() = Parent(test_bench.entities[0]);
+
+        // Tick
+        // ! FIXME: May take one frame to bind the missing properties because
+        // ! the `parent_update_system` must run in order to update the `Children` component
+        test_bench.run();
+        test_bench.run();
+
+        test_bench.validate_binds(|curve_index, prop_index, ptr| {
+            assert!(
+                *ptr != Ptr(null_mut()),
+                "property {} wasn't rebinded in curve {}",
+                prop_index,
+                curve_index,
+            )
+        });
     }
 
     #[test]
@@ -1379,6 +1494,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(feature = "extra-profiling-tests")]
     fn test_bench_update() {
         // ? NOTE: Mimics a basic system update behavior good for pref since criterion will pollute the
         // ? annotations with many expensive instructions
diff --git a/crates/bevy_animation/src/hierarchy.rs b/crates/bevy_animation/src/hierarchy.rs
index da29b50e263b4..b4e8972b56278 100644
--- a/crates/bevy_animation/src/hierarchy.rs
+++ b/crates/bevy_animation/src/hierarchy.rs
@@ -36,6 +36,10 @@ impl NamedHierarchy {
         &self.entities[entity_index as usize]
     }
 
+    pub fn iter(&self) -> impl Iterator<Item = &(Index, Name)> {
+        self.entities.iter()
+    }
+
     /// Adds a new entity hierarchy path separated by backslashes (`'/'`)
     /// return the entity index and if was or not inserted
     pub fn get_or_insert_entity(&mut self, entity_path: &str) -> (Index, bool) {
@@ -108,7 +112,7 @@ impl NamedHierarchy {
         entity_index: Index,
         entities_table_cache: &mut Vec<Option<Entity>>,
         children_query: &mut Query<(&Children,)>,
-        name_query: &mut Query<(&Name,)>,
+        name_query: &mut Query<(&Parent, &Name)>,
     ) -> Option<Entity> {
         if let Some(entity) = &entities_table_cache[entity_index as usize] {
             Some(*entity)
@@ -127,14 +131,16 @@ impl NamedHierarchy {
                     children
                         .iter()
                         .find(|entity| {
-                            if let Ok((name,)) = name_query.get(**entity) {
-                                if name == entity_name {
-                                    // Update cache
-                                    entities_table_cache[entity_index as usize] = Some(**entity);
-                                    true
-                                } else {
-                                    false
+                            if let Ok((current_parent, name)) = name_query.get(**entity) {
+                                // ! FIXME: Parent changes before the children update it self,
+                                // ! to account for that we also must double check entity parent component it self
+                                if current_parent.0 != parent_entity || name != entity_name {
+                                    return false;
                                 }
+
+                                // Update cache
+                                entities_table_cache[entity_index as usize] = Some(**entity);
+                                true
                             } else {
                                 false
                             }
@@ -176,15 +182,18 @@ impl NamedHierarchy {
                         children
                             .iter()
                             .find(|entity| {
-                                if let Ok(name) = world.get::<Name>(**entity) {
-                                    if name == entity_name {
-                                        // Update cache
-                                        entities_table_cache[entity_index as usize] =
-                                            Some(**entity);
-                                        true
-                                    } else {
-                                        false
+                                if let Ok((current_parent, name)) =
+                                    world.query_one::<(&Parent, &Name)>(**entity)
+                                {
+                                    // ! FIXME: Parent changes before the children update it self,
+                                    // ! to account for that we also must double check entity parent component it self
+                                    if current_parent.0 != parent_entity || name != entity_name {
+                                        return false;
                                     }
+
+                                    // Update cache
+                                    entities_table_cache[entity_index as usize] = Some(**entity);
+                                    true
                                 } else {
                                     false
                                 }

From c1219806b18065f70deac8b25d01e18978c75dc9 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Mon, 30 Nov 2020 20:54:44 -0300
Subject: [PATCH 023/153] added children info in named hierarchy (now just
 hierarchy)

---
 crates/bevy_animation/Cargo.toml       |   4 +-
 crates/bevy_animation/src/generic.rs   | 146 ++++++++++++++-----------
 crates/bevy_animation/src/hierarchy.rs |  27 +++--
 crates/bevy_animation/src/lib.rs       |   2 +-
 4 files changed, 106 insertions(+), 73 deletions(-)

diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index 7b20216674d87..1e282138df376 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -30,8 +30,8 @@ tracing = { version = "0.1.21", features = ["attributes"] }
 [dev-dependencies]
 criterion = "0.3.3"
 
-[profile.release]
-debug = true
+# [profile.release]
+# debug = true
 
 [[bench]]
 name = "animator"
diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 349ab03c13689..29130a48af2e2 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -13,7 +13,7 @@ use std::any::TypeId;
 use std::hash::Hash;
 use std::ptr::null_mut;
 
-use super::hierarchy::NamedHierarchy;
+use super::hierarchy::Hierarchy;
 use super::lerping::LerpValue;
 
 // TODO: Curve/Clip need a validation during deserialization because they are
@@ -27,7 +27,7 @@ pub struct Clip {
     pub warp: bool,
     duration: f32,
     /// Entity identification made by parent index and name
-    hierarchy: NamedHierarchy,
+    hierarchy: Hierarchy,
     /// Attribute is made by the entity index and a string that combines
     /// component name followed by their attributes spaced by a period,
     /// like so: `"Transform.translation.x"`
@@ -45,7 +45,7 @@ impl Default for Clip {
             warp: true,
             duration: 0.0,
             // ? NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
-            hierarchy: NamedHierarchy::default(),
+            hierarchy: Hierarchy::default(),
             properties: vec![],
             curves: vec![],
         }
@@ -459,9 +459,9 @@ struct ClipBindEntity {
 struct ClipBind {
     entities: Vec<Option<ClipBindEntity>>,
     /// True only when all the attributes are binded
-    all_binded: bool,
+    binded: bool,
     /// Attributes pointers
-    attributes: Vec<Ptr>,
+    pointers: Vec<Ptr>,
 }
 
 // #[derive(Debug)]
@@ -485,7 +485,6 @@ unsafe impl Sync for Ptr {}
 struct BindingState {
     clips_event_reader: EventReader<AssetEvent<Clip>>,
     clips_modified: fnv::FnvHashSet<Handle<Clip>>,
-    entities_parent_changed: Vec<u16>,
 }
 
 /// Creates a new vector with a given size filled with the values returned by the given default function
@@ -504,17 +503,18 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
     // Fetch resources
     let mut state = {
         let state = resources.get_local_mut::<BindingState>(system_id);
-        if state.is_none() {
-            std::mem::drop(state); // ? NOTE: Makes the borrow checker happy
-            resources.insert_local(system_id, BindingState::default());
-            resources.get_local_mut::<BindingState>(system_id).unwrap()
-        } else {
-            state.unwrap()
+        match state {
+            Some(state) => state,
+            None => {
+                std::mem::drop(state); // ? NOTE: Makes the borrow checker happy
+                resources.insert_local(system_id, BindingState::default());
+                resources.get_local_mut::<BindingState>(system_id).unwrap()
+            }
         }
     };
 
     let type_registry = resources.get::<TypeRegistry>().unwrap();
-    let type_registry_read_guard = type_registry.component.read();
+    let mut type_registry_read_guard = None;
 
     let clips = resources.get::<Assets<Clip>>().unwrap();
     let clip_events = resources.get::<Events<AssetEvent<Clip>>>().unwrap();
@@ -534,6 +534,11 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
         };
     }
 
+    let mut entities_parent_changed = vec![];
+
+    // Used for entity translation
+    let mut entities_table_cache = vec![];
+
     for (root, mut animator) in animator_query {
         let animator = &mut *animator; // Make sure the borrow checker is happy
 
@@ -542,9 +547,6 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
             .bind_clips
             .resize_with(animator.clips.len(), || None);
 
-        // Used for entity translation
-        let mut entities_table_cache = vec![];
-
         for (clip_handle, bind) in animator.clips.iter().zip(animator.bind_clips.iter_mut()) {
             // Invalidate binds for clips that where modified
             if state.clips_modified.contains(clip_handle) {
@@ -570,17 +572,19 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
             let bind = if let Some(bind) = bind.as_mut() {
                 // Invalidate previously binded attributes
 
-                let done = &mut bind.all_binded;
-                let attrs = &mut bind.attributes;
+                // Borrow checker sugar coat
+                let binded = &mut bind.binded;
+                let pointers = &mut bind.pointers;
+                let entities = &mut bind.entities;
 
                 // NOTE: Must be empty in this next function, if not it means
                 // something went wrong in the previous iteration
                 debug_assert!(
-                    state.entities_parent_changed.len() == 0,
+                    entities_parent_changed.len() == 0,
                     "parent changes have not been properly handled"
                 );
 
-                bind.entities
+                entities
                     .iter_mut()
                     .enumerate()
                     // Find entities that changed
@@ -593,14 +597,16 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
 
                         // Not root
                         if *entity_index > 0 {
+                            // TODO: Check the entity name
                             if let Ok(Parent(parent)) = world.query_one::<&Parent>(inner.entity) {
                                 // Parent changed or removed
                                 if inner.parent != Some(*parent) {
-                                    state.entities_parent_changed.push(*entity_index as u16);
+                                    entities_parent_changed.push(*entity_index as u16);
                                     return true;
                                 }
                             } else {
                                 // Parent removed
+                                entities_parent_changed.push(*entity_index as u16);
                                 return true;
                             }
                         }
@@ -612,6 +618,7 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
                             }
                         } else {
                             // Entity deleted
+                            entities_parent_changed.push(*entity_index as u16);
                             return true;
                         }
 
@@ -622,46 +629,36 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
                     .for_each(|(entity_index, entry)| {
                         *entry = None;
                         // ? NOTE: Will only run if the bind was invalidated in this frame
-                        for (descriptor, attr) in clip.properties.iter().zip(attrs.iter_mut()) {
+                        for (descriptor, attr) in clip.properties.iter().zip(pointers.iter_mut()) {
                             if descriptor.0 as usize == entity_index {
                                 *attr = Ptr(null_mut());
                             }
                         }
-                        *done = false;
+                        *binded = false;
                     });
 
                 // Handle entities that had theirs parents changed
                 // ? NOTE: Heavy code path triggered when an animated hierarchy changes
-                while let Some(entity_index) = state.entities_parent_changed.pop() {
-                    let entry = &mut bind.entities[entity_index as usize];
+                while let Some(entity_index) = entities_parent_changed.pop() {
+                    clip.hierarchy
+                        .depth_first(entity_index, &mut |entity_index, _| {
+                            let entry = &mut entities[entity_index as usize];
+
+                            if entry.is_some() {
+                                // Yet not invalidated
+                                for (descriptor, attr) in
+                                    clip.properties.iter().zip(pointers.iter_mut())
+                                {
+                                    if descriptor.0 == entity_index {
+                                        *attr = Ptr(null_mut());
+                                    }
+                                }
 
-                    if entry.is_some() {
-                        // Yet not invalidated
-                        for (descriptor, attr) in clip.properties.iter().zip(attrs.iter_mut()) {
-                            if descriptor.0 == entity_index {
-                                *attr = Ptr(null_mut());
+                                *entry = None;
                             }
-                        }
-                    }
 
-                    *entry = None;
-                    *done = false;
-
-                    // Find children to invalidate their binds as well
-                    // ? NOTE: The `NamedHierarch` isn't optimized for travel the hierarchy
-                    // ? tree from top to bottom, so this operation is quite inefficient
-                    state.entities_parent_changed.extend(
-                        clip.hierarchy
-                            .iter()
-                            .enumerate()
-                            .filter_map(|(i, (parent_index, _))| {
-                                if *parent_index == entity_index {
-                                    Some(i as u16)
-                                } else {
-                                    None
-                                }
-                            }),
-                    );
+                            *binded = false;
+                        });
                 }
 
                 bind
@@ -669,24 +666,24 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
                 // Create empty binds
                 *bind = Some(ClipBind {
                     entities: vec_filled(clip.hierarchy.len(), || None),
-                    all_binded: false,
-                    attributes: vec_filled(clip.properties.len(), || Ptr(null_mut())),
+                    binded: false,
+                    pointers: vec_filled(clip.properties.len(), || Ptr(null_mut())),
                 });
 
                 bind.as_mut().unwrap()
             };
 
             // All attributes are binded
-            if bind.all_binded {
+            if bind.binded {
                 continue;
             }
 
             // Will be cleared if any attribute fail to bind
-            bind.all_binded = true;
+            bind.binded = true;
 
             // Bind attributes
             for (attr_index, (attr, descriptor)) in bind
-                .attributes
+                .pointers
                 .iter_mut()
                 .zip(clip.properties.iter())
                 .enumerate()
@@ -725,8 +722,9 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
                         }
                     });
 
-                    if let Some(component_reg) =
-                        type_registry_read_guard.get_with_short_name(component_short_name)
+                    if let Some(component_reg) = type_registry_read_guard
+                        .get_or_insert_with(|| type_registry.component.read()) // Lazily gets type registry read lock
+                        .get_with_short_name(component_short_name)
                     {
                         // ! FIXME: This function should fail, if the entity doesn't have the component
                         let root_props = component_reg.get_component_properties(
@@ -741,15 +739,19 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
                         );
 
                         // Clear binded bit if not fully binded
-                        bind.all_binded &= *attr != Ptr(null_mut());
+                        bind.binded &= *attr != Ptr(null_mut());
                     } else {
-                        bind.all_binded = false;
+                        bind.binded = false;
                         panic!("component `{}` not registered", component_short_name);
                     }
                 } else {
                     // Missing entity
-                    bind.all_binded = false;
+                    bind.binded = false;
                 }
+
+                // TODO: Check bounds and memory alignment whenever the binds change
+                // do this by: sorting the pointers and then checking if the curve value type size
+                // doesn't overlap with the next pointer
             }
         }
     }
@@ -900,7 +902,7 @@ pub fn animator_update_system(world: &mut World, resources: &mut Resources) {
 
                     // TODO: can be done in bached_parallel if is visited warped inside a mutex
                     for (curve_index, (ptr, keyframe)) in bind
-                        .attributes
+                        .pointers
                         .iter()
                         .zip(layer.keyframe.iter_mut())
                         .enumerate()
@@ -1287,7 +1289,7 @@ mod tests {
                 .map(|b| b.as_ref().expect("missing clip bind"))
                 .enumerate()
                 .for_each(|(i, b)| {
-                    b.attributes
+                    b.pointers
                         .iter()
                         .enumerate()
                         .for_each(|(j, attr)| validation(i, j, attr));
@@ -1449,6 +1451,11 @@ mod tests {
     #[test]
     fn entity_archetype_change() {
         // Add tests for entity archetype change
+
+        // TODO: Add extra dummy component
+        // TODO: Remove dummy component
+        // TODO: Remove parent
+
         unimplemented!()
     }
 
@@ -1501,7 +1508,7 @@ mod tests {
         let mut test_bench = AnimatorTestBench::new();
         test_bench.run();
 
-        for _ in 0..100_000 {
+        for _ in 0..1_000_000 {
             // Time tick
             {
                 let mut time = test_bench.app.resources.get_mut::<Time>().unwrap();
@@ -1513,5 +1520,18 @@ mod tests {
         }
     }
 
+    #[test]
+    #[cfg(feature = "extra-profiling-tests")]
+    fn test_bench_binding() {
+        // ? NOTE: Mimics a basic system update behavior good for pref since criterion will pollute the
+        // ? annotations with many expensive instructions
+        let mut test_bench = AnimatorTestBench::new();
+        test_bench.run();
+
+        for _ in 0..1_000_000 {
+            animator_binding_system(&mut test_bench.app.world, &mut test_bench.app.resources);
+        }
+    }
+
     // TODO: test update with 5 layers or more ...
 }
diff --git a/crates/bevy_animation/src/hierarchy.rs b/crates/bevy_animation/src/hierarchy.rs
index b4e8972b56278..22084ee837805 100644
--- a/crates/bevy_animation/src/hierarchy.rs
+++ b/crates/bevy_animation/src/hierarchy.rs
@@ -2,6 +2,7 @@ use bevy_core::prelude::*;
 use bevy_ecs::prelude::*;
 use bevy_transform::prelude::*;
 //use serde::{Deserialize, Serialize};
+use smallvec::{smallvec, SmallVec};
 use std::convert::TryFrom;
 
 pub type Index = u16;
@@ -9,21 +10,25 @@ pub type Index = u16;
 /// Provides a way of describing a hierarchy or named entities
 /// and means for finding then in the world
 #[derive(Debug, Clone)]
-pub struct NamedHierarchy {
+pub struct Hierarchy {
     /// Entity identification made by parent index and name
     entities: Vec<(Index, Name)>,
+    // ? NOTE: SmallVec<[u16; 10]> occupy the same 32 bytes as the SmallVec<[u16; 8]>, but the latter
+    // ? should be only take 24 bytes using the "union" feature
+    children: Vec<SmallVec<[u16; 10]>>,
 }
 
-impl Default for NamedHierarchy {
+impl Default for Hierarchy {
     fn default() -> Self {
         Self {
             // ? NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
             entities: vec![(Index::MAX, Name::default())],
+            children: vec![smallvec![]],
         }
     }
 }
 
-impl NamedHierarchy {
+impl Hierarchy {
     /// Number of entities registered.
     #[inline(always)]
     pub fn len(&self) -> usize {
@@ -36,8 +41,15 @@ impl NamedHierarchy {
         &self.entities[entity_index as usize]
     }
 
-    pub fn iter(&self) -> impl Iterator<Item = &(Index, Name)> {
-        self.entities.iter()
+    pub fn depth_first<F: FnMut(Index, &Name)>(&self, entity_index: Index, visitor: &mut F) {
+        let i = entity_index as usize;
+        let (_, name) = &self.entities[i];
+
+        visitor(entity_index, name);
+
+        for child_index in &self.children[i] {
+            self.depth_first(*child_index, visitor);
+        }
     }
 
     /// Adds a new entity hierarchy path separated by backslashes (`'/'`)
@@ -65,9 +77,12 @@ impl NamedHierarchy {
                 // Add entity
                 let e = self.entities.len();
                 self.entities.push((entity, Name::from_str(name)));
+                self.children.push(smallvec![]);
                 entity_created = true;
                 // Soft limit added to save memory, identical to the curve limit
+                let _parent = entity;
                 entity = Index::try_from(e).expect("entities limit reached");
+                self.children[_parent as usize].push(entity)
             }
         }
 
@@ -94,8 +109,6 @@ impl NamedHierarchy {
         path
     }
 
-    // TODO: Docs of how to proper use the find_* functions
-
     /// Finds an entity given a set of queries, see the example bellow
     /// how to proper call this function,
     ///
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 1b3723be4f355..594279ec6b119 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -9,7 +9,7 @@ pub mod lerping;
 mod skinned_mesh;
 
 pub use crate::generic::*;
-pub use crate::hierarchy::NamedHierarchy;
+pub use crate::hierarchy::Hierarchy;
 pub use crate::skinned_mesh::*;
 
 pub mod prelude {

From 4309611b1cd6adc671a310b219a06b8ac2b9da6f Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sat, 5 Dec 2020 12:20:25 -0300
Subject: [PATCH 024/153] mesh skining + named hiearchy can be built from array
 to preserve order + minor changes

---
 .../bevy_animation/src/forward_skinned.vert   |  38 +++
 crates/bevy_animation/src/generic.rs          |  20 +-
 crates/bevy_animation/src/hierarchy.rs        |  33 +-
 crates/bevy_animation/src/lib.rs              |  17 +-
 crates/bevy_animation/src/skinned_mesh.rs     | 288 ++++++++++++------
 crates/bevy_gltf/src/loader.rs                |  35 ++-
 crates/bevy_render/src/mesh/mesh.rs           |   1 +
 7 files changed, 304 insertions(+), 128 deletions(-)
 create mode 100644 crates/bevy_animation/src/forward_skinned.vert

diff --git a/crates/bevy_animation/src/forward_skinned.vert b/crates/bevy_animation/src/forward_skinned.vert
new file mode 100644
index 0000000000000..204b991246522
--- /dev/null
+++ b/crates/bevy_animation/src/forward_skinned.vert
@@ -0,0 +1,38 @@
+#version 450
+
+layout(location = 0) in vec3 Vertex_Position;
+layout(location = 1) in vec3 Vertex_Normal;
+layout(location = 2) in vec2 Vertex_Uv;
+layout(location = 3) in vec4 Vertex_Weight;
+layout(location = 4) in uvec4 Vertex_Join;
+
+layout(location = 0) out vec3 v_Position;
+layout(location = 1) out vec3 v_Normal;
+layout(location = 2) out vec2 v_Uv;
+
+layout(set = 0, binding = 0) uniform Camera {
+    mat4 ViewProj;
+};
+
+layout(set = 2, binding = 0) uniform Transform {
+    mat4 Model;
+};
+
+layout(set = 2, binding = 1) buffer SkinInstance_joint_matrices {
+    mat4[] Joints;
+};
+
+void main() {
+    mat4 Mat = Vertex_Weight.x * Joints[Vertex_Join.x]
+        + Vertex_Weight.y * Joints[Vertex_Join.y]
+        + Vertex_Weight.z * Joints[Vertex_Join.z]
+        + Vertex_Weight.w * Joints[Vertex_Join.w];
+
+    Mat = Model * Mat;
+
+    v_Normal = (Mat * vec4(Vertex_Normal, 1.0)).xyz;
+    v_Normal = mat3(Mat) * Vertex_Normal;
+    v_Position = (Mat * vec4(Vertex_Position, 1.0)).xyz;
+    v_Uv = Vertex_Uv;
+    gl_Position = ViewProj * vec4(v_Position, 1.0);
+}
diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 29130a48af2e2..e8e490c551be3 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -13,7 +13,7 @@ use std::any::TypeId;
 use std::hash::Hash;
 use std::ptr::null_mut;
 
-use super::hierarchy::Hierarchy;
+use super::hierarchy::NamedHierarchyTree;
 use super::lerping::LerpValue;
 
 // TODO: Curve/Clip need a validation during deserialization because they are
@@ -27,7 +27,7 @@ pub struct Clip {
     pub warp: bool,
     duration: f32,
     /// Entity identification made by parent index and name
-    hierarchy: Hierarchy,
+    hierarchy: NamedHierarchyTree,
     /// Attribute is made by the entity index and a string that combines
     /// component name followed by their attributes spaced by a period,
     /// like so: `"Transform.translation.x"`
@@ -45,7 +45,7 @@ impl Default for Clip {
             warp: true,
             duration: 0.0,
             // ? NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
-            hierarchy: Hierarchy::default(),
+            hierarchy: NamedHierarchyTree::default(),
             properties: vec![],
             curves: vec![],
         }
@@ -180,6 +180,7 @@ impl Clip {
 #[derive(Debug, Clone)]
 pub enum CurveUntyped {
     Float(Curve<f32>),
+    //Vec2(Curve<Vec2>),
     Vec3(Curve<Vec3>),
     Vec4(Curve<Vec4>),
     Quat(Curve<Quat>),
@@ -292,8 +293,7 @@ where
         self.sample_indexed(index, time).1
     }
 
-    /// Samples the curve starting from some keyframe index, this make the common case `O(1)`,
-    /// use only when time advancing forwards
+    /// Samples the curve starting from some keyframe index, this make the common case `O(1)`
     pub fn sample_indexed(&self, mut index: usize, time: f32) -> (usize, T) {
         // Adjust for the current keyframe index
         let last_index = self.samples.len() - 1;
@@ -356,9 +356,15 @@ where
         self.samples.iter().copied().zip(self.values.iter_mut())
     }
 
+    #[inline(always)]
     pub fn value_type(&self) -> TypeId {
         TypeId::of::<T>()
     }
+
+    #[inline(always)]
+    pub fn value_size(&self) -> usize {
+        std::mem::size_of::<T>()
+    }
 }
 
 #[derive(Debug, Clone, Properties)]
@@ -808,8 +814,8 @@ fn find_property_ptr<'a, P: Iterator<Item = &'a str>>(
                 // With the new bevy_reflect we can ref properties inside vectors and other things
                 if unsafe { root.offset_from(ptr).abs() } >= size {
                     // TODO: log also the full property path
-                    tracing::warn!("property outside component");
-                    return null_mut();
+                    panic!("property outside component");
+                    //return null_mut();
                 }
             }
             ptr
diff --git a/crates/bevy_animation/src/hierarchy.rs b/crates/bevy_animation/src/hierarchy.rs
index 22084ee837805..ddbdfb36459f6 100644
--- a/crates/bevy_animation/src/hierarchy.rs
+++ b/crates/bevy_animation/src/hierarchy.rs
@@ -10,15 +10,15 @@ pub type Index = u16;
 /// Provides a way of describing a hierarchy or named entities
 /// and means for finding then in the world
 #[derive(Debug, Clone)]
-pub struct Hierarchy {
+pub struct NamedHierarchyTree {
     /// Entity identification made by parent index and name
     entities: Vec<(Index, Name)>,
     // ? NOTE: SmallVec<[u16; 10]> occupy the same 32 bytes as the SmallVec<[u16; 8]>, but the latter
     // ? should be only take 24 bytes using the "union" feature
-    children: Vec<SmallVec<[u16; 10]>>,
+    children: Vec<SmallVec<[Index; 10]>>,
 }
 
-impl Default for Hierarchy {
+impl Default for NamedHierarchyTree {
     fn default() -> Self {
         Self {
             // ? NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
@@ -28,13 +28,38 @@ impl Default for Hierarchy {
     }
 }
 
-impl Hierarchy {
+impl NamedHierarchyTree {
+    /// Used when the hierarchy must be in a specific order
+    pub fn from_parent_and_name_entities(entities: Vec<(Index, Name)>) -> Self {
+        let mut children = vec![];
+        children.resize_with(entities.len(), || smallvec![]);
+
+        for (entity_index, (parent_index, _)) in entities.iter().enumerate() {
+            children
+                .get_mut(*parent_index as usize)
+                .map(|c| c.push(entity_index as Index));
+        }
+
+        Self { entities, children }
+    }
+
+    // pub fn from_name_and_children_entities(iter: impl Iterator<Item ...>) -> Self {
+    // }
+
     /// Number of entities registered.
     #[inline(always)]
     pub fn len(&self) -> usize {
         self.entities.len()
     }
 
+    /// Iterates over each entity parent index, name and children indexes
+    #[inline(always)]
+    pub fn iter(&self) -> impl Iterator<Item = (&(Index, Name), &[Index])> {
+        self.entities
+            .iter()
+            .zip(self.children.iter().map(|c| &c[..]))
+    }
+
     /// Gets the entity parent index and `Name` components
     #[inline(always)]
     pub fn get_entity(&self, entity_index: Index) -> &(Index, Name) {
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 594279ec6b119..699be058ae8cd 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -9,13 +9,14 @@ pub mod lerping;
 mod skinned_mesh;
 
 pub use crate::generic::*;
-pub use crate::hierarchy::Hierarchy;
+pub use crate::hierarchy::NamedHierarchyTree;
 pub use crate::skinned_mesh::*;
 
 pub mod prelude {
     pub use crate::generic::{Animator, Clip, Curve, CurveUntyped};
+    pub use crate::hierarchy::NamedHierarchyTree;
     pub use crate::lerping::LerpValue;
-    pub use crate::skinned_mesh::{MeshSkin, MeshSkinBinder, MeshSkinnerDebugger};
+    pub use crate::skinned_mesh::{SkinAsset, SkinComponent, SkinDebugger};
 }
 
 pub mod stage {
@@ -39,10 +40,12 @@ impl Plugin for AnimationPlugin {
             .add_system_to_stage(stage::ANIMATE, animator_update_system);
 
         // Skinning
-        app.add_asset::<MeshSkin>()
-            .register_component_with::<MeshSkinBinder>(|reg| reg.map_entities())
-            .register_component::<MeshSkinnerDebugger>()
-            .add_system_to_stage(stage::POST_UPDATE, mesh_skinner_debugger_update)
-            .add_system_to_stage(stage::ANIMATE, mesh_skinner_startup);
+        app.add_asset::<SkinAsset>()
+            .add_asset::<SkinInstance>()
+            .register_component_with::<SkinComponent>(|reg| reg.map_entities())
+            .register_component::<SkinDebugger>()
+            .add_startup_system(skinning_setup)
+            .add_system_to_stage(stage::ANIMATE, skinning_update)
+            .add_system_to_stage(stage::POST_UPDATE, skinning_debugger_update);
     }
 }
diff --git a/crates/bevy_animation/src/skinned_mesh.rs b/crates/bevy_animation/src/skinned_mesh.rs
index bd221b63ee004..2991509be9e5a 100644
--- a/crates/bevy_animation/src/skinned_mesh.rs
+++ b/crates/bevy_animation/src/skinned_mesh.rs
@@ -1,4 +1,5 @@
 // TODO: Later merge with bevy_animation
+use crate::hierarchy::NamedHierarchyTree;
 use bevy_asset::{Assets, Handle};
 use bevy_core::Name;
 use bevy_ecs::prelude::*;
@@ -7,142 +8,241 @@ use bevy_math::Mat4;
 use bevy_pbr::prelude::*;
 use bevy_property::Properties;
 use bevy_render::mesh::{shape, Indices, Mesh, VertexAttributeValues};
-use bevy_render::pipeline::PrimitiveTopology;
+use bevy_render::pipeline::{PipelineDescriptor, PrimitiveTopology, RenderPipelines};
+use bevy_render::render_graph::{base, AssetRenderResourcesNode, RenderGraph};
+use bevy_render::renderer::RenderResources;
+use bevy_render::shader::{Shader, ShaderStage};
 use bevy_transform::prelude::*;
 use bevy_type_registry::TypeUuid;
 use smallvec::SmallVec;
 
-/// Skin asset used by the mesh skinning process
+// NOTE: generated using python `import secrets; secrets.token_hex(8)`
+pub const FORWARD_SKINNED_PIPELINE_HANDLE: Handle<PipelineDescriptor> =
+    Handle::weak_from_u64(PipelineDescriptor::TYPE_UUID, 0xedf5a66b71d07478u64);
+
+/// Skin asset used by the skinning process
 #[derive(Debug, Clone, TypeUuid)]
 #[uuid = "129d54f5-4ee7-456f-9340-32e71469cdaf"]
-pub struct MeshSkin {
+pub struct SkinAsset {
+    /// Inverse bind matrices in root node space
     pub inverse_bind_matrices: Vec<Mat4>,
-    pub bones_names: Vec<String>, // TODO: Use the Name component instead
-    /// Each bone as an entry that specifies their parent bone, maybe used to reconstruct
-    /// the bone hierarchy when missing
-    pub bones_parents: Vec<Option<usize>>,
+    /// Skin joint hierarchy, plus one extra the root node as the first entry.
+    pub hierarchy: NamedHierarchyTree,
 }
 
-impl MeshSkin {
-    #[inline(always)]
-    pub fn bone_count(&self) -> usize {
-        self.bones_names.len()
-    }
+#[derive(Default, Debug, Clone, TypeUuid, RenderResources)]
+#[uuid = "e25de07b-f813-4c6b-ad06-b160c3e924b2"]
+pub struct SkinInstance {
+    // TODO: Use 4x3 matrices instead the last row will be always vec4(0, 0, 0, 1)
+    // NOTE: Mat4 doesn't impl `Byteable` so we need to use an array here
+    #[render_resources(buffer)]
+    joint_matrices: Vec<[f32; 16]>,
+    // TODO: Can we use a shader_def to define the number of bones per vertex? (no we can't)
 }
 
 /// Component that skins some mesh.
-/// Requires a `Handle<MeshSkin>` attached to same entity as the component
+/// Requires a `Handle<Skin>` attached to same entity as the component
 #[derive(Properties)]
-pub struct MeshSkinBinder {
+pub struct SkinComponent {
     /// Keeps track of what `MeshSkin` this component is configured to,
     /// extra work is required to keep bones in order.
     ///
     /// It's expected to the skin not to change very often or at all
     #[property(ignore)]
-    skin: Option<Handle<MeshSkin>>,
-    /// Skeleton root entity
-    pub skeleton: Entity,
+    previous_skin: Option<Handle<SkinAsset>>,
+
     /// Maps each bone to an entity, order matters and must match the
-    /// `Handle<MeshSkin>` bone order, this will simplify the lookup of
+    /// `Handle<Skin>` bone order, this will simplify the lookup of
     /// the bind matrix for each bone
-    pub bones: SmallVec<[Option<Entity>; 16]>, // ! FIXME: Property can't handle Vec<Entity>
-    /// List of sub-meshes (gltf primitives) that uses this mesh skinner
-    pub meshes: SmallVec<[Entity; 8]>, // ! FIXME: Property can't handle Vec<Entity>
+    #[property(ignore)]
+    joint_entities: Vec<Option<Entity>>,
+
+    #[property(ignore)]
+    instance: Option<Handle<SkinInstance>>,
+
+    /// Skeleton root entity
+    pub root: Entity,
+
+    /// List of entities with `RenderPipelines` attached to it
+    /// that will share this component render resources
+    ///
+    /// *NOTE* Children of this component doesn't require to be added
+    pub renderers: SmallVec<[Entity; 8]>, // ! FIXME: Property can't handle Vec<Entity>
 }
 
-impl MeshSkinBinder {
-    pub fn with_skeleton(skeleton: Entity) -> Self {
+impl SkinComponent {
+    /// Creates a new SkinBinder component
+    pub fn with_root(root: Entity) -> Self {
         Self {
-            skin: None,
-            skeleton,
-            bones: Default::default(),
-            meshes: Default::default(),
+            previous_skin: None,
+            joint_entities: Default::default(),
+            instance: None,
+            root,
+            renderers: Default::default(),
         }
     }
-
-    // TODO: Provide a safe interface to `set_bone_by_name` in the MeshSkinner
 }
 
 // TODO: Same problem of Parent component
-impl FromResources for MeshSkinBinder {
+impl FromResources for SkinComponent {
     fn from_resources(_resources: &bevy_ecs::Resources) -> Self {
-        MeshSkinBinder::with_skeleton(Entity::new(u32::MAX))
+        SkinComponent::with_root(Entity::new(u32::MAX))
     }
 }
 
-impl MapEntities for MeshSkinBinder {
+impl MapEntities for SkinComponent {
     fn map_entities(
         &mut self,
         entity_map: &bevy_ecs::EntityMap,
     ) -> Result<(), bevy_ecs::MapEntitiesError> {
-        for bone in &mut self.bones {
-            if let Some(bone_entity) = bone {
-                *bone_entity = entity_map.get(*bone_entity)?;
-            }
+        for renderer in &mut self.renderers {
+            *renderer = entity_map.get(*renderer)?;
         }
-        self.skeleton = entity_map.get(self.skeleton)?;
+        self.root = entity_map.get(self.root)?;
         Ok(())
     }
 }
 
-// NOTE: This system is provided for a user convenience, once the root bone is assigned this system
-// will find the rest of the skeleton hierarchy.
-pub(crate) fn mesh_skinner_startup(
-    mesh_skin_assets: Res<Assets<MeshSkin>>,
-    mut skinners_query: Query<(&Handle<MeshSkin>, &mut MeshSkinBinder, Option<&Children>)>,
-    meshes_query: Query<(&Handle<Mesh>,)>,
-    bones_query: Query<(Entity, &Name, Option<&Children>)>,
+#[tracing::instrument(skip(pipelines, shaders, render_graph))]
+pub(crate) fn skinning_setup(
+    mut pipelines: ResMut<Assets<PipelineDescriptor>>,
+    mut shaders: ResMut<Assets<Shader>>,
+    mut render_graph: ResMut<RenderGraph>,
+) {
+    let mut forward_skinned_pipeline = pipelines
+        .get(bevy_pbr::render_graph::FORWARD_PIPELINE_HANDLE)
+        .expect("missing forward pipeline")
+        .clone();
+
+    forward_skinned_pipeline.shader_stages.vertex = shaders.add(Shader::from_glsl(
+        ShaderStage::Vertex,
+        include_str!("forward_skinned.vert"),
+    ));
+
+    pipelines.set_untracked(FORWARD_SKINNED_PIPELINE_HANDLE, forward_skinned_pipeline);
+
+    // Add an AssetRenderResourcesNode to our Render Graph. This will bind SkinInstance resources to our shader
+    render_graph.add_system_node(
+        "skin_instance",
+        AssetRenderResourcesNode::<SkinInstance>::new(false),
+    );
+
+    // Add a Render Graph edge connecting our new "skin_instance" node to the main pass node.
+    // This ensures "skin_instance" runs before the main pass
+    render_graph
+        .add_node_edge("skin_instance", base::node::MAIN_PASS)
+        .unwrap();
+}
+
+// ? NOTE: You can check the follow link, for more details
+// ? https://github.com/KhronosGroup/glTF-Tutorials/blob/master/gltfTutorial/gltfTutorial_020_Skins.md
+#[tracing::instrument(skip(
+    commands,
+    skin_assets,
+    skin_instances,
+    binds_query,
+    children_query,
+    name_query,
+    transforms_query
+))]
+pub(crate) fn skinning_update(
+    commands: &mut Commands,
+    skin_assets: Res<Assets<SkinAsset>>,
+    mut skin_instances: ResMut<Assets<SkinInstance>>,
+    mut binds_query: Query<(&Handle<SkinAsset>, &mut SkinComponent, &Children)>,
+    //meshes_query: Query<(&Handle<Mesh>,)>,
+    //bones_query: Query<(Entity, &Name, Option<&Children>)>,
+    mut children_query: Query<(&Children,)>,
+    mut name_query: Query<(&Parent, &Name)>,
+    transforms_query: Query<(&GlobalTransform,)>,
+    mut renderers_query: Query<(&mut RenderPipelines,)>,
 ) {
-    for (mesh_skin, mut mesh_skinner, children) in skinners_query.iter_mut() {
+    for (skin_asset_handle, mut skin_bind, skin_children) in binds_query.iter_mut() {
         // Already assigned
-        if Some(mesh_skin) == mesh_skinner.skin.as_ref() {
-            continue;
+        if Some(skin_asset_handle) != skin_bind.previous_skin.as_ref() {
+            // Clear
+            skin_bind.joint_entities.clear();
+            skin_bind.previous_skin = Some(skin_asset_handle.clone());
+            skin_bind.instance = None;
         }
 
-        // Lookup for all non assigned sub-meshes
-        if let Some(children) = children {
-            for mesh in children
-                .iter()
-                .filter_map(|child| meshes_query.get(*child).map_or(None, |_| Some(child)))
-                .copied()
-            {
-                if mesh_skinner.meshes.contains(&mesh) {
-                    continue;
-                }
+        if let Some(skin_asset) = skin_assets.get(skin_asset_handle) {
+            // Ensure bone capacity and assign the root entity
+            skin_bind
+                .joint_entities
+                .resize(skin_asset.hierarchy.len(), None);
+            skin_bind.joint_entities[0] = Some(skin_bind.root);
+
+            // Look for skeleton entities
+            for entity_index in 1..skin_asset.hierarchy.len() {
+                skin_asset.hierarchy.find_entity(
+                    entity_index as u16,
+                    &mut skin_bind.joint_entities,
+                    &mut children_query,
+                    &mut name_query,
+                );
+            }
 
-                mesh_skinner.meshes.push(mesh);
+            if skin_bind.instance.is_none() {
+                // Create skin instance
+                let mut joint_matrices = vec![];
+                joint_matrices.resize(
+                    skin_asset.inverse_bind_matrices.len(),
+                    Mat4::identity().to_cols_array(),
+                );
+                skin_bind.instance = Some(skin_instances.add(SkinInstance { joint_matrices }));
             }
-        }
 
-        if let Some(skin) = mesh_skin_assets.get(mesh_skin) {
-            // Ensure bone capacity
-            mesh_skinner.bones.resize(skin.bone_count(), None);
-
-            // TODO: Uee the find_entity function instead!
-            let mut root = true;
-            let mut stack = vec![mesh_skinner.skeleton];
-            while let Some(entity) = stack.pop() {
-                // Lookup bones in the hierarchy
-                if let Ok((bone_entity, name, children)) = bones_query.get(entity) {
-                    if root {
-                        children.map(|c| stack.extend(c.iter()));
-                        root = false;
-                        continue;
-                    }
+            // Bind skins in the renderers
 
-                    if let Some((bone_index, _)) = skin
-                        .bones_names
-                        .iter()
-                        .enumerate()
-                        .find(|(_, n)| name.as_str().eq(n.as_str()))
-                    {
-                        mesh_skinner.bones[bone_index] = Some(bone_entity);
-                        children.map(|c| stack.extend(c.iter()));
-                    }
+            let skin_instance_handle = skin_bind
+                .instance
+                .as_ref()
+                .expect("missing skin instance handle");
+
+            for renderer_entity in skin_bind.renderers.iter().chain(skin_children.iter()) {
+                // Insert right skinning info
+                commands.insert_one(*renderer_entity, skin_instance_handle.clone());
+
+                // Change render pipeline
+                if let Ok((mut renderer,)) = renderers_query.get_mut(*renderer_entity) {
+                    renderer.pipelines[0].pipeline = FORWARD_SKINNED_PIPELINE_HANDLE;
                 }
             }
 
-            mesh_skinner.skin = Some(mesh_skin.clone());
+            // Update skin uniforms
+            let root_inverse_matrix = transforms_query.get(skin_bind.root).map_or_else(
+                |_| Mat4::identity(),
+                |(global_transform,)| {
+                    // TODO: build the inverse matrix directly from the Isometry should be faster
+                    global_transform.compute_matrix().inverse()
+                },
+            );
+
+            let skin_instance = skin_instances
+                .get_mut(skin_instance_handle)
+                .expect("missing skin instance");
+
+            skin_instance
+                .joint_matrices
+                .iter_mut()
+                .zip(
+                    skin_bind
+                        .joint_entities
+                        .iter()
+                        .skip(1) // Skip the root entity
+                        .zip(skin_asset.inverse_bind_matrices.iter()),
+                )
+                .for_each(|(joint_matrix, (joint_entity, joint_inverse_matrix))| {
+                    if let Some(entity) = joint_entity {
+                        if let Ok((global_transform,)) = transforms_query.get(*entity) {
+                            *joint_matrix = (root_inverse_matrix
+                                * global_transform.compute_matrix()
+                                * (*joint_inverse_matrix))
+                                .to_cols_array();
+                        }
+                    }
+                });
         }
     }
 }
@@ -150,7 +250,7 @@ pub(crate) fn mesh_skinner_startup(
 ///////////////////////////////////////////////////////////////////////////////
 
 #[derive(Default, Debug, Properties)]
-pub struct MeshSkinnerDebugger {
+pub struct SkinDebugger {
     //pub enabled: bool,
     #[property(ignore)]
     started: bool,
@@ -160,15 +260,15 @@ pub struct MeshSkinnerDebugger {
     entity: Option<Entity>,
 }
 
-pub(crate) fn mesh_skinner_debugger_update(
+pub(crate) fn skinning_debugger_update(
     commands: &mut Commands,
     mut meshes: ResMut<Assets<Mesh>>,
-    skins: Res<Assets<MeshSkin>>,
-    mut debugger_query: Query<(&Handle<MeshSkin>, &MeshSkinBinder, &mut MeshSkinnerDebugger)>,
+    skins: Res<Assets<SkinAsset>>,
+    mut debugger_query: Query<(&Handle<SkinAsset>, &SkinComponent, &mut SkinDebugger)>,
     bones_query: Query<(&GlobalTransform,)>,
 ) {
     for (skin_handle, skinner, mut debugger) in debugger_query.iter_mut() {
-        if skinner.skin.as_ref() != Some(skin_handle) {
+        if skinner.previous_skin.as_ref() != Some(skin_handle) {
             continue;
         }
 
@@ -186,7 +286,7 @@ pub(crate) fn mesh_skinner_debugger_update(
 
             if !debugger.started {
                 let bone_mesh = meshes.add(Mesh::from(shape::Cube { size: 0.02 }));
-                for bone in skinner.bones.iter() {
+                for bone in skinner.joint_entities.iter() {
                     if let Some(entity) = bone {
                         commands
                             .spawn(PbrBundle {
@@ -214,7 +314,7 @@ pub(crate) fn mesh_skinner_debugger_update(
             }
 
             let positions = skinner
-                .bones
+                .joint_entities
                 .iter()
                 .map(|bone| {
                     if let Some(entity) = *bone {
@@ -235,12 +335,12 @@ pub(crate) fn mesh_skinner_debugger_update(
             let mut indices = vec![];
             let mut vertices = vec![];
 
-            for (i, parent) in skin.bones_parents.iter().enumerate() {
-                if let Some(parent) = *parent {
+            for (i, ((parent_index, _), _)) in skin.hierarchy.iter().enumerate() {
+                if let Some(parent) = positions.get(*parent_index as usize) {
                     indices.push(vertices.len() as u32);
                     vertices.push(positions[i].into());
                     indices.push(vertices.len() as u32);
-                    vertices.push(positions[parent].into());
+                    vertices.push((*parent).into());
                 }
             }
 
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 9dae0010dc80c..edafddd925da4 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -131,7 +131,7 @@ async fn load_gltf<'a, 'b>(
                     .read_colors(0)
                     .map(|v| VertexAttributeValues::Uchar4(v.into_rgba_u8().collect()))
                 {
-                    mesh.set_attribute(Mesh::ATTRIBUTE_WEIGHT, color_attribute);
+                    mesh.set_attribute(Mesh::ATTRIBUTE_COLOR, color_attribute);
                 }
 
                 if let Some(weight_attribute) = reader
@@ -161,27 +161,30 @@ async fn load_gltf<'a, 'b>(
 
         let reader = skin.reader(|buffer| Some(&buffer_data[buffer.index()]));
         if let Some(inverse_bind_matrices) = reader.read_inverse_bind_matrices() {
-            let mut bones_names = vec![];
-            let mut bones_parents = vec![];
+            let mut entities_parent_and_name = vec![];
 
-            for joint in skin.joints() {
-                bones_names.push(joint.name().expect("unnamed bone").to_string());
+            // Skeleton root node
+            entities_parent_and_name.push((u16::MAX, Name::from_str("")));
 
-                if let Some(parent) = parents[joint.index()] {
-                    bones_parents.push(skin.joints().position(|j| j.index() == parent));
-                } else {
-                    bones_parents.push(None);
-                }
+            for joint in skin.joints() {
+                entities_parent_and_name.push((
+                    parents[joint.index()]
+                        .and_then(|parent| skin.joints().position(|j| j.index() == parent))
+                        .map(|parent| parent + 1)
+                        .unwrap_or(0) as u16,
+                    Name::from_str(joint.name().expect("unnamed bone")),
+                ));
             }
 
             load_context.set_labeled_asset(
                 &skin_label,
-                LoadedAsset::new(MeshSkin {
+                LoadedAsset::new(SkinAsset {
                     inverse_bind_matrices: inverse_bind_matrices
                         .map(|x| Mat4::from_cols_array_2d(&x))
                         .collect(),
-                    bones_names,
-                    bones_parents,
+                    hierarchy: NamedHierarchyTree::from_parent_and_name_entities(
+                        entities_parent_and_name,
+                    ),
                 }),
             );
         }
@@ -406,17 +409,17 @@ fn load_node(
     if let Some(skin) = node.skin() {
         let skin_label = skin_label(&skin);
         let skin_asset_path = AssetPath::new_ref(load_context.path(), Some(&skin_label));
-        let skin_handle: Handle<MeshSkin> = load_context.get_handle(skin_asset_path);
+        let skin_handle: Handle<SkinAsset> = load_context.get_handle(skin_asset_path);
         world_builder.with(skin_handle);
 
         // TODO: Mesh skinner needs a at least a reference to the skeleton root for it to work
         // for this reason it need to keep track of all entities created by their index in the gltf node vec
         let skeleton_root = skin.skeleton().map_or(root_node.index(), |n| n.index());
-        world_builder.with(MeshSkinBinder::with_skeleton(
+        world_builder.with(SkinComponent::with_root(
             entity_lookup[skeleton_root].expect("missing skeleton root entity"),
         ));
 
-        world_builder.with(MeshSkinnerDebugger::default());
+        world_builder.with(SkinDebugger::default());
     }
 
     // create camera node
diff --git a/crates/bevy_render/src/mesh/mesh.rs b/crates/bevy_render/src/mesh/mesh.rs
index 10136558da215..96d84854f28c1 100644
--- a/crates/bevy_render/src/mesh/mesh.rs
+++ b/crates/bevy_render/src/mesh/mesh.rs
@@ -123,6 +123,7 @@ impl Mesh {
     pub const ATTRIBUTE_UV_0: &'static str = "Vertex_Uv";
     pub const ATTRIBUTE_WEIGHT: &'static str = "Vertex_Weight";
     pub const ATTRIBUTE_JOINT: &'static str = "Vertex_Join";
+    pub const ATTRIBUTE_COLOR: &'static str = "Vertex_Color";
 
     pub fn new(primitive_topology: PrimitiveTopology) -> Self {
         Mesh {

From 5139d2e2787f251940d4198a066fd95cfb1b3a00 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sat, 5 Dec 2020 12:48:22 -0300
Subject: [PATCH 025/153] refactor hierarchy + docs

---
 crates/bevy_animation/src/generic.rs      |   6 +-
 crates/bevy_animation/src/hierarchy.rs    | 128 ++++++++++++++++------
 crates/bevy_animation/src/lib.rs          |   4 +-
 crates/bevy_animation/src/skinned_mesh.rs |   4 +-
 crates/bevy_gltf/src/loader.rs            |   4 +-
 5 files changed, 101 insertions(+), 45 deletions(-)

diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index e8e490c551be3..635f7981b8c23 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -13,7 +13,7 @@ use std::any::TypeId;
 use std::hash::Hash;
 use std::ptr::null_mut;
 
-use super::hierarchy::NamedHierarchyTree;
+use super::hierarchy::Hierarchy;
 use super::lerping::LerpValue;
 
 // TODO: Curve/Clip need a validation during deserialization because they are
@@ -27,7 +27,7 @@ pub struct Clip {
     pub warp: bool,
     duration: f32,
     /// Entity identification made by parent index and name
-    hierarchy: NamedHierarchyTree,
+    hierarchy: Hierarchy,
     /// Attribute is made by the entity index and a string that combines
     /// component name followed by their attributes spaced by a period,
     /// like so: `"Transform.translation.x"`
@@ -45,7 +45,7 @@ impl Default for Clip {
             warp: true,
             duration: 0.0,
             // ? NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
-            hierarchy: NamedHierarchyTree::default(),
+            hierarchy: Hierarchy::default(),
             properties: vec![],
             curves: vec![],
         }
diff --git a/crates/bevy_animation/src/hierarchy.rs b/crates/bevy_animation/src/hierarchy.rs
index ddbdfb36459f6..09765c7d60be3 100644
--- a/crates/bevy_animation/src/hierarchy.rs
+++ b/crates/bevy_animation/src/hierarchy.rs
@@ -2,50 +2,58 @@ use bevy_core::prelude::*;
 use bevy_ecs::prelude::*;
 use bevy_transform::prelude::*;
 //use serde::{Deserialize, Serialize};
+use private::*;
 use smallvec::{smallvec, SmallVec};
-use std::convert::TryFrom;
 
-pub type Index = u16;
+// TODO: Create a simplified version without the children ?!
 
 /// Provides a way of describing a hierarchy or named entities
 /// and means for finding then in the world
+///
+/// By default and to save memory the nodes are indexed using `u16`
+/// but you can change it when needed.
 #[derive(Debug, Clone)]
-pub struct NamedHierarchyTree {
+pub struct Hierarchy<I: Index = u16> {
     /// Entity identification made by parent index and name
-    entities: Vec<(Index, Name)>,
+    entities: Vec<(I, Name)>,
     // ? NOTE: SmallVec<[u16; 10]> occupy the same 32 bytes as the SmallVec<[u16; 8]>, but the latter
     // ? should be only take 24 bytes using the "union" feature
-    children: Vec<SmallVec<[Index; 10]>>,
+    children: Vec<SmallVec<[I; 10]>>,
 }
 
-impl Default for NamedHierarchyTree {
+impl<I: Index> Default for Hierarchy<I> {
     fn default() -> Self {
         Self {
             // ? NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
-            entities: vec![(Index::MAX, Name::default())],
+            entities: vec![(I::MAX_VALUE, Name::default())],
             children: vec![smallvec![]],
         }
     }
 }
 
-impl NamedHierarchyTree {
-    /// Used when the hierarchy must be in a specific order
-    pub fn from_parent_and_name_entities(entities: Vec<(Index, Name)>) -> Self {
+impl<I: Index> Hierarchy<I> {
+    /// Used when the hierarchy must be in a specific order,
+    /// this function takes an vec of entities defined by their parent index
+    /// (on the same vec) and name.
+    ///
+    /// Any root entity should be indexed using `I::MAX_VALUE` or `I::MAX`.
+    ///
+    /// Many different root nodes are supported although having other roots
+    /// make hard to search entities, please refer to the documentation of
+    /// `find_entity` or `find_entity_in_world` to see how.
+    pub fn from_ordered_entities(entities: Vec<(I, Name)>) -> Self {
         let mut children = vec![];
         children.resize_with(entities.len(), || smallvec![]);
 
         for (entity_index, (parent_index, _)) in entities.iter().enumerate() {
             children
-                .get_mut(*parent_index as usize)
-                .map(|c| c.push(entity_index as Index));
+                .get_mut(parent_index.as_usize())
+                .map(|c| c.push(I::from_usize_checked(entity_index)));
         }
 
         Self { entities, children }
     }
 
-    // pub fn from_name_and_children_entities(iter: impl Iterator<Item ...>) -> Self {
-    // }
-
     /// Number of entities registered.
     #[inline(always)]
     pub fn len(&self) -> usize {
@@ -54,7 +62,7 @@ impl NamedHierarchyTree {
 
     /// Iterates over each entity parent index, name and children indexes
     #[inline(always)]
-    pub fn iter(&self) -> impl Iterator<Item = (&(Index, Name), &[Index])> {
+    pub fn iter(&self) -> impl Iterator<Item = (&(I, Name), &[I])> {
         self.entities
             .iter()
             .zip(self.children.iter().map(|c| &c[..]))
@@ -62,12 +70,12 @@ impl NamedHierarchyTree {
 
     /// Gets the entity parent index and `Name` components
     #[inline(always)]
-    pub fn get_entity(&self, entity_index: Index) -> &(Index, Name) {
-        &self.entities[entity_index as usize]
+    pub fn get_entity(&self, entity_index: I) -> &(I, Name) {
+        &self.entities[entity_index.as_usize()]
     }
 
-    pub fn depth_first<F: FnMut(Index, &Name)>(&self, entity_index: Index, visitor: &mut F) {
-        let i = entity_index as usize;
+    pub fn depth_first<F: FnMut(I, &Name)>(&self, entity_index: I, visitor: &mut F) {
+        let i = entity_index.as_usize();
         let (_, name) = &self.entities[i];
 
         visitor(entity_index, name);
@@ -79,9 +87,9 @@ impl NamedHierarchyTree {
 
     /// Adds a new entity hierarchy path separated by backslashes (`'/'`)
     /// return the entity index and if was or not inserted
-    pub fn get_or_insert_entity(&mut self, entity_path: &str) -> (Index, bool) {
+    pub fn get_or_insert_entity(&mut self, entity_path: &str) -> (I, bool) {
         let mut entity_created = false;
-        let mut entity = 0; // Start search from root
+        let mut entity = I::from_usize(0); // Start search from root
         for name in entity_path.split('/') {
             // Ignore the first '/' or '///'
             if name.is_empty() {
@@ -97,7 +105,7 @@ impl NamedHierarchyTree {
                 // ? NOTE: Conversion will never panic because the collection
                 // ? size will only increase in the else branch where a
                 // ? safe cast is performed
-                entity = e as Index;
+                entity = I::from_usize(e);
             } else {
                 // Add entity
                 let e = self.entities.len();
@@ -106,8 +114,8 @@ impl NamedHierarchyTree {
                 entity_created = true;
                 // Soft limit added to save memory, identical to the curve limit
                 let _parent = entity;
-                entity = Index::try_from(e).expect("entities limit reached");
-                self.children[_parent as usize].push(entity)
+                entity = I::from_usize_checked(e);
+                self.children[_parent.as_usize()].push(entity)
             }
         }
 
@@ -118,10 +126,10 @@ impl NamedHierarchyTree {
     ///
     /// The `NamedHierarchy` stores a the entity path in a specific way to improve search performance
     /// thus it needs to rebuilt in the human readable format
-    pub fn get_entity_path_at(&self, mut entity_index: Index) -> Option<String> {
+    pub fn get_entity_path_at(&self, mut entity_index: I) -> Option<String> {
         let mut path = None;
 
-        while let Some((parent_index, name)) = self.entities.get(entity_index as usize) {
+        while let Some((parent_index, name)) = self.entities.get(entity_index.as_usize()) {
             if let Some(path) = path.as_mut() {
                 *path = format!("{}/{}", name.as_str(), path);
             } else {
@@ -145,17 +153,21 @@ impl NamedHierarchyTree {
     ///
     /// let found_entity = named_hierarchy.find_entity(2, &mut entities_table_cache, children_query, name_query);
     /// ```
+    ///
+    /// *NOTE* Keep in mind that you can have as many root as you want
+    /// but each root must be manually find and inserted in the `entities_table_cache`
+    /// before calling this function.
     pub fn find_entity(
         &self,
-        entity_index: Index,
+        entity_index: I,
         entities_table_cache: &mut Vec<Option<Entity>>,
         children_query: &mut Query<(&Children,)>,
         name_query: &mut Query<(&Parent, &Name)>,
     ) -> Option<Entity> {
-        if let Some(entity) = &entities_table_cache[entity_index as usize] {
+        if let Some(entity) = &entities_table_cache[entity_index.as_usize()] {
             Some(*entity)
         } else {
-            let (parent_index, entity_name) = &self.entities[entity_index as usize];
+            let (parent_index, entity_name) = &self.entities[entity_index.as_usize()];
 
             // Use recursion to find the entity parent
             self.find_entity(
@@ -177,7 +189,7 @@ impl NamedHierarchyTree {
                                 }
 
                                 // Update cache
-                                entities_table_cache[entity_index as usize] = Some(**entity);
+                                entities_table_cache[entity_index.as_usize()] = Some(**entity);
                                 true
                             } else {
                                 false
@@ -202,16 +214,20 @@ impl NamedHierarchyTree {
     ///
     /// let found_entity = named_hierarchy.find_entity_in_world(2, &mut entities_table_cache, &world);
     /// ```
+    ///
+    /// *NOTE* Keep in mind that you can have as many root as you want
+    /// but each root must be manually find and inserted in the `entities_table_cache`
+    /// before calling this function.
     pub fn find_entity_in_world(
         &self,
-        entity_index: Index,
+        entity_index: I,
         entities_table_cache: &mut Vec<Option<Entity>>,
         world: &World,
     ) -> Option<Entity> {
-        if let Some(entity) = &entities_table_cache[entity_index as usize] {
+        if let Some(entity) = &entities_table_cache[entity_index.as_usize()] {
             Some(*entity)
         } else {
-            let (parent_index, entity_name) = &self.entities[entity_index as usize];
+            let (parent_index, entity_name) = &self.entities[entity_index.as_usize()];
 
             // Use recursion to find the entity parent
             self.find_entity_in_world(*parent_index, entities_table_cache, world)
@@ -230,7 +246,7 @@ impl NamedHierarchyTree {
                                     }
 
                                     // Update cache
-                                    entities_table_cache[entity_index as usize] = Some(**entity);
+                                    entities_table_cache[entity_index.as_usize()] = Some(**entity);
                                     true
                                 } else {
                                     false
@@ -244,3 +260,45 @@ impl NamedHierarchyTree {
         }
     }
 }
+
+mod private {
+    use std::convert::TryFrom;
+
+    /// Implemented by unsigned types
+    pub trait Index: Sized + PartialEq + Copy + Clone {
+        const MAX_VALUE: Self;
+
+        fn as_usize(&self) -> usize;
+        fn from_usize(index: usize) -> Self;
+        fn from_usize_checked(index: usize) -> Self;
+    }
+
+    macro_rules! impl_index {
+        ($t:ty) => {
+            impl Index for $t {
+                const MAX_VALUE: $t = <$t>::MAX;
+
+                fn as_usize(&self) -> usize {
+                    *self as usize
+                }
+
+                fn from_usize(index: usize) -> Self {
+                    index as Self
+                }
+
+                fn from_usize_checked(index: usize) -> Self {
+                    Self::try_from(index).expect(concat!(
+                        "entities limit reached, indexed with ",
+                        stringify!($t)
+                    ))
+                }
+            }
+        };
+    }
+
+    impl_index!(u8);
+    impl_index!(u16);
+    impl_index!(u32);
+    impl_index!(u64);
+    impl_index!(usize);
+}
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 699be058ae8cd..b7ccefe9d51a8 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -9,12 +9,12 @@ pub mod lerping;
 mod skinned_mesh;
 
 pub use crate::generic::*;
-pub use crate::hierarchy::NamedHierarchyTree;
+pub use crate::hierarchy::Hierarchy;
 pub use crate::skinned_mesh::*;
 
 pub mod prelude {
     pub use crate::generic::{Animator, Clip, Curve, CurveUntyped};
-    pub use crate::hierarchy::NamedHierarchyTree;
+    pub use crate::hierarchy::Hierarchy;
     pub use crate::lerping::LerpValue;
     pub use crate::skinned_mesh::{SkinAsset, SkinComponent, SkinDebugger};
 }
diff --git a/crates/bevy_animation/src/skinned_mesh.rs b/crates/bevy_animation/src/skinned_mesh.rs
index 2991509be9e5a..129f963b2287c 100644
--- a/crates/bevy_animation/src/skinned_mesh.rs
+++ b/crates/bevy_animation/src/skinned_mesh.rs
@@ -1,5 +1,5 @@
 // TODO: Later merge with bevy_animation
-use crate::hierarchy::NamedHierarchyTree;
+use crate::hierarchy::Hierarchy;
 use bevy_asset::{Assets, Handle};
 use bevy_core::Name;
 use bevy_ecs::prelude::*;
@@ -27,7 +27,7 @@ pub struct SkinAsset {
     /// Inverse bind matrices in root node space
     pub inverse_bind_matrices: Vec<Mat4>,
     /// Skin joint hierarchy, plus one extra the root node as the first entry.
-    pub hierarchy: NamedHierarchyTree,
+    pub hierarchy: Hierarchy,
 }
 
 #[derive(Default, Debug, Clone, TypeUuid, RenderResources)]
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index edafddd925da4..1b6883e5220d6 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -182,9 +182,7 @@ async fn load_gltf<'a, 'b>(
                     inverse_bind_matrices: inverse_bind_matrices
                         .map(|x| Mat4::from_cols_array_2d(&x))
                         .collect(),
-                    hierarchy: NamedHierarchyTree::from_parent_and_name_entities(
-                        entities_parent_and_name,
-                    ),
+                    hierarchy: Hierarchy::from_ordered_entities(entities_parent_and_name),
                 }),
             );
         }

From 740a8b4194cfca9fcbbba23e4a04b620bc5c6142 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sat, 5 Dec 2020 13:37:32 -0300
Subject: [PATCH 026/153] working on a custom animator like the original
 bevy_animator

---
 crates/bevy_animation/src/custom.rs | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 crates/bevy_animation/src/custom.rs

diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
new file mode 100644
index 0000000000000..8feedd9c1238a
--- /dev/null
+++ b/crates/bevy_animation/src/custom.rs
@@ -0,0 +1,29 @@
+struct ClipBind {
+    entities: Vec<Option<Entity>>,
+}
+
+pub struct Animator {
+    clips: Vec<Handle<Clip>>,
+    binds: Vec<Option<ClipBind>>,
+}
+
+struct ClipProperties(HashMap<String, SmallVec<[u16; 10]>>);
+
+pub struct AnimatorProperties {
+    map: HashMap<WeakHandle<Clip>, ClipProperties>,
+}
+
+#[derive(Default)]
+struct AnimatorState {
+    clips_event_reader: EventReader<AssetEvent<Clip>>,
+}
+
+fn animator_udpate(
+    mut state: Local<AnimatorState>,
+    clips: Res<Assets<Clip>>,
+    clip_events: Res<Events<AssetEvent<Clip>>>,
+    mut animators_properties: ResMut<AnimatorProperties>,
+    animators_query: Query<(&Animator,)>,
+) {
+    //
+}

From 62954ba51b2c7bff2f53282de9f5c8a2d73e906b Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sat, 5 Dec 2020 20:34:01 -0300
Subject: [PATCH 027/153] strip curve and clip into separated files, concept
 proof of a safer system

---
 crates/bevy_animation/src/clip.rs    | 156 +++++++++++
 crates/bevy_animation/src/curve.rs   | 198 ++++++++++++++
 crates/bevy_animation/src/custom.rs  | 309 +++++++++++++++++++++-
 crates/bevy_animation/src/generic.rs | 373 +--------------------------
 crates/bevy_animation/src/lib.rs     |  10 +-
 5 files changed, 672 insertions(+), 374 deletions(-)
 create mode 100644 crates/bevy_animation/src/clip.rs
 create mode 100644 crates/bevy_animation/src/curve.rs

diff --git a/crates/bevy_animation/src/clip.rs b/crates/bevy_animation/src/clip.rs
new file mode 100644
index 0000000000000..5152df8e365f9
--- /dev/null
+++ b/crates/bevy_animation/src/clip.rs
@@ -0,0 +1,156 @@
+use bevy_type_registry::TypeUuid;
+
+use super::curve::CurveUntyped;
+use super::hierarchy::Hierarchy;
+
+// TODO: Curve/Clip need a validation during deserialization because they are
+// structured as SOA (struct of arrays), so the vec's length must match
+
+// TODO: impl Serialize, Deserialize
+#[derive(Debug, Clone, TypeUuid)]
+#[uuid = "4c76e6c3-706d-4a74-af8e-4f48033e0733"]
+pub struct Clip {
+    //#[serde(default = "clip_default_warp")]
+    pub warp: bool,
+    duration: f32,
+    /// Entity identification made by parent index and name
+    pub(crate) hierarchy: Hierarchy,
+    /// Attribute is made by the entity index and a string that combines
+    /// component name followed by their attributes spaced by a period,
+    /// like so: `"Transform.translation.x"`
+    pub(crate) properties: Vec<(u16, String)>,
+    pub(crate) curves: Vec<CurveUntyped>,
+}
+
+// fn clip_default_warp() -> bool {
+//     true
+// }
+
+impl Default for Clip {
+    fn default() -> Self {
+        Self {
+            warp: true,
+            duration: 0.0,
+            // ? NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
+            hierarchy: Hierarchy::default(),
+            properties: vec![],
+            curves: vec![],
+        }
+    }
+}
+
+impl Clip {
+    /// Property to be animated must be in the following format `"path/to/named_entity@Transform.translation.x"`
+    /// where the left side `@` defines a path to the entity to animate,
+    /// while the right side the path to a property to animate starting from the component.
+    ///
+    /// *NOTE* This is a expensive function
+    pub fn add_animated_prop(&mut self, property_path: &str, mut curve: CurveUntyped) {
+        // Clip an only have some amount of curves and entities
+        // this limitation was added to save memory (but you can increase it if you want)
+        assert!(
+            (self.curves.len() as u16) <= u16::MAX,
+            "curve limit reached"
+        );
+
+        // Split in entity and attribute path,
+        // NOTE: use rfind because it's expected the latter to be generally shorter
+        let path =
+            property_path.split_at(property_path.rfind('@').expect("property path missing @"));
+
+        let (entity1, just_created) = self.hierarchy.get_or_insert_entity(path.0);
+        let name1 = path.1.split_at(1).1;
+
+        // If some entity was created it means this property is a new one so we can safely skip the attribute testing
+        if !just_created {
+            for (i, entry) in self.properties.iter().enumerate() {
+                let (entity0, name0) = entry;
+
+                if *entity0 != entity1 {
+                    continue;
+                }
+
+                let mid = name1.len().min(name0.len());
+                let (head0, tail0) = name0.split_at(mid);
+                let (head1, tail1) = name1.split_at(mid);
+
+                if head0 == head1 {
+                    // Replace
+                    if tail0.len() == 0 && tail1.len() == 0 {
+                        // Found a property are equal the one been inserted
+                        // Replace curve, the property was already added, this is very important
+                        // because it guarantees that each property will have unique access to some
+                        // attribute during the update stages
+
+                        let inserted_duration = curve.duration();
+                        std::mem::swap(&mut self.curves[i], &mut curve);
+                        self.update_duration(curve.duration(), inserted_duration);
+                        return;
+                    } else {
+                        // Check the inserted attribute is nested of an already present attribute
+                        // NOTE: ".../Enity0@Transform.translation" and ".../Enity0@Transform.translation.x"
+                        // can't coexist because it may cause a problems of non unique access
+                        if tail0.starts_with('.') || tail1.starts_with('.') {
+                            panic!("nesting properties");
+                        }
+                    }
+                }
+            }
+        }
+
+        self.duration = self.duration.max(curve.duration());
+        self.properties.push((entity1, name1.to_string()));
+        self.curves.push(curve);
+    }
+
+    /// Number of animated properties in this clip
+    #[inline(always)]
+    pub fn len(&self) -> u16 {
+        self.curves.len() as u16
+    }
+
+    /// Returns the property curve property path.
+    ///
+    /// The clip stores a property path in a specific way to improve search performance
+    /// thus it needs to rebuilt the curve property path in the human readable format
+    pub fn get_property_path(&self, index: u16) -> String {
+        let (entity_index, name) = &self.properties[index as usize];
+        format!(
+            "{}@{}",
+            self.hierarchy
+                .get_entity_path_at(*entity_index)
+                .expect("property as an invalid entity"),
+            name.as_str()
+        )
+    }
+
+    /// Clip duration
+    #[inline(always)]
+    pub fn duration(&self) -> f32 {
+        self.duration
+    }
+
+    /// Updates the clip duration based of the inserted and removed curve durations
+    /// *WARNING* The curve must be already replaced before call this function
+    fn update_duration(&mut self, removed_duration: f32, inserted_duration: f32) {
+        if removed_duration == inserted_duration {
+            // If precisely matches the inserted curve duration we don't need to update anything
+        } else if float_cmp::approx_eq!(f32, removed_duration, self.duration, ulps = 2) {
+            // At this point the duration for the removed curve is the same as self.duration
+            // this mean that we have to compute the clip duration from scratch;
+            //
+            // NOTE: I opted for am approximated float comparison because it's better
+            // to do all the this work than get a hard to debug glitch
+            // TODO: Review approximated comparison
+
+            self.duration = self
+                .curves
+                .iter()
+                .map(|c| c.duration())
+                .fold(0.0, |acc, x| acc.max(x));
+        } else {
+            // Faster clip duration update
+            self.duration = self.duration.max(inserted_duration);
+        }
+    }
+}
diff --git a/crates/bevy_animation/src/curve.rs b/crates/bevy_animation/src/curve.rs
new file mode 100644
index 0000000000000..87c55b0dfcbf2
--- /dev/null
+++ b/crates/bevy_animation/src/curve.rs
@@ -0,0 +1,198 @@
+use bevy_math::prelude::*;
+use std::any::TypeId;
+
+use super::lerping::LerpValue;
+
+// TODO: impl Serialize, Deserialize
+#[derive(Debug, Clone)]
+pub enum CurveUntyped {
+    Float(Curve<f32>),
+    //Vec2(Curve<Vec2>),
+    Vec3(Curve<Vec3>),
+    Vec4(Curve<Vec4>),
+    Quat(Curve<Quat>),
+    //Handle(Curve<HandleUntyped>),
+    // TODO: Color(Curve<Color>),
+}
+
+macro_rules! untyped_fn {
+    ($v:vis fn $name:ident ( &self, $( $arg:ident : $arg_ty:ty ,)* ) $(-> $ret:ty)* ) => {
+        $v fn $name(&self, $( $arg : $arg_ty ),*) $(-> $ret)* {
+            match self {
+                CurveUntyped::Float(v) => v.$name($($arg,)*),
+                CurveUntyped::Vec3(v) => v.$name($($arg,)*),
+                CurveUntyped::Vec4(v) => v.$name($($arg,)*),
+                CurveUntyped::Quat(v) => v.$name($($arg,)*),
+            }
+        }
+    };
+}
+
+impl CurveUntyped {
+    untyped_fn!(pub fn duration(&self,) -> f32);
+    untyped_fn!(pub fn value_type(&self,) -> TypeId);
+    //untyped_fn!(pub fn add_time_offset(&mut self, time: f32,) -> ());
+
+    pub fn add_time_offset(&mut self, time: f32) {
+        match self {
+            CurveUntyped::Float(v) => v.add_offset_time(time),
+            CurveUntyped::Vec3(v) => v.add_offset_time(time),
+            CurveUntyped::Vec4(v) => v.add_offset_time(time),
+            CurveUntyped::Quat(v) => v.add_offset_time(time),
+        }
+    }
+}
+
+// TODO: Curve/Clip need a validation during deserialization because they are
+// structured as SOA (struct of arrays), so the vec's length must match
+
+// TODO: impl Serialize, Deserialize
+#[derive(Default, Debug)]
+pub struct Curve<T> {
+    // TODO: Step / Linear / Spline variants
+    samples: Vec<f32>,
+    //tangents: Vec<(f32, f32)>,
+    values: Vec<T>,
+}
+
+impl<T: Clone> Clone for Curve<T> {
+    fn clone(&self) -> Self {
+        Self {
+            samples: self.samples.clone(),
+            values: self.values.clone(),
+        }
+    }
+}
+
+impl<T> Curve<T>
+where
+    T: LerpValue + Clone + 'static,
+{
+    pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
+        // TODO: Result?
+
+        // Make sure both have the same length
+        assert!(
+            samples.len() == values.len(),
+            "samples and values must have the same length"
+        );
+
+        assert!(samples.len() > 0, "empty curve");
+
+        // Make sure the
+        assert!(
+            samples
+                .iter()
+                .zip(samples.iter().skip(1))
+                .all(|(a, b)| a < b),
+            "time samples must be on ascending order"
+        );
+        Self { samples, values }
+    }
+
+    pub fn from_linear(t0: f32, t1: f32, v0: T, v1: T) -> Self {
+        Self {
+            samples: if t1 >= t0 { vec![t0, t1] } else { vec![t1, t0] },
+            values: vec![v0, v1],
+        }
+    }
+
+    pub fn from_constant(v: T) -> Self {
+        Self {
+            samples: vec![0.0],
+            values: vec![v],
+        }
+    }
+
+    pub fn duration(&self) -> f32 {
+        self.samples.last().copied().unwrap_or(0.0)
+    }
+
+    /// Easer to use sampling method that don't have time restrictions or needs
+    /// the keyframe index, but is more expensive always `O(n)`. Which means
+    /// sampling takes longer to evaluate as much as time get closer to curve duration
+    /// and it get worse with more keyframes.
+    pub fn sample(&self, time: f32) -> T {
+        // Index guessing gives a small search optimization
+        let index = if time < self.duration() * 0.5 {
+            0
+        } else {
+            self.samples.len() - 1
+        };
+
+        self.sample_indexed(index, time).1
+    }
+
+    /// Samples the curve starting from some keyframe index, this make the common case `O(1)`
+    pub fn sample_indexed(&self, mut index: usize, time: f32) -> (usize, T) {
+        // Adjust for the current keyframe index
+        let last_index = self.samples.len() - 1;
+
+        index = index.max(0).min(last_index);
+        if self.samples[index] < time {
+            // Forward search
+            loop {
+                if index == last_index {
+                    return (last_index, self.values.last().unwrap().clone());
+                }
+                index += 1;
+
+                if self.samples[index] >= time {
+                    break;
+                }
+            }
+        } else {
+            // Backward search
+            loop {
+                if index == 0 {
+                    return (0, self.values.last().unwrap().clone());
+                }
+
+                let i = index - 1;
+                if self.samples[i] <= time {
+                    break;
+                }
+
+                index = i;
+            }
+        }
+
+        // Lerp the value
+        let i = index - 1;
+        let previous_time = self.samples[i];
+        let t = (time - previous_time) / (self.samples[index] - previous_time);
+        debug_assert!(t >= 0.0 && t <= 1.0, "t = {} but should be normalized", t); // Checks if it's required to normalize t
+        let value = T::lerp(&self.values[i], &self.values[index], t);
+
+        (index, value)
+    }
+
+    pub fn add_offset_time(&mut self, time_offset: f32) {
+        self.samples.iter_mut().for_each(|t| *t += time_offset);
+    }
+
+    // pub fn insert(&mut self, time_sample: f32, value: T) {
+    // }
+
+    // pub fn remove(&mut self, index: usize) {
+    //assert!(samples.len() > 1, "curve can't be empty");
+    // }
+
+    pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
+        self.samples.iter().copied().zip(self.values.iter())
+    }
+
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
+        self.samples.iter().copied().zip(self.values.iter_mut())
+    }
+
+    #[inline(always)]
+    pub fn value_type(&self) -> TypeId {
+        TypeId::of::<T>()
+    }
+
+    #[inline(always)]
+    pub fn value_size(&self) -> usize {
+        std::mem::size_of::<T>()
+    }
+}
diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 8feedd9c1238a..5b0842f8beb74 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -1,29 +1,316 @@
-struct ClipBind {
-    entities: Vec<Option<Entity>>,
+use anyhow::Result;
+use bevy_app::prelude::{EventReader, Events};
+use bevy_asset::{AssetEvent, Assets, Handle /*, HandleUntyped*/};
+use bevy_core::prelude::*;
+use bevy_ecs::prelude::*;
+use bevy_ecs::{Location, SystemId};
+use bevy_math::prelude::*;
+use bevy_property::{Properties, Property, PropertyType};
+use bevy_transform::prelude::*;
+use bevy_type_registry::{TypeRegistry, TypeUuid};
+//use serde::{Deserialize, Serialize};
+use fnv::FnvHashMap;
+use smallvec::{smallvec, SmallVec};
+use std::any::TypeId;
+use std::hash::Hash;
+use std::ptr::null_mut;
+
+use super::hierarchy::Hierarchy;
+use super::lerping::LerpValue;
+
+use super::clip::Clip;
+use super::curve::CurveUntyped;
+
+#[derive(Debug, Clone, Properties)]
+pub struct Layer {
+    pub weight: f32,
+    pub clip_index: u16,
+    pub time: f32,
+    pub time_scale: f32,
+    keyframe: Vec<usize>,
+}
+
+impl Default for Layer {
+    fn default() -> Self {
+        Layer {
+            weight: 1.0,
+            clip_index: 0,
+            time: 0.0,
+            time_scale: 1.0,
+            keyframe: vec![],
+        }
+    }
 }
 
+#[derive(Debug, Properties)]
 pub struct Animator {
     clips: Vec<Handle<Clip>>,
-    binds: Vec<Option<ClipBind>>,
+    #[property(ignore)]
+    bind_clips: Vec<ClipBind>,
+    pub time_scale: f32,
+    pub layers: Vec<Layer>,
+}
+
+#[derive(Default, Debug)]
+struct ClipBind {
+    entities: Vec<Option<Entity>>,
 }
 
-struct ClipProperties(HashMap<String, SmallVec<[u16; 10]>>);
+///////////////////////////////////////////////////////////////////////////////
 
-pub struct AnimatorProperties {
-    map: HashMap<WeakHandle<Clip>, ClipProperties>,
+#[derive(Debug)]
+pub struct PropDescriptor {
+    pub entity_index: u16,
+    pub curve_index: u16,
+}
+
+#[derive(Default, Debug)]
+pub struct Props(FnvHashMap<String, SmallVec<[PropDescriptor; 4]>>);
+
+impl Props {
+    fn new(clip: &Clip) -> Self {
+        let mut props = Props::default();
+        for ((curve_index, _), (entity_index, prop_name)) in
+            clip.curves.iter().enumerate().zip(clip.properties.iter())
+        {
+            let desc = PropDescriptor {
+                entity_index: *entity_index as u16,
+                curve_index: curve_index as u16,
+            };
+
+            if let Some(v) = props.0.get_mut(prop_name) {
+                v.push(desc);
+                continue;
+            }
+
+            props.0.insert(prop_name.to_owned(), smallvec![desc]);
+        }
+        props
+    }
+
+    #[inline(always)]
+    pub fn get(&self, name: &str) -> Option<&[PropDescriptor]> {
+        self.0.get(name).map(|sv| &sv[..])
+    }
+}
+
+#[derive(Default, Debug)]
+pub struct ClipProps(FnvHashMap<Handle<Clip>, Props>);
+
+impl ClipProps {
+    #[inline(always)]
+    pub fn get(&self, clip_handle: &Handle<Clip>) -> Option<&Props> {
+        self.0.get(&clip_handle.as_weak())
+    }
 }
 
 #[derive(Default)]
-struct AnimatorState {
+pub(crate) struct AnimatorState {
     clips_event_reader: EventReader<AssetEvent<Clip>>,
 }
 
-fn animator_udpate(
+pub(crate) fn animator_udpate(
     mut state: Local<AnimatorState>,
+    time: Res<Time>,
     clips: Res<Assets<Clip>>,
     clip_events: Res<Events<AssetEvent<Clip>>>,
-    mut animators_properties: ResMut<AnimatorProperties>,
-    animators_query: Query<(&Animator,)>,
+    mut clip_props: ResMut<ClipProps>,
+    mut animators_query: Query<(Entity, &mut Animator)>,
+    mut children_query: Query<(&Children,)>,
+    mut name_query: Query<(&Parent, &Name)>,
 ) {
-    //
+    // Create clip props
+    for event in state.clips_event_reader.iter(&clip_events) {
+        match event {
+            AssetEvent::Removed { handle } => {
+                clip_props.0.remove(&handle);
+            }
+            AssetEvent::Created { handle } | AssetEvent::Modified { handle } => {
+                let clip = clips.get(handle).expect("missing asset");
+                clip_props.0.insert(handle.as_weak(), Props::new(clip));
+            }
+        };
+    }
+
+    let delta_time = time.delta_seconds;
+
+    for (animator_entity, mut animator) in animators_query.iter_mut() {
+        let animator = &mut *animator;
+
+        // Time scales by component
+        let delta_time = delta_time * animator.time_scale;
+
+        let w_total = animator
+            .layers
+            .iter()
+            .fold(0.0, |w, layer| w + layer.weight);
+
+        let norm = 1.0 / w_total;
+
+        // Normalize all states weights
+        for layer in &mut animator.layers {
+            layer.weight *= norm;
+        }
+
+        // Make run for the binds
+        animator
+            .bind_clips
+            .resize_with(animator.clips.len(), ClipBind::default);
+
+        for (clip_index, clip_handle) in animator.clips.iter().enumerate() {
+            if let Some(clip) = clips.get(clip_handle) {
+                let bind = &mut animator.bind_clips[clip_index];
+
+                // Prepare the entities table cache
+                bind.entities.clear();
+                bind.entities.resize(clip.hierarchy.len(), None);
+                // Assign the root entity as the first element
+                bind.entities[0] = Some(animator_entity);
+
+                // Find entitites ...
+                for entity_index in 1..clip.hierarchy.len() {
+                    clip.hierarchy.find_entity(
+                        entity_index as u16,
+                        &mut bind.entities,
+                        &mut children_query,
+                        &mut name_query,
+                    );
+                }
+
+                let curves_count = clip.curves.len();
+
+                for layer in &mut animator.layers {
+                    if layer.clip_index as usize != clip_index {
+                        continue;
+                    }
+
+                    // Ensure capacity for cached keyframe index vec
+                    if layer.keyframe.len() != curves_count {
+                        layer.keyframe.clear();
+                        layer
+                            .keyframe
+                            .resize_with(curves_count, || Default::default());
+                    }
+
+                    // Update time
+                    let mut time = layer.time + delta_time * layer.time_scale;
+
+                    // Warp mode
+                    if clip.warp {
+                        // Warp Around
+                        if time > clip.duration() {
+                            time = (time / clip.duration()).fract() * clip.duration();
+                            // Reset all keyframes cached indexes
+                            layer
+                                .keyframe
+                                .iter_mut()
+                                .for_each(|x| *x = Default::default())
+                        }
+                    } else {
+                        // Hold
+                        time = time.min(clip.duration());
+                    }
+
+                    // Advance state time
+                    layer.time = time;
+                }
+            }
+        }
+    }
+}
+
+pub(crate) fn animator_transform_update(
+    clips: Res<Assets<Clip>>,
+    clip_props: Res<ClipProps>,
+    mut animators_query: Query<(&mut Animator,)>,
+    mut transform_query: Query<(&mut Transform,)>,
+) {
+    for (mut animator,) in animators_query.iter_mut() {
+        let animator = &mut *animator;
+
+        for layer in &mut animator.layers {
+            let w = layer.weight;
+            if w < 1.0e-8 {
+                continue;
+            }
+
+            let time = layer.time;
+            let clip_index = layer.clip_index as usize;
+
+            if let Some(bind) = animator.bind_clips.get(clip_index) {
+                if let Some(clip_handle) = animator.clips.get(clip_index) {
+                    if let Some(clip) = clips.get(clip_handle) {
+                        if let Some(clip_props) = clip_props.get(clip_handle) {
+                            // Update properties
+                            for prop in clip_props.get("Transform.translation").unwrap_or(&[]) {
+                                if let Some(entity) = bind.entities[prop.entity_index as usize] {
+                                    let curve_index = prop.curve_index as usize;
+                                    match &clip.curves[curve_index] {
+                                        CurveUntyped::Vec3(curve) => {
+                                            // TODO: Expensive query
+                                            if let Ok((mut transform,)) =
+                                                transform_query.get_mut(entity)
+                                            {
+                                                let (k, v) = curve.sample_indexed(
+                                                    layer.keyframe[curve_index],
+                                                    time,
+                                                );
+                                                transform.translation = v;
+                                                layer.keyframe[curve_index] = k;
+                                            }
+                                        }
+                                        _ => {}
+                                    }
+                                }
+                            }
+
+                            for prop in clip_props.get("Transform.rotation").unwrap_or(&[]) {
+                                if let Some(entity) = bind.entities[prop.entity_index as usize] {
+                                    let curve_index = prop.curve_index as usize;
+                                    match &clip.curves[curve_index] {
+                                        CurveUntyped::Quat(curve) => {
+                                            // TODO: Expensive query
+                                            if let Ok((mut transform,)) =
+                                                transform_query.get_mut(entity)
+                                            {
+                                                let (k, v) = curve.sample_indexed(
+                                                    layer.keyframe[curve_index],
+                                                    time,
+                                                );
+                                                transform.rotation = v;
+                                                layer.keyframe[curve_index] = k;
+                                            }
+                                        }
+                                        _ => {}
+                                    }
+                                }
+                            }
+
+                            for prop in clip_props.get("Transform.scale").unwrap_or(&[]) {
+                                if let Some(entity) = bind.entities[prop.entity_index as usize] {
+                                    let curve_index = prop.curve_index as usize;
+                                    match &clip.curves[curve_index] {
+                                        CurveUntyped::Vec3(curve) => {
+                                            // TODO: Expensive query
+                                            if let Ok((mut transform,)) =
+                                                transform_query.get_mut(entity)
+                                            {
+                                                let (k, v) = curve.sample_indexed(
+                                                    layer.keyframe[curve_index],
+                                                    time,
+                                                );
+                                                transform.scale = v;
+                                                layer.keyframe[curve_index] = k;
+                                            }
+                                        }
+                                        _ => {}
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
 }
diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 635f7981b8c23..6c616b5825b5b 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -7,366 +7,16 @@ use bevy_ecs::{Location, SystemId};
 use bevy_math::prelude::*;
 use bevy_property::{Properties, Property, PropertyType};
 use bevy_transform::prelude::*;
-use bevy_type_registry::{TypeRegistry, TypeUuid};
+use bevy_type_registry::TypeRegistry;
 //use serde::{Deserialize, Serialize};
 use std::any::TypeId;
 use std::hash::Hash;
 use std::ptr::null_mut;
 
-use super::hierarchy::Hierarchy;
+use super::clip::Clip;
+use super::curve::CurveUntyped;
 use super::lerping::LerpValue;
 
-// TODO: Curve/Clip need a validation during deserialization because they are
-// structured as SOA (struct of arrays), so the vec's length must match
-
-// TODO: impl Serialize, Deserialize
-#[derive(Debug, Clone, TypeUuid)]
-#[uuid = "4c76e6c3-706d-4a74-af8e-4f48033e0733"]
-pub struct Clip {
-    //#[serde(default = "clip_default_warp")]
-    pub warp: bool,
-    duration: f32,
-    /// Entity identification made by parent index and name
-    hierarchy: Hierarchy,
-    /// Attribute is made by the entity index and a string that combines
-    /// component name followed by their attributes spaced by a period,
-    /// like so: `"Transform.translation.x"`
-    properties: Vec<(u16, String)>,
-    curves: Vec<CurveUntyped>,
-}
-
-// fn clip_default_warp() -> bool {
-//     true
-// }
-
-impl Default for Clip {
-    fn default() -> Self {
-        Self {
-            warp: true,
-            duration: 0.0,
-            // ? NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
-            hierarchy: Hierarchy::default(),
-            properties: vec![],
-            curves: vec![],
-        }
-    }
-}
-
-impl Clip {
-    /// Property to be animated must be in the following format `"path/to/named_entity@Transform.translation.x"`
-    /// where the left side `@` defines a path to the entity to animate,
-    /// while the right side the path to a property to animate starting from the component.
-    ///
-    /// *NOTE* This is a expensive function
-    pub fn add_animated_prop(&mut self, property_path: &str, mut curve: CurveUntyped) {
-        // Clip an only have some amount of curves and entities
-        // this limitation was added to save memory (but you can increase it if you want)
-        assert!(
-            (self.curves.len() as u16) <= u16::MAX,
-            "curve limit reached"
-        );
-
-        // Split in entity and attribute path,
-        // NOTE: use rfind because it's expected the latter to be generally shorter
-        let path =
-            property_path.split_at(property_path.rfind('@').expect("property path missing @"));
-
-        let (entity1, just_created) = self.hierarchy.get_or_insert_entity(path.0);
-        let name1 = path.1.split_at(1).1;
-
-        // If some entity was created it means this property is a new one so we can safely skip the attribute testing
-        if !just_created {
-            for (i, entry) in self.properties.iter().enumerate() {
-                let (entity0, name0) = entry;
-
-                if *entity0 != entity1 {
-                    continue;
-                }
-
-                let mid = name1.len().min(name0.len());
-                let (head0, tail0) = name0.split_at(mid);
-                let (head1, tail1) = name1.split_at(mid);
-
-                if head0 == head1 {
-                    // Replace
-                    if tail0.len() == 0 && tail1.len() == 0 {
-                        // Found a property are equal the one been inserted
-                        // Replace curve, the property was already added, this is very important
-                        // because it guarantees that each property will have unique access to some
-                        // attribute during the update stages
-
-                        let inserted_duration = curve.duration();
-                        std::mem::swap(&mut self.curves[i], &mut curve);
-                        self.update_duration(curve.duration(), inserted_duration);
-                        return;
-                    } else {
-                        // Check the inserted attribute is nested of an already present attribute
-                        // NOTE: ".../Enity0@Transform.translation" and ".../Enity0@Transform.translation.x"
-                        // can't coexist because it may cause a problems of non unique access
-                        if tail0.starts_with('.') || tail1.starts_with('.') {
-                            panic!("nesting properties");
-                        }
-                    }
-                }
-            }
-        }
-
-        self.duration = self.duration.max(curve.duration());
-        self.properties.push((entity1, name1.to_string()));
-        self.curves.push(curve);
-    }
-
-    /// Number of animated properties in this clip
-    #[inline(always)]
-    pub fn len(&self) -> u16 {
-        self.curves.len() as u16
-    }
-
-    /// Returns the property curve property path.
-    ///
-    /// The clip stores a property path in a specific way to improve search performance
-    /// thus it needs to rebuilt the curve property path in the human readable format
-    pub fn get_property_path(&self, index: u16) -> String {
-        let (entity_index, name) = &self.properties[index as usize];
-        format!(
-            "{}@{}",
-            self.hierarchy
-                .get_entity_path_at(*entity_index)
-                .expect("property as an invalid entity"),
-            name.as_str()
-        )
-    }
-
-    /// Clip duration
-    #[inline(always)]
-    pub fn duration(&self) -> f32 {
-        self.duration
-    }
-
-    /// Updates the clip duration based of the inserted and removed curve durations
-    /// *WARNING* The curve must be already replaced before call this function
-    fn update_duration(&mut self, removed_duration: f32, inserted_duration: f32) {
-        if removed_duration == inserted_duration {
-            // If precisely matches the inserted curve duration we don't need to update anything
-        } else if float_cmp::approx_eq!(f32, removed_duration, self.duration, ulps = 2) {
-            // At this point the duration for the removed curve is the same as self.duration
-            // this mean that we have to compute the clip duration from scratch;
-            //
-            // NOTE: I opted for am approximated float comparison because it's better
-            // to do all the this work than get a hard to debug glitch
-            // TODO: Review approximated comparison
-
-            self.duration = self
-                .curves
-                .iter()
-                .map(|c| c.duration())
-                .fold(0.0, |acc, x| acc.max(x));
-        } else {
-            // Faster clip duration update
-            self.duration = self.duration.max(inserted_duration);
-        }
-    }
-}
-
-// TODO: Not found clip masks very useful, right now you can slone the cu
-// /// Masks clip
-// pub struct ClipMask {
-//     /// Entity identification made by parent index and name
-//     entities: Vec<(u16, String)>,
-//     masked: Vec<u16>,
-// }
-
-// TODO: impl Serialize, Deserialize
-#[derive(Debug, Clone)]
-pub enum CurveUntyped {
-    Float(Curve<f32>),
-    //Vec2(Curve<Vec2>),
-    Vec3(Curve<Vec3>),
-    Vec4(Curve<Vec4>),
-    Quat(Curve<Quat>),
-    //Handle(Curve<HandleUntyped>),
-    // TODO: Color(Curve<Color>),
-}
-
-macro_rules! untyped_fn {
-    ($v:vis fn $name:ident ( &self, $( $arg:ident : $arg_ty:ty ,)* ) $(-> $ret:ty)* ) => {
-        $v fn $name(&self, $( $arg : $arg_ty ),*) $(-> $ret)* {
-            match self {
-                CurveUntyped::Float(v) => v.$name($($arg,)*),
-                CurveUntyped::Vec3(v) => v.$name($($arg,)*),
-                CurveUntyped::Vec4(v) => v.$name($($arg,)*),
-                CurveUntyped::Quat(v) => v.$name($($arg,)*),
-            }
-        }
-    };
-}
-
-impl CurveUntyped {
-    untyped_fn!(pub fn duration(&self,) -> f32);
-    untyped_fn!(pub fn value_type(&self,) -> TypeId);
-    //untyped_fn!(pub fn add_time_offset(&mut self, time: f32,) -> ());
-
-    pub fn add_time_offset(&mut self, time: f32) {
-        match self {
-            CurveUntyped::Float(v) => v.add_offset_time(time),
-            CurveUntyped::Vec3(v) => v.add_offset_time(time),
-            CurveUntyped::Vec4(v) => v.add_offset_time(time),
-            CurveUntyped::Quat(v) => v.add_offset_time(time),
-        }
-    }
-}
-
-// TODO: impl Serialize, Deserialize
-#[derive(Default, Debug)]
-pub struct Curve<T> {
-    // TODO: Step / Linear / Spline variants
-    samples: Vec<f32>,
-    //tangents: Vec<(f32, f32)>,
-    values: Vec<T>,
-}
-
-impl<T: Clone> Clone for Curve<T> {
-    fn clone(&self) -> Self {
-        Self {
-            samples: self.samples.clone(),
-            values: self.values.clone(),
-        }
-    }
-}
-
-impl<T> Curve<T>
-where
-    T: LerpValue + Clone + 'static,
-{
-    pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
-        // TODO: Result?
-
-        // Make sure both have the same length
-        assert!(
-            samples.len() == values.len(),
-            "samples and values must have the same length"
-        );
-
-        assert!(samples.len() > 0, "empty curve");
-
-        // Make sure the
-        assert!(
-            samples
-                .iter()
-                .zip(samples.iter().skip(1))
-                .all(|(a, b)| a < b),
-            "time samples must be on ascending order"
-        );
-        Self { samples, values }
-    }
-
-    pub fn from_linear(t0: f32, t1: f32, v0: T, v1: T) -> Self {
-        Self {
-            samples: if t1 >= t0 { vec![t0, t1] } else { vec![t1, t0] },
-            values: vec![v0, v1],
-        }
-    }
-
-    pub fn from_constant(v: T) -> Self {
-        Self {
-            samples: vec![0.0],
-            values: vec![v],
-        }
-    }
-
-    pub fn duration(&self) -> f32 {
-        self.samples.last().copied().unwrap_or(0.0)
-    }
-
-    /// Easer to use sampling method that don't have time restrictions or needs
-    /// the keyframe index, but is more expensive always `O(n)`. Which means
-    /// sampling takes longer to evaluate as much as time get closer to curve duration
-    /// and it get worse with more keyframes.
-    pub fn sample(&self, time: f32) -> T {
-        // Index guessing gives a small search optimization
-        let index = if time < self.duration() * 0.5 {
-            0
-        } else {
-            self.samples.len() - 1
-        };
-
-        self.sample_indexed(index, time).1
-    }
-
-    /// Samples the curve starting from some keyframe index, this make the common case `O(1)`
-    pub fn sample_indexed(&self, mut index: usize, time: f32) -> (usize, T) {
-        // Adjust for the current keyframe index
-        let last_index = self.samples.len() - 1;
-
-        index = index.max(0).min(last_index);
-        if self.samples[index] < time {
-            // Forward search
-            loop {
-                if index == last_index {
-                    return (last_index, self.values.last().unwrap().clone());
-                }
-                index += 1;
-
-                if self.samples[index] >= time {
-                    break;
-                }
-            }
-        } else {
-            // Backward search
-            loop {
-                if index == 0 {
-                    return (0, self.values.last().unwrap().clone());
-                }
-
-                let i = index - 1;
-                if self.samples[i] <= time {
-                    break;
-                }
-
-                index = i;
-            }
-        }
-
-        // Lerp the value
-        let i = index - 1;
-        let previous_time = self.samples[i];
-        let t = (time - previous_time) / (self.samples[index] - previous_time);
-        debug_assert!(t >= 0.0 && t <= 1.0, "t = {} but should be normalized", t); // Checks if it's required to normalize t
-        let value = T::lerp(&self.values[i], &self.values[index], t);
-
-        (index, value)
-    }
-
-    pub fn add_offset_time(&mut self, time_offset: f32) {
-        self.samples.iter_mut().for_each(|t| *t += time_offset);
-    }
-
-    // pub fn insert(&mut self, time_sample: f32, value: T) {
-    // }
-
-    // pub fn remove(&mut self, index: usize) {
-    //assert!(samples.len() > 1, "curve can't be empty");
-    // }
-
-    pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
-        self.samples.iter().copied().zip(self.values.iter())
-    }
-
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
-        self.samples.iter().copied().zip(self.values.iter_mut())
-    }
-
-    #[inline(always)]
-    pub fn value_type(&self) -> TypeId {
-        TypeId::of::<T>()
-    }
-
-    #[inline(always)]
-    pub fn value_size(&self) -> usize {
-        std::mem::size_of::<T>()
-    }
-}
-
 #[derive(Debug, Clone, Properties)]
 pub struct Layer {
     pub weight: f32,
@@ -857,11 +507,6 @@ pub fn animator_update_system(world: &mut World, resources: &mut Resources) {
 
         animator.visited.clear();
         for layer in &mut animator.layers {
-            let w = layer.weight;
-            if w < SMOL {
-                continue;
-            }
-
             let clip_index = layer.clip;
             if let Some(clip) = animator
                 .clips
@@ -890,8 +535,8 @@ pub fn animator_update_system(world: &mut World, resources: &mut Resources) {
                     // Warp mode
                     if clip.warp {
                         // Warp Around
-                        if time > clip.duration {
-                            time = (time / clip.duration).fract() * clip.duration;
+                        if time > clip.duration() {
+                            time = (time / clip.duration()).fract() * clip.duration();
                             // Reset all keyframes cached indexes
                             layer
                                 .keyframe
@@ -900,12 +545,17 @@ pub fn animator_update_system(world: &mut World, resources: &mut Resources) {
                         }
                     } else {
                         // Hold
-                        time = time.min(clip.duration);
+                        time = time.min(clip.duration());
                     }
 
                     // Advance state time
                     layer.time = time;
 
+                    let w = layer.weight;
+                    if w < SMOL {
+                        continue;
+                    }
+
                     // TODO: can be done in bached_parallel if is visited warped inside a mutex
                     for (curve_index, (ptr, keyframe)) in bind
                         .pointers
@@ -1022,6 +672,7 @@ pub fn animator_update_system(world: &mut World, resources: &mut Resources) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::curve::Curve;
 
     #[test]
     fn curve_evaluation() {
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index b7ccefe9d51a8..cc6cc70b44590 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -3,6 +3,10 @@ use bevy_asset::AddAsset;
 //use bevy_ecs::prelude::*;
 use bevy_type_registry::RegisterType;
 
+pub mod clip;
+pub mod curve;
+pub mod custom;
+
 pub mod generic;
 mod hierarchy;
 pub mod lerping;
@@ -13,7 +17,9 @@ pub use crate::hierarchy::Hierarchy;
 pub use crate::skinned_mesh::*;
 
 pub mod prelude {
-    pub use crate::generic::{Animator, Clip, Curve, CurveUntyped};
+    pub use crate::clip::*;
+    pub use crate::curve::*;
+    pub use crate::generic::Animator;
     pub use crate::hierarchy::Hierarchy;
     pub use crate::lerping::LerpValue;
     pub use crate::skinned_mesh::{SkinAsset, SkinComponent, SkinDebugger};
@@ -33,7 +39,7 @@ impl Plugin for AnimationPlugin {
         app.add_stage_after(stage::UPDATE, stage::ANIMATE);
 
         // Generic animation
-        app.add_asset::<Clip>()
+        app.add_asset::<clip::Clip>()
             //.add_asset_loader(ClipLoader)
             .register_component::<Animator>()
             .add_system_to_stage(stage::ANIMATE, animator_binding_system)

From a4fd66927241f6764ff878e1e8c4095298a71f9c Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sat, 5 Dec 2020 21:52:33 -0300
Subject: [PATCH 028/153] working on a new clip format

---
 crates/bevy_animation/src/clip.rs    |  83 ++++++--
 crates/bevy_animation/src/custom.rs  | 283 +++++++++++----------------
 crates/bevy_animation/src/generic.rs |  41 ++--
 crates/bevy_animation/src/lib.rs     |   2 +-
 crates/bevy_core/src/name.rs         |   2 +
 5 files changed, 206 insertions(+), 205 deletions(-)

diff --git a/crates/bevy_animation/src/clip.rs b/crates/bevy_animation/src/clip.rs
index 5152df8e365f9..4aae107ff4074 100644
--- a/crates/bevy_animation/src/clip.rs
+++ b/crates/bevy_animation/src/clip.rs
@@ -1,3 +1,4 @@
+use bevy_core::Name;
 use bevy_type_registry::TypeUuid;
 
 use super::curve::CurveUntyped;
@@ -6,6 +7,12 @@ use super::hierarchy::Hierarchy;
 // TODO: Curve/Clip need a validation during deserialization because they are
 // structured as SOA (struct of arrays), so the vec's length must match
 
+#[derive(Debug, Clone, Copy)]
+pub struct CurveEntry {
+    pub entity_index: u16,
+    pub property_index: u16,
+}
+
 // TODO: impl Serialize, Deserialize
 #[derive(Debug, Clone, TypeUuid)]
 #[uuid = "4c76e6c3-706d-4a74-af8e-4f48033e0733"]
@@ -14,12 +21,14 @@ pub struct Clip {
     pub warp: bool,
     duration: f32,
     /// Entity identification made by parent index and name
-    pub(crate) hierarchy: Hierarchy,
-    /// Attribute is made by the entity index and a string that combines
+    hierarchy: Hierarchy,
+    /// Each curve as one entry that maps a curve to an entity and a property path
+    entries: Vec<CurveEntry>,
+    curves: Vec<CurveUntyped>,
+    /// A single property is made by string that combines
     /// component name followed by their attributes spaced by a period,
     /// like so: `"Transform.translation.x"`
-    pub(crate) properties: Vec<(u16, String)>,
-    pub(crate) curves: Vec<CurveUntyped>,
+    properties: Vec<Name>,
 }
 
 // fn clip_default_warp() -> bool {
@@ -35,6 +44,7 @@ impl Default for Clip {
             hierarchy: Hierarchy::default(),
             properties: vec![],
             curves: vec![],
+            entries: vec![],
         }
     }
 }
@@ -58,21 +68,20 @@ impl Clip {
         let path =
             property_path.split_at(property_path.rfind('@').expect("property path missing @"));
 
-        let (entity1, just_created) = self.hierarchy.get_or_insert_entity(path.0);
-        let name1 = path.1.split_at(1).1;
+        let (entity_index, just_created) = self.hierarchy.get_or_insert_entity(path.0);
+        let target_name = path.1.split_at(1).1;
 
         // If some entity was created it means this property is a new one so we can safely skip the attribute testing
         if !just_created {
-            for (i, entry) in self.properties.iter().enumerate() {
-                let (entity0, name0) = entry;
-
-                if *entity0 != entity1 {
+            for (i, entry) in self.entries.iter().enumerate() {
+                if entry.entity_index != entity_index {
                     continue;
                 }
 
-                let mid = name1.len().min(name0.len());
-                let (head0, tail0) = name0.split_at(mid);
-                let (head1, tail1) = name1.split_at(mid);
+                let property_name = self.properties[entry.property_index as usize];
+                let mid = target_name.len().min(property_name.len());
+                let (head0, tail0) = property_name.split_at(mid);
+                let (head1, tail1) = target_name.split_at(mid);
 
                 if head0 == head1 {
                     // Replace
@@ -98,8 +107,26 @@ impl Clip {
             }
         }
 
+        // Find property or insert as a new one
+        let target_name = Name::from_str(target_name);
+        let property_index = self
+            .properties
+            .iter()
+            .position(|property_name| property_name == &target_name)
+            .map_or_else(
+                || {
+                    let property_index = self.properties.len() as u16;
+                    self.properties.push(target_name);
+                    property_index
+                },
+                |property_index| property_index as u16,
+            );
+
         self.duration = self.duration.max(curve.duration());
-        self.properties.push((entity1, name1.to_string()));
+        self.entries.push(CurveEntry {
+            entity_index,
+            property_index,
+        });
         self.curves.push(curve);
     }
 
@@ -114,13 +141,17 @@ impl Clip {
     /// The clip stores a property path in a specific way to improve search performance
     /// thus it needs to rebuilt the curve property path in the human readable format
     pub fn get_property_path(&self, index: u16) -> String {
-        let (entity_index, name) = &self.properties[index as usize];
+        let CurveEntry {
+            entity_index,
+            property_index,
+        } = &self.entries[index as usize];
+
         format!(
             "{}@{}",
             self.hierarchy
                 .get_entity_path_at(*entity_index)
                 .expect("property as an invalid entity"),
-            name.as_str()
+            self.properties[*property_index as usize].as_str()
         )
     }
 
@@ -153,4 +184,24 @@ impl Clip {
             self.duration = self.duration.max(inserted_duration);
         }
     }
+
+    #[inline(always)]
+    pub fn hierarchy(&self) -> &Hierarchy {
+        &self.hierarchy
+    }
+
+    #[inline(always)]
+    pub fn properties(&self) -> &[Name] {
+        &self.properties[..]
+    }
+
+    #[inline(always)]
+    pub fn curves(&self) -> impl Iterator<Item = (&CurveEntry, &CurveUntyped)> {
+        self.entries.iter().zip(self.curves.iter())
+    }
+
+    #[inline(always)]
+    pub fn get(&self, curve_index: u16) -> Option<&CurveUntyped> {
+        self.curves.get(curve_index as usize)
+    }
 }
diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 5b0842f8beb74..2575472d8faf2 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -58,80 +58,13 @@ struct ClipBind {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[derive(Debug)]
-pub struct PropDescriptor {
-    pub entity_index: u16,
-    pub curve_index: u16,
-}
-
-#[derive(Default, Debug)]
-pub struct Props(FnvHashMap<String, SmallVec<[PropDescriptor; 4]>>);
-
-impl Props {
-    fn new(clip: &Clip) -> Self {
-        let mut props = Props::default();
-        for ((curve_index, _), (entity_index, prop_name)) in
-            clip.curves.iter().enumerate().zip(clip.properties.iter())
-        {
-            let desc = PropDescriptor {
-                entity_index: *entity_index as u16,
-                curve_index: curve_index as u16,
-            };
-
-            if let Some(v) = props.0.get_mut(prop_name) {
-                v.push(desc);
-                continue;
-            }
-
-            props.0.insert(prop_name.to_owned(), smallvec![desc]);
-        }
-        props
-    }
-
-    #[inline(always)]
-    pub fn get(&self, name: &str) -> Option<&[PropDescriptor]> {
-        self.0.get(name).map(|sv| &sv[..])
-    }
-}
-
-#[derive(Default, Debug)]
-pub struct ClipProps(FnvHashMap<Handle<Clip>, Props>);
-
-impl ClipProps {
-    #[inline(always)]
-    pub fn get(&self, clip_handle: &Handle<Clip>) -> Option<&Props> {
-        self.0.get(&clip_handle.as_weak())
-    }
-}
-
-#[derive(Default)]
-pub(crate) struct AnimatorState {
-    clips_event_reader: EventReader<AssetEvent<Clip>>,
-}
-
 pub(crate) fn animator_udpate(
-    mut state: Local<AnimatorState>,
     time: Res<Time>,
     clips: Res<Assets<Clip>>,
-    clip_events: Res<Events<AssetEvent<Clip>>>,
-    mut clip_props: ResMut<ClipProps>,
     mut animators_query: Query<(Entity, &mut Animator)>,
     mut children_query: Query<(&Children,)>,
     mut name_query: Query<(&Parent, &Name)>,
 ) {
-    // Create clip props
-    for event in state.clips_event_reader.iter(&clip_events) {
-        match event {
-            AssetEvent::Removed { handle } => {
-                clip_props.0.remove(&handle);
-            }
-            AssetEvent::Created { handle } | AssetEvent::Modified { handle } => {
-                let clip = clips.get(handle).expect("missing asset");
-                clip_props.0.insert(handle.as_weak(), Props::new(clip));
-            }
-        };
-    }
-
     let delta_time = time.delta_seconds;
 
     for (animator_entity, mut animator) in animators_query.iter_mut() {
@@ -163,13 +96,13 @@ pub(crate) fn animator_udpate(
 
                 // Prepare the entities table cache
                 bind.entities.clear();
-                bind.entities.resize(clip.hierarchy.len(), None);
+                bind.entities.resize(clip.hierarchy().len(), None);
                 // Assign the root entity as the first element
                 bind.entities[0] = Some(animator_entity);
 
                 // Find entitites ...
-                for entity_index in 1..clip.hierarchy.len() {
-                    clip.hierarchy.find_entity(
+                for entity_index in 1..clip.hierarchy().len() {
+                    clip.hierarchy().find_entity(
                         entity_index as u16,
                         &mut bind.entities,
                         &mut children_query,
@@ -177,7 +110,7 @@ pub(crate) fn animator_udpate(
                     );
                 }
 
-                let curves_count = clip.curves.len();
+                let curves_count = clip.len() as usize;
 
                 for layer in &mut animator.layers {
                     if layer.clip_index as usize != clip_index {
@@ -219,98 +152,116 @@ pub(crate) fn animator_udpate(
     }
 }
 
-pub(crate) fn animator_transform_update(
-    clips: Res<Assets<Clip>>,
-    clip_props: Res<ClipProps>,
-    mut animators_query: Query<(&mut Animator,)>,
-    mut transform_query: Query<(&mut Transform,)>,
-) {
-    for (mut animator,) in animators_query.iter_mut() {
-        let animator = &mut *animator;
-
-        for layer in &mut animator.layers {
-            let w = layer.weight;
-            if w < 1.0e-8 {
-                continue;
-            }
-
-            let time = layer.time;
-            let clip_index = layer.clip_index as usize;
-
-            if let Some(bind) = animator.bind_clips.get(clip_index) {
-                if let Some(clip_handle) = animator.clips.get(clip_index) {
-                    if let Some(clip) = clips.get(clip_handle) {
-                        if let Some(clip_props) = clip_props.get(clip_handle) {
-                            // Update properties
-                            for prop in clip_props.get("Transform.translation").unwrap_or(&[]) {
-                                if let Some(entity) = bind.entities[prop.entity_index as usize] {
-                                    let curve_index = prop.curve_index as usize;
-                                    match &clip.curves[curve_index] {
-                                        CurveUntyped::Vec3(curve) => {
-                                            // TODO: Expensive query
-                                            if let Ok((mut transform,)) =
-                                                transform_query.get_mut(entity)
-                                            {
-                                                let (k, v) = curve.sample_indexed(
-                                                    layer.keyframe[curve_index],
-                                                    time,
-                                                );
-                                                transform.translation = v;
-                                                layer.keyframe[curve_index] = k;
-                                            }
-                                        }
-                                        _ => {}
-                                    }
-                                }
-                            }
-
-                            for prop in clip_props.get("Transform.rotation").unwrap_or(&[]) {
-                                if let Some(entity) = bind.entities[prop.entity_index as usize] {
-                                    let curve_index = prop.curve_index as usize;
-                                    match &clip.curves[curve_index] {
-                                        CurveUntyped::Quat(curve) => {
-                                            // TODO: Expensive query
-                                            if let Ok((mut transform,)) =
-                                                transform_query.get_mut(entity)
-                                            {
-                                                let (k, v) = curve.sample_indexed(
-                                                    layer.keyframe[curve_index],
-                                                    time,
-                                                );
-                                                transform.rotation = v;
-                                                layer.keyframe[curve_index] = k;
-                                            }
-                                        }
-                                        _ => {}
-                                    }
-                                }
-                            }
-
-                            for prop in clip_props.get("Transform.scale").unwrap_or(&[]) {
-                                if let Some(entity) = bind.entities[prop.entity_index as usize] {
-                                    let curve_index = prop.curve_index as usize;
-                                    match &clip.curves[curve_index] {
-                                        CurveUntyped::Vec3(curve) => {
-                                            // TODO: Expensive query
-                                            if let Ok((mut transform,)) =
-                                                transform_query.get_mut(entity)
-                                            {
-                                                let (k, v) = curve.sample_indexed(
-                                                    layer.keyframe[curve_index],
-                                                    time,
-                                                );
-                                                transform.scale = v;
-                                                layer.keyframe[curve_index] = k;
-                                            }
-                                        }
-                                        _ => {}
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
+// pub(crate) fn animator_transform_update(
+//     clips: Res<Assets<Clip>>,
+//     mut animators_query: Query<(&mut Animator,)>,
+//     mut transform_query: Query<(&mut Transform,)>,
+// ) {
+//     const TRANSLATION: Name = Name::from_str("Transform.translation");
+//     const ROTATION: Name = Name::from_str("Transform.rotation");
+//     const SCALE: Name = Name::from_str("Transform.scale");
+
+//     for (mut animator,) in animators_query.iter_mut() {
+//         let animator = &mut *animator;
+
+//         for layer in &mut animator.layers {
+//             let w = layer.weight;
+//             if w < 1.0e-8 {
+//                 continue;
+//             }
+
+//             let time = layer.time;
+//             let clip_index = layer.clip_index as usize;
+
+//             if let Some(bind) = animator.bind_clips.get(clip_index) {
+//                 if let Some(clip_handle) = animator.clips.get(clip_index) {
+//                     if let Some(clip) = clips.get(clip_handle) {
+//                         // Fetch properties indexes for this particular clip
+//                         let mut translation = u16::MAX;
+//                         let mut rotation = u16::MAX;
+//                         let mut scale = u16::MAX;
+
+//                         for (property_index, prop_name) in clip.properties().iter().enumerate() {
+//                             if prop_name == &TRANSLATION {
+//                                 translation = property_index as u16;
+//                             } else if prop_name == &ROTATION {
+//                                 rotation = property_index as u16;
+//                             } else if prop_name == &SCALE {
+//                                 scale = property_index as u16;
+//                             }
+//                         }
+
+//                         // if let Some(clip_props) = clip_props.get(clip_handle) {
+//                         //     // Update properties
+//                         //     for prop in clip_props.get("Transform.translation").unwrap_or(&[]) {
+//                         //         if let Some(entity) = bind.entities[prop.entity_index as usize] {
+//                         //             let curve_index = prop.curve_index as usize;
+//                         //             match &clip.curves[curve_index] {
+//                         //                 CurveUntyped::Vec3(curve) => {
+//                         //                     // TODO: Expensive query
+//                         //                     if let Ok((mut transform,)) =
+//                         //                         transform_query.get_mut(entity)
+//                         //                     {
+//                         //                         let (k, v) = curve.sample_indexed(
+//                         //                             layer.keyframe[curve_index],
+//                         //                             time,
+//                         //                         );
+//                         //                         transform.translation = v;
+//                         //                         layer.keyframe[curve_index] = k;
+//                         //                     }
+//                         //                 }
+//                         //                 _ => {}
+//                         //             }
+//                         //         }
+//                         //     }
+
+//                         //     for prop in clip_props.get("Transform.rotation").unwrap_or(&[]) {
+//                         //         if let Some(entity) = bind.entities[prop.entity_index as usize] {
+//                         //             let curve_index = prop.curve_index as usize;
+//                         //             match &clip.curves[curve_index] {
+//                         //                 CurveUntyped::Quat(curve) => {
+//                         //                     // TODO: Expensive query
+//                         //                     if let Ok((mut transform,)) =
+//                         //                         transform_query.get_mut(entity)
+//                         //                     {
+//                         //                         let (k, v) = curve.sample_indexed(
+//                         //                             layer.keyframe[curve_index],
+//                         //                             time,
+//                         //                         );
+//                         //                         transform.rotation = v;
+//                         //                         layer.keyframe[curve_index] = k;
+//                         //                     }
+//                         //                 }
+//                         //                 _ => {}
+//                         //             }
+//                         //         }
+//                         //     }
+
+//                         //     for prop in clip_props.get("Transform.scale").unwrap_or(&[]) {
+//                         //         if let Some(entity) = bind.entities[prop.entity_index as usize] {
+//                         //             let curve_index = prop.curve_index as usize;
+//                         //             match &clip.curves[curve_index] {
+//                         //                 CurveUntyped::Vec3(curve) => {
+//                         //                     // TODO: Expensive query
+//                         //                     if let Ok((mut transform,)) =
+//                         //                         transform_query.get_mut(entity)
+//                         //                     {
+//                         //                         let (k, v) = curve.sample_indexed(
+//                         //                             layer.keyframe[curve_index],
+//                         //                             time,
+//                         //                         );
+//                         //                         transform.scale = v;
+//                         //                         layer.keyframe[curve_index] = k;
+//                         //                     }
+//                         //                 }
+//                         //                 _ => {}
+//                         //             }
+//                         //         }
+//                         //     }
+//                         // }
+//                     }
+//                 }
+//             }
+//         }
+//     }
+// }
diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index 6c616b5825b5b..bff862c956fa1 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -221,7 +221,7 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
 
             // Prepare the entities table cache
             entities_table_cache.clear();
-            entities_table_cache.resize(clip.hierarchy.len(), None);
+            entities_table_cache.resize(clip.hierarchy().len(), None);
             // Assign the root entity as the first element
             entities_table_cache[0] = Some(root);
 
@@ -285,8 +285,8 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
                     .for_each(|(entity_index, entry)| {
                         *entry = None;
                         // ? NOTE: Will only run if the bind was invalidated in this frame
-                        for (descriptor, attr) in clip.properties.iter().zip(pointers.iter_mut()) {
-                            if descriptor.0 as usize == entity_index {
+                        for (descriptor, attr) in clip.curves().zip(pointers.iter_mut()) {
+                            if descriptor.0.entity_index as usize == entity_index {
                                 *attr = Ptr(null_mut());
                             }
                         }
@@ -296,16 +296,14 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
                 // Handle entities that had theirs parents changed
                 // ? NOTE: Heavy code path triggered when an animated hierarchy changes
                 while let Some(entity_index) = entities_parent_changed.pop() {
-                    clip.hierarchy
+                    clip.hierarchy()
                         .depth_first(entity_index, &mut |entity_index, _| {
                             let entry = &mut entities[entity_index as usize];
 
                             if entry.is_some() {
                                 // Yet not invalidated
-                                for (descriptor, attr) in
-                                    clip.properties.iter().zip(pointers.iter_mut())
-                                {
-                                    if descriptor.0 == entity_index {
+                                for (descriptor, attr) in clip.curves().zip(pointers.iter_mut()) {
+                                    if descriptor.0.entity_index == entity_index {
                                         *attr = Ptr(null_mut());
                                     }
                                 }
@@ -321,9 +319,9 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
             } else {
                 // Create empty binds
                 *bind = Some(ClipBind {
-                    entities: vec_filled(clip.hierarchy.len(), || None),
+                    entities: vec_filled(clip.hierarchy().len(), || None),
                     binded: false,
-                    pointers: vec_filled(clip.properties.len(), || Ptr(null_mut())),
+                    pointers: vec_filled(clip.len() as usize, || Ptr(null_mut())),
                 });
 
                 bind.as_mut().unwrap()
@@ -338,13 +336,10 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
             bind.binded = true;
 
             // Bind attributes
-            for (attr_index, (attr, descriptor)) in bind
-                .pointers
-                .iter_mut()
-                .zip(clip.properties.iter())
-                .enumerate()
+            for (attr_index, (attr, descriptor)) in
+                bind.pointers.iter_mut().zip(clip.curves()).enumerate()
             {
-                let (entity_index, attr_path) = descriptor;
+                let (entry, curve) = descriptor;
 
                 if *attr != Ptr(null_mut()) {
                     // Already binded
@@ -359,18 +354,18 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
                 let mut path = attr_path.split('.');
                 let component_short_name = path.next().expect("missing component short name");
 
-                if let Some(entity) = clip.hierarchy.find_entity_in_world(
-                    *entity_index,
+                if let Some(entity) = clip.hierarchy().find_entity_in_world(
+                    entry.entity_index,
                     &mut entities_table_cache,
                     &world,
                 ) {
                     let location = world.get_entity_location(entity).unwrap();
 
-                    bind.entities[*entity_index as usize].get_or_insert_with(|| {
+                    bind.entities[entry.entity_index as usize].get_or_insert_with(|| {
                         ClipBindEntity {
                             // If the entity was found the parent was as well (unless is the root which will always be None)
                             parent: entities_table_cache
-                                .get(clip.hierarchy.get_entity(*entity_index).0 as usize)
+                                .get(clip.hierarchy().get_entity(entry.entity_index).0 as usize)
                                 .copied()
                                 .flatten(),
                             entity,
@@ -517,7 +512,7 @@ pub fn animator_update_system(world: &mut World, resources: &mut Resources) {
                 // TODO: Add layer mask
 
                 if let Some(bind) = &animator.bind_clips[clip_index as usize] {
-                    let curves_count = clip.curves.len();
+                    let curves_count = clip.len() as usize;
 
                     // Ensure capacity for cached keyframe index vec
                     if layer.keyframe.len() != curves_count {
@@ -568,7 +563,9 @@ pub fn animator_update_system(world: &mut World, resources: &mut Resources) {
                             continue;
                         }
 
-                        let curve = &clip.curves[curve_index];
+                        let curve = clip
+                            .get(curve_index as u16)
+                            .expect("curve index out of bounds");
 
                         let viz = if animator.visited.contains(&ptr) {
                             true
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index cc6cc70b44590..a3cdfbcfc9a6a 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -17,7 +17,7 @@ pub use crate::hierarchy::Hierarchy;
 pub use crate::skinned_mesh::*;
 
 pub mod prelude {
-    pub use crate::clip::*;
+    pub use crate::clip::Clip;
     pub use crate::curve::*;
     pub use crate::generic::Animator;
     pub use crate::hierarchy::Hierarchy;
diff --git a/crates/bevy_core/src/name.rs b/crates/bevy_core/src/name.rs
index 79ff54d60c8c0..3c154e2ff8c5a 100644
--- a/crates/bevy_core/src/name.rs
+++ b/crates/bevy_core/src/name.rs
@@ -40,11 +40,13 @@ impl Name {
         *self = Name::new(name);
     }
 
+    #[inline(always)]
     pub fn mutate<F: FnOnce(&mut String)>(&mut self, f: F) {
         f(&mut self.name);
         self.update_hash();
     }
 
+    #[inline(always)]
     pub fn as_str(&self) -> &str {
         self.name.as_str()
     }

From 866a441e2b40001d1a155cd338ffaf0225429b86 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 6 Dec 2020 00:39:16 -0300
Subject: [PATCH 029/153] still working on a safer and faster alternative

---
 crates/bevy_animation/src/clip.rs    |  74 ++++++++-
 crates/bevy_animation/src/curve.rs   |  41 +++++
 crates/bevy_animation/src/custom.rs  | 228 +++++++++++++--------------
 crates/bevy_animation/src/generic.rs | 104 +-----------
 crates/bevy_core/src/name.rs         |   2 +-
 5 files changed, 229 insertions(+), 220 deletions(-)

diff --git a/crates/bevy_animation/src/clip.rs b/crates/bevy_animation/src/clip.rs
index 4aae107ff4074..eb6c5d6169182 100644
--- a/crates/bevy_animation/src/clip.rs
+++ b/crates/bevy_animation/src/clip.rs
@@ -78,7 +78,7 @@ impl Clip {
                     continue;
                 }
 
-                let property_name = self.properties[entry.property_index as usize];
+                let property_name = &self.properties[entry.property_index as usize];
                 let mid = target_name.len().min(property_name.len());
                 let (head0, tail0) = property_name.split_at(mid);
                 let (head1, tail1) = target_name.split_at(mid);
@@ -205,3 +205,75 @@ impl Clip {
         self.curves.get(curve_index as usize)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::curve::Curve;
+    use bevy_math::prelude::*;
+
+    #[test]
+    fn create_clip() {
+        let mut clip = Clip::default();
+        let curve = Curve::from_linear(0.0, 1.0, 0.0, 1.0);
+        let prop = "/Root/Ball@Sphere.radius";
+        clip.add_animated_prop(prop, CurveUntyped::Float(curve));
+        assert_eq!(clip.get_property_path(0), prop);
+    }
+
+    #[test]
+    fn clip_replace_property() {
+        // NOTE: This test is very important because it guarantees that each property have unique
+        // access to some attribute during the update stages
+        let mut clip = Clip::default();
+        let prop = "/Root/Ball@Sphere.radius";
+        clip.add_animated_prop(
+            "/Root/Ball@Transform.translate.y",
+            CurveUntyped::Float(Curve::from_linear(0.0, 1.0, 0.0, 1.0)),
+        );
+        clip.add_animated_prop(
+            prop,
+            CurveUntyped::Float(Curve::from_linear(0.0, 1.0, 0.0, 1.0)),
+        );
+        assert_eq!(clip.duration(), 1.0);
+        clip.add_animated_prop(
+            prop,
+            CurveUntyped::Float(Curve::from_linear(0.0, 1.2, 0.1, 2.0)),
+        );
+        assert_eq!(clip.len(), 2);
+        assert_eq!(clip.get_property_path(1), prop);
+        assert_eq!(clip.duration(), 1.2);
+    }
+
+    #[test]
+    fn clip_fine_grain_properties() {
+        let mut clip = Clip::default();
+        clip.add_animated_prop(
+            "/Root/Ball@Transform.translate.y",
+            CurveUntyped::Float(Curve::from_linear(0.0, 1.0, 0.0, 1.0)),
+        );
+        assert_eq!(clip.duration(), 1.0);
+        clip.add_animated_prop(
+            "/Root/Ball@Transform.translate.x",
+            CurveUntyped::Float(Curve::from_linear(0.0, 1.2, 0.0, 2.0)),
+        );
+        assert_eq!(clip.len(), 2);
+        assert_eq!(clip.duration(), 1.2);
+    }
+
+    #[test]
+    #[should_panic]
+    fn clip_nested_properties() {
+        // Maybe required by `bevy_reflect` this guarantees are necessary
+        // because the way we execute
+        let mut clip = Clip::default();
+        clip.add_animated_prop(
+            "/Root/Ball@Transform.translate",
+            CurveUntyped::Vec3(Curve::from_linear(0.0, 1.0, Vec3::zero(), Vec3::unit_y())),
+        );
+        clip.add_animated_prop(
+            "/Root/Ball@Transform.translate.x",
+            CurveUntyped::Float(Curve::from_linear(0.0, 1.2, 0.0, 2.0)),
+        );
+    }
+}
diff --git a/crates/bevy_animation/src/curve.rs b/crates/bevy_animation/src/curve.rs
index 87c55b0dfcbf2..2ea21666dc087 100644
--- a/crates/bevy_animation/src/curve.rs
+++ b/crates/bevy_animation/src/curve.rs
@@ -196,3 +196,44 @@ where
         std::mem::size_of::<T>()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn curve_evaluation() {
+        let curve = Curve::new(
+            vec![0.0, 0.25, 0.5, 0.75, 1.0],
+            vec![0.0, 0.5, 1.0, 1.5, 2.0],
+        );
+        assert_eq!(curve.sample(0.5), 1.0);
+
+        let mut i0 = 0;
+        let mut e0 = 0.0;
+        for v in &[0.1, 0.3, 0.7, 0.4, 0.2, 0.0, 0.4, 0.85, 1.0] {
+            let v = *v;
+            let (i1, e1) = curve.sample_indexed(i0, v);
+            assert_eq!(e1, 2.0 * v);
+            if e1 > e0 {
+                assert!(i1 >= i0);
+            } else {
+                assert!(i1 <= i0);
+            }
+            e0 = e1;
+            i0 = i1;
+        }
+    }
+
+    #[test]
+    #[should_panic]
+    fn curve_bad_length() {
+        let _ = Curve::new(vec![0.0, 0.5, 1.0], vec![0.0, 1.0]);
+    }
+
+    #[test]
+    #[should_panic]
+    fn curve_time_samples_not_sorted() {
+        let _ = Curve::new(vec![0.0, 1.5, 1.0], vec![0.0, 1.0, 2.0]);
+    }
+}
diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 2575472d8faf2..74d04250d2eb9 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -46,16 +46,38 @@ impl Default for Layer {
 pub struct Animator {
     clips: Vec<Handle<Clip>>,
     #[property(ignore)]
-    bind_clips: Vec<ClipBind>,
+    bind_clips: Vec<Bind>,
     pub time_scale: f32,
     pub layers: Vec<Layer>,
 }
 
 #[derive(Default, Debug)]
-struct ClipBind {
+struct Bind {
     entities: Vec<Option<Entity>>,
 }
 
+impl Animator {
+    pub fn animate<'a>(&'a mut self) -> LayerIterator<'a> {
+        LayerIterator {
+            index: 0,
+            animator: self,
+        }
+    }
+}
+
+pub struct LayerIterator<'a> {
+    index: usize,
+    animator: &'a mut Animator,
+}
+
+impl<'a> Iterator for LayerIterator<'a> {
+    type Item = (&'a mut Layer, &'a Handle<Clip>, &'a [Option<Entity>]);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        todo!()
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 pub(crate) fn animator_udpate(
@@ -88,7 +110,7 @@ pub(crate) fn animator_udpate(
         // Make run for the binds
         animator
             .bind_clips
-            .resize_with(animator.clips.len(), ClipBind::default);
+            .resize_with(animator.clips.len(), Bind::default);
 
         for (clip_index, clip_handle) in animator.clips.iter().enumerate() {
             if let Some(clip) = clips.get(clip_handle) {
@@ -152,116 +174,90 @@ pub(crate) fn animator_udpate(
     }
 }
 
-// pub(crate) fn animator_transform_update(
-//     clips: Res<Assets<Clip>>,
-//     mut animators_query: Query<(&mut Animator,)>,
-//     mut transform_query: Query<(&mut Transform,)>,
-// ) {
-//     const TRANSLATION: Name = Name::from_str("Transform.translation");
-//     const ROTATION: Name = Name::from_str("Transform.rotation");
-//     const SCALE: Name = Name::from_str("Transform.scale");
-
-//     for (mut animator,) in animators_query.iter_mut() {
-//         let animator = &mut *animator;
-
-//         for layer in &mut animator.layers {
-//             let w = layer.weight;
-//             if w < 1.0e-8 {
-//                 continue;
-//             }
-
-//             let time = layer.time;
-//             let clip_index = layer.clip_index as usize;
-
-//             if let Some(bind) = animator.bind_clips.get(clip_index) {
-//                 if let Some(clip_handle) = animator.clips.get(clip_index) {
-//                     if let Some(clip) = clips.get(clip_handle) {
-//                         // Fetch properties indexes for this particular clip
-//                         let mut translation = u16::MAX;
-//                         let mut rotation = u16::MAX;
-//                         let mut scale = u16::MAX;
-
-//                         for (property_index, prop_name) in clip.properties().iter().enumerate() {
-//                             if prop_name == &TRANSLATION {
-//                                 translation = property_index as u16;
-//                             } else if prop_name == &ROTATION {
-//                                 rotation = property_index as u16;
-//                             } else if prop_name == &SCALE {
-//                                 scale = property_index as u16;
-//                             }
-//                         }
-
-//                         // if let Some(clip_props) = clip_props.get(clip_handle) {
-//                         //     // Update properties
-//                         //     for prop in clip_props.get("Transform.translation").unwrap_or(&[]) {
-//                         //         if let Some(entity) = bind.entities[prop.entity_index as usize] {
-//                         //             let curve_index = prop.curve_index as usize;
-//                         //             match &clip.curves[curve_index] {
-//                         //                 CurveUntyped::Vec3(curve) => {
-//                         //                     // TODO: Expensive query
-//                         //                     if let Ok((mut transform,)) =
-//                         //                         transform_query.get_mut(entity)
-//                         //                     {
-//                         //                         let (k, v) = curve.sample_indexed(
-//                         //                             layer.keyframe[curve_index],
-//                         //                             time,
-//                         //                         );
-//                         //                         transform.translation = v;
-//                         //                         layer.keyframe[curve_index] = k;
-//                         //                     }
-//                         //                 }
-//                         //                 _ => {}
-//                         //             }
-//                         //         }
-//                         //     }
-
-//                         //     for prop in clip_props.get("Transform.rotation").unwrap_or(&[]) {
-//                         //         if let Some(entity) = bind.entities[prop.entity_index as usize] {
-//                         //             let curve_index = prop.curve_index as usize;
-//                         //             match &clip.curves[curve_index] {
-//                         //                 CurveUntyped::Quat(curve) => {
-//                         //                     // TODO: Expensive query
-//                         //                     if let Ok((mut transform,)) =
-//                         //                         transform_query.get_mut(entity)
-//                         //                     {
-//                         //                         let (k, v) = curve.sample_indexed(
-//                         //                             layer.keyframe[curve_index],
-//                         //                             time,
-//                         //                         );
-//                         //                         transform.rotation = v;
-//                         //                         layer.keyframe[curve_index] = k;
-//                         //                     }
-//                         //                 }
-//                         //                 _ => {}
-//                         //             }
-//                         //         }
-//                         //     }
-
-//                         //     for prop in clip_props.get("Transform.scale").unwrap_or(&[]) {
-//                         //         if let Some(entity) = bind.entities[prop.entity_index as usize] {
-//                         //             let curve_index = prop.curve_index as usize;
-//                         //             match &clip.curves[curve_index] {
-//                         //                 CurveUntyped::Vec3(curve) => {
-//                         //                     // TODO: Expensive query
-//                         //                     if let Ok((mut transform,)) =
-//                         //                         transform_query.get_mut(entity)
-//                         //                     {
-//                         //                         let (k, v) = curve.sample_indexed(
-//                         //                             layer.keyframe[curve_index],
-//                         //                             time,
-//                         //                         );
-//                         //                         transform.scale = v;
-//                         //                         layer.keyframe[curve_index] = k;
-//                         //                     }
-//                         //                 }
-//                         //                 _ => {}
-//                         //             }
-//                         //         }
-//                         //     }
-//                         // }
-//                     }
-//                 }
-//             }
-//         }
-//     }
-// }
+pub(crate) fn animator_transform_update(
+    clips: Res<Assets<Clip>>,
+    mut animators_query: Query<(&mut Animator,)>,
+    mut transform_query: Query<(&mut Transform,)>,
+) {
+    // TODO: Make const
+    let TRANSLATION: Name = Name::from_str("Transform.translation");
+    let ROTATION: Name = Name::from_str("Transform.rotation");
+    let SCALE: Name = Name::from_str("Transform.scale");
+
+    // let mut visited = fnv::FnvHashSet::default();
+
+    // let viz = if visited.contains(&ptr) {
+    //     true
+    // } else {
+    //     visited.insert(*ptr);
+    //     false
+    // };
+
+    for (mut animator,) in animators_query.iter_mut() {
+        let animator = &mut *animator;
+        // visited.clear();
+
+        for (layer, clip_handle, entities) in animator.animate() {
+            let w = layer.weight;
+            if w < 1.0e-8 {
+                continue;
+            }
+
+            let time = layer.time;
+
+            if let Some(clip) = clips.get(clip_handle) {
+                // Fetch properties indexes for this particular clip
+                let mut translation = u16::MAX;
+                let mut rotation = u16::MAX;
+                let mut scale = u16::MAX;
+
+                for (property_index, prop_name) in clip.properties().iter().enumerate() {
+                    if translation == u16::MAX && prop_name == &TRANSLATION {
+                        translation = property_index as u16;
+                    } else if rotation == u16::MAX && prop_name == &ROTATION {
+                        rotation = property_index as u16;
+                    } else if scale == u16::MAX && prop_name == &SCALE {
+                        scale = property_index as u16;
+                    }
+                }
+
+                for (curve_index, (entry, curve)) in clip.curves().enumerate() {
+                    if entry.property_index != translation
+                        || entry.property_index != rotation
+                        || entry.property_index != scale
+                    {
+                        continue;
+                    }
+
+                    if let Some(entity) = entities[entry.entity_index as usize] {
+                        // Entity found
+                        if let Ok((mut transform,)) = transform_query.get_mut(entity) {
+                            if entry.property_index == translation {
+                                if let CurveUntyped::Vec3(curve) = curve {
+                                    let (k, v) =
+                                        curve.sample_indexed(layer.keyframe[curve_index], time);
+                                    transform.translation = v;
+                                    layer.keyframe[curve_index] = k;
+                                }
+                            } else if entry.property_index == rotation {
+                                if let CurveUntyped::Quat(curve) = curve {
+                                    let (k, v) =
+                                        curve.sample_indexed(layer.keyframe[curve_index], time);
+                                    transform.rotation = v;
+                                    layer.keyframe[curve_index] = k;
+                                }
+                            } else if entry.property_index == scale {
+                                if let CurveUntyped::Vec3(curve) = curve {
+                                    let (k, v) =
+                                        curve.sample_indexed(layer.keyframe[curve_index], time);
+                                    transform.scale = v;
+                                    layer.keyframe[curve_index] = k;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
index bff862c956fa1..ba3ebc59ca1a6 100644
--- a/crates/bevy_animation/src/generic.rs
+++ b/crates/bevy_animation/src/generic.rs
@@ -351,6 +351,7 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
 
                 // Query component by name
                 // TODO: Log error instead of panic ...
+                let attr_path = &clip.properties()[entry.property_index as usize];
                 let mut path = attr_path.split('.');
                 let component_short_name = path.next().expect("missing component short name");
 
@@ -386,7 +387,7 @@ pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
                         *attr = find_property_ptr(
                             path,
                             root_props,
-                            clip.curves[attr_index].value_type(),
+                            clip.get(attr_index as u16).unwrap().value_type(),
                         );
 
                         // Clear binded bit if not fully binded
@@ -671,107 +672,6 @@ mod tests {
     use super::*;
     use crate::curve::Curve;
 
-    #[test]
-    fn curve_evaluation() {
-        let curve = Curve::new(
-            vec![0.0, 0.25, 0.5, 0.75, 1.0],
-            vec![0.0, 0.5, 1.0, 1.5, 2.0],
-        );
-        assert_eq!(curve.sample(0.5), 1.0);
-
-        let mut i0 = 0;
-        let mut e0 = 0.0;
-        for v in &[0.1, 0.3, 0.7, 0.4, 0.2, 0.0, 0.4, 0.85, 1.0] {
-            let v = *v;
-            let (i1, e1) = curve.sample_indexed(i0, v);
-            assert_eq!(e1, 2.0 * v);
-            if e1 > e0 {
-                assert!(i1 >= i0);
-            } else {
-                assert!(i1 <= i0);
-            }
-            e0 = e1;
-            i0 = i1;
-        }
-    }
-
-    #[test]
-    #[should_panic]
-    fn curve_bad_length() {
-        let _ = Curve::new(vec![0.0, 0.5, 1.0], vec![0.0, 1.0]);
-    }
-
-    #[test]
-    #[should_panic]
-    fn curve_time_samples_not_sorted() {
-        let _ = Curve::new(vec![0.0, 1.5, 1.0], vec![0.0, 1.0, 2.0]);
-    }
-
-    #[test]
-    fn create_clip() {
-        let mut clip = Clip::default();
-        let curve = Curve::from_linear(0.0, 1.0, 0.0, 1.0);
-        let prop = "/Root/Ball@Sphere.radius";
-        clip.add_animated_prop(prop, CurveUntyped::Float(curve));
-        assert_eq!(clip.get_property_path(0), prop);
-    }
-
-    #[test]
-    fn clip_replace_property() {
-        // NOTE: This test is very important because it guarantees that each property have unique
-        // access to some attribute during the update stages
-        let mut clip = Clip::default();
-        let prop = "/Root/Ball@Sphere.radius";
-        clip.add_animated_prop(
-            "/Root/Ball@Transform.translate.y",
-            CurveUntyped::Float(Curve::from_linear(0.0, 1.0, 0.0, 1.0)),
-        );
-        clip.add_animated_prop(
-            prop,
-            CurveUntyped::Float(Curve::from_linear(0.0, 1.0, 0.0, 1.0)),
-        );
-        assert_eq!(clip.duration(), 1.0);
-        clip.add_animated_prop(
-            prop,
-            CurveUntyped::Float(Curve::from_linear(0.0, 1.2, 0.1, 2.0)),
-        );
-        assert_eq!(clip.len(), 2);
-        assert_eq!(clip.get_property_path(1), prop);
-        assert_eq!(clip.duration(), 1.2);
-    }
-
-    #[test]
-    fn clip_fine_grain_properties() {
-        let mut clip = Clip::default();
-        clip.add_animated_prop(
-            "/Root/Ball@Transform.translate.y",
-            CurveUntyped::Float(Curve::from_linear(0.0, 1.0, 0.0, 1.0)),
-        );
-        assert_eq!(clip.duration(), 1.0);
-        clip.add_animated_prop(
-            "/Root/Ball@Transform.translate.x",
-            CurveUntyped::Float(Curve::from_linear(0.0, 1.2, 0.0, 2.0)),
-        );
-        assert_eq!(clip.len(), 2);
-        assert_eq!(clip.duration(), 1.2);
-    }
-
-    #[test]
-    #[should_panic]
-    fn clip_nested_properties() {
-        // Maybe required by `bevy_reflect` this guarantees are necessary
-        // because the way we execute
-        let mut clip = Clip::default();
-        clip.add_animated_prop(
-            "/Root/Ball@Transform.translate",
-            CurveUntyped::Vec3(Curve::from_linear(0.0, 1.0, Vec3::zero(), Vec3::unit_y())),
-        );
-        clip.add_animated_prop(
-            "/Root/Ball@Transform.translate.x",
-            CurveUntyped::Float(Curve::from_linear(0.0, 1.2, 0.0, 2.0)),
-        );
-    }
-
     #[test]
     fn unhandled_properties_implementation_for_types() {
         // This is take as granted to simplify the function `Clip::add_animated_prop`
diff --git a/crates/bevy_core/src/name.rs b/crates/bevy_core/src/name.rs
index 3c154e2ff8c5a..120f6941ce4e2 100644
--- a/crates/bevy_core/src/name.rs
+++ b/crates/bevy_core/src/name.rs
@@ -9,7 +9,7 @@ use std::hash::{Hash, Hasher};
 /// Component containing the name used to identify a entity. Keep in mind that
 /// multiple entities may have the same name.
 ///
-/// *NOTE* Once created you can't change it's contents because this `Name`
+/// **NOTE** Once created you can't change it's contents because this `Name`
 /// component also stores the string hash to drastically improve performance comparison
 #[derive(Debug, Clone, Properties)]
 pub struct Name {

From 3258b8984386411d73c4fdd17cf02fe6539070e3 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 6 Dec 2020 01:28:02 -0300
Subject: [PATCH 030/153] trying the safe replacement function parity done

---
 crates/bevy_animation/src/custom.rs | 224 ++++++++++++++++++----------
 crates/bevy_animation/src/lib.rs    |  20 ++-
 2 files changed, 160 insertions(+), 84 deletions(-)

diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 74d04250d2eb9..cc25cdb76cded 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -1,48 +1,34 @@
 use anyhow::Result;
-use bevy_app::prelude::{EventReader, Events};
-use bevy_asset::{AssetEvent, Assets, Handle /*, HandleUntyped*/};
+use bevy_asset::{Assets, Handle /*, HandleUntyped*/};
 use bevy_core::prelude::*;
 use bevy_ecs::prelude::*;
-use bevy_ecs::{Location, SystemId};
-use bevy_math::prelude::*;
-use bevy_property::{Properties, Property, PropertyType};
+use bevy_property::Properties;
 use bevy_transform::prelude::*;
-use bevy_type_registry::{TypeRegistry, TypeUuid};
-//use serde::{Deserialize, Serialize};
-use fnv::FnvHashMap;
-use smallvec::{smallvec, SmallVec};
-use std::any::TypeId;
-use std::hash::Hash;
-use std::ptr::null_mut;
 
-use super::hierarchy::Hierarchy;
-use super::lerping::LerpValue;
-
-use super::clip::Clip;
-use super::curve::CurveUntyped;
+use crate::clip::Clip;
+use crate::curve::CurveUntyped;
+use crate::lerping::LerpValue;
 
 #[derive(Debug, Clone, Properties)]
 pub struct Layer {
     pub weight: f32,
-    pub clip_index: u16,
+    pub clip: u16,
     pub time: f32,
     pub time_scale: f32,
-    keyframe: Vec<usize>,
 }
 
 impl Default for Layer {
     fn default() -> Self {
         Layer {
             weight: 1.0,
-            clip_index: 0,
+            clip: 0,
             time: 0.0,
             time_scale: 1.0,
-            keyframe: vec![],
         }
     }
 }
 
-#[derive(Debug, Properties)]
+#[derive(Default, Debug, Properties)]
 pub struct Animator {
     clips: Vec<Handle<Clip>>,
     #[property(ignore)]
@@ -57,30 +43,62 @@ struct Bind {
 }
 
 impl Animator {
-    pub fn animate<'a>(&'a mut self) -> LayerIterator<'a> {
+    pub fn add_clip(&mut self, clip: Handle<Clip>) -> u16 {
+        if let Some(i) = self.clips.iter().position(|c| *c == clip) {
+            i as u16
+        } else {
+            // TODO: assert too many clips ...
+            let i = self.clips.len();
+            self.clips.push(clip);
+            i as u16
+        }
+    }
+
+    pub fn add_layer(&mut self, clip: Handle<Clip>, weight: f32) -> u16 {
+        let clip = self.add_clip(clip);
+        let layer_index = self.layers.len();
+        self.layers.push(Layer {
+            clip,
+            weight,
+            ..Default::default()
+        });
+        layer_index as u16
+    }
+
+    pub fn clips_len(&self) -> u16 {
+        self.clips.len() as u16
+    }
+
+    pub fn animate<'a>(&'a self) -> LayerIterator<'a> {
         LayerIterator {
             index: 0,
             animator: self,
         }
     }
 }
-
 pub struct LayerIterator<'a> {
     index: usize,
-    animator: &'a mut Animator,
+    animator: &'a Animator,
 }
 
 impl<'a> Iterator for LayerIterator<'a> {
-    type Item = (&'a mut Layer, &'a Handle<Clip>, &'a [Option<Entity>]);
+    type Item = (&'a Layer, &'a Handle<Clip>, &'a [Option<Entity>]);
 
     fn next(&mut self) -> Option<Self::Item> {
-        todo!()
+        let index = self.index;
+        self.index += 1;
+
+        let layer = self.animator.layers.get(index)?;
+        let clip_handle = self.animator.clips.get(layer.clip as usize)?;
+        let entities = &self.animator.bind_clips.get(layer.clip as usize)?.entities[..];
+
+        return Some((layer, clip_handle, entities));
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-pub(crate) fn animator_udpate(
+pub(crate) fn animator_update_system(
     time: Res<Time>,
     clips: Res<Assets<Clip>>,
     mut animators_query: Query<(Entity, &mut Animator)>,
@@ -132,20 +150,20 @@ pub(crate) fn animator_udpate(
                     );
                 }
 
-                let curves_count = clip.len() as usize;
+                // let curves_count = clip.len() as usize;
 
                 for layer in &mut animator.layers {
-                    if layer.clip_index as usize != clip_index {
+                    if layer.clip as usize != clip_index {
                         continue;
                     }
 
-                    // Ensure capacity for cached keyframe index vec
-                    if layer.keyframe.len() != curves_count {
-                        layer.keyframe.clear();
-                        layer
-                            .keyframe
-                            .resize_with(curves_count, || Default::default());
-                    }
+                    // // Ensure capacity for cached keyframe index vec
+                    // if layer.keyframe.len() != curves_count {
+                    //     layer.keyframe.clear();
+                    //     layer
+                    //         .keyframe
+                    //         .resize_with(curves_count, || Default::default());
+                    // }
 
                     // Update time
                     let mut time = layer.time + delta_time * layer.time_scale;
@@ -155,11 +173,11 @@ pub(crate) fn animator_udpate(
                         // Warp Around
                         if time > clip.duration() {
                             time = (time / clip.duration()).fract() * clip.duration();
-                            // Reset all keyframes cached indexes
-                            layer
-                                .keyframe
-                                .iter_mut()
-                                .for_each(|x| *x = Default::default())
+                            // // Reset all keyframes cached indexes
+                            // layer
+                            //     .keyframe
+                            //     .iter_mut()
+                            //     .for_each(|x| *x = Default::default())
                         }
                     } else {
                         // Hold
@@ -174,28 +192,43 @@ pub(crate) fn animator_udpate(
     }
 }
 
-pub(crate) fn animator_transform_update(
+#[derive(Default, Debug)]
+pub struct Visited {
+    table: fnv::FnvHashSet<*const u8>,
+}
+
+impl Visited {
+    pub fn clear(&mut self) {
+        self.table.clear()
+    }
+
+    pub fn is_visited<T>(&mut self, ptr: *const T) -> bool {
+        let ptr = ptr as *const u8;
+        if self.table.contains(&ptr) {
+            true
+        } else {
+            self.table.insert(ptr);
+            false
+        }
+    }
+}
+
+pub(crate) fn animator_transform_update_system(
     clips: Res<Assets<Clip>>,
     mut animators_query: Query<(&mut Animator,)>,
     mut transform_query: Query<(&mut Transform,)>,
 ) {
     // TODO: Make const
-    let TRANSLATION: Name = Name::from_str("Transform.translation");
-    let ROTATION: Name = Name::from_str("Transform.rotation");
-    let SCALE: Name = Name::from_str("Transform.scale");
+    let translation_name: Name = Name::from_str("Transform.translation");
+    let rotation_name: Name = Name::from_str("Transform.rotation");
+    let scale_name: Name = Name::from_str("Transform.scale");
 
-    // let mut visited = fnv::FnvHashSet::default();
-
-    // let viz = if visited.contains(&ptr) {
-    //     true
-    // } else {
-    //     visited.insert(*ptr);
-    //     false
-    // };
+    let mut visited = Visited::default();
+    // let mut transforms = vec![];
 
     for (mut animator,) in animators_query.iter_mut() {
         let animator = &mut *animator;
-        // visited.clear();
+        visited.clear();
 
         for (layer, clip_handle, entities) in animator.animate() {
             let w = layer.weight;
@@ -212,46 +245,85 @@ pub(crate) fn animator_transform_update(
                 let mut scale = u16::MAX;
 
                 for (property_index, prop_name) in clip.properties().iter().enumerate() {
-                    if translation == u16::MAX && prop_name == &TRANSLATION {
+                    if translation == u16::MAX && prop_name == &translation_name {
                         translation = property_index as u16;
-                    } else if rotation == u16::MAX && prop_name == &ROTATION {
+                    } else if rotation == u16::MAX && prop_name == &rotation_name {
                         rotation = property_index as u16;
-                    } else if scale == u16::MAX && prop_name == &SCALE {
+                    } else if scale == u16::MAX && prop_name == &scale_name {
                         scale = property_index as u16;
                     }
                 }
 
+                // transforms.clear();
+
+                // // SAFETY: Pre-fetch all transforms to avoid calling get_mut multiple fimes
+                // // this is safe because it doesn't change the safe logic
+                // unsafe {
+                //     for entry in entities {
+                //         transforms.push(
+                //             entry
+                //                 .map(|entity| transform_query.get_unsafe(entity).ok())
+                //                 .flatten()
+                //                 .map(|(transform,)| transform),
+                //         );
+                //     }
+                // }
+
                 for (curve_index, (entry, curve)) in clip.curves().enumerate() {
-                    if entry.property_index != translation
-                        || entry.property_index != rotation
-                        || entry.property_index != scale
+                    let property_index = entry.property_index;
+
+                    // Pre check before fetching the entity
+                    if property_index != translation
+                        || property_index != rotation
+                        || property_index != scale
                     {
                         continue;
                     }
 
                     if let Some(entity) = entities[entry.entity_index as usize] {
                         // Entity found
+                        // TODO: Optimize for entity fetch
                         if let Ok((mut transform,)) = transform_query.get_mut(entity) {
-                            if entry.property_index == translation {
+                            if property_index == translation {
                                 if let CurveUntyped::Vec3(curve) = curve {
-                                    let (k, v) =
-                                        curve.sample_indexed(layer.keyframe[curve_index], time);
-                                    transform.translation = v;
-                                    layer.keyframe[curve_index] = k;
+                                    // let (k, v) =
+                                    //     curve.sample_indexed(layer.keyframe[curve_index], time);
+                                    // layer.keyframe[curve_index] = k;
+                                    let v = curve.sample(time);
+
+                                    if visited.is_visited(transform.translation.as_ref().as_ptr()) {
+                                        transform.translation =
+                                            LerpValue::lerp(&transform.translation, &v, w);
+                                    } else {
+                                        transform.translation = v;
+                                    }
                                 }
-                            } else if entry.property_index == rotation {
+                            } else if property_index == rotation {
                                 if let CurveUntyped::Quat(curve) = curve {
-                                    let (k, v) =
-                                        curve.sample_indexed(layer.keyframe[curve_index], time);
-                                    transform.rotation = v;
-                                    layer.keyframe[curve_index] = k;
+                                    // let (k, v) =
+                                    //     curve.sample_indexed(layer.keyframe[curve_index], time);
+                                    // layer.keyframe[curve_index] = k;
+                                    let v = curve.sample(time);
+
+                                    if visited.is_visited(transform.rotation.as_ref().as_ptr()) {
+                                        transform.rotation =
+                                            LerpValue::lerp(&transform.rotation, &v, w);
+                                    } else {
+                                        transform.rotation = v;
+                                    }
                                 }
-                            } else if entry.property_index == scale {
+                            } else if property_index == scale {
                                 if let CurveUntyped::Vec3(curve) = curve {
-                                    let (k, v) =
-                                        curve.sample_indexed(layer.keyframe[curve_index], time);
-                                    transform.scale = v;
-                                    layer.keyframe[curve_index] = k;
+                                    // let (k, v) =
+                                    //     curve.sample_indexed(layer.keyframe[curve_index], time);
+                                    // layer.keyframe[curve_index] = k;
+                                    let v = curve.sample(time);
+
+                                    if visited.is_visited(transform.scale.as_ref().as_ptr()) {
+                                        transform.scale = LerpValue::lerp(&transform.scale, &v, w);
+                                    } else {
+                                        transform.scale = v;
+                                    }
                                 }
                             }
                         }
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index a3cdfbcfc9a6a..db2a2ea2d7964 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -3,23 +3,25 @@ use bevy_asset::AddAsset;
 //use bevy_ecs::prelude::*;
 use bevy_type_registry::RegisterType;
 
+mod custom;
+//mod generic;
+
 pub mod clip;
 pub mod curve;
-pub mod custom;
-
-pub mod generic;
 mod hierarchy;
 pub mod lerping;
 mod skinned_mesh;
 
-pub use crate::generic::*;
+pub use crate::custom::*;
+//pub use crate::generic::*;
 pub use crate::hierarchy::Hierarchy;
 pub use crate::skinned_mesh::*;
 
 pub mod prelude {
     pub use crate::clip::Clip;
     pub use crate::curve::*;
-    pub use crate::generic::Animator;
+    pub use crate::custom::Animator;
+    //pub use crate::generic::Animator;
     pub use crate::hierarchy::Hierarchy;
     pub use crate::lerping::LerpValue;
     pub use crate::skinned_mesh::{SkinAsset, SkinComponent, SkinDebugger};
@@ -42,8 +44,10 @@ impl Plugin for AnimationPlugin {
         app.add_asset::<clip::Clip>()
             //.add_asset_loader(ClipLoader)
             .register_component::<Animator>()
-            .add_system_to_stage(stage::ANIMATE, animator_binding_system)
-            .add_system_to_stage(stage::ANIMATE, animator_update_system);
+            // .add_system_to_stage(stage::ANIMATE, animator_binding_system)
+            // .add_system_to_stage(stage::ANIMATE, animator_update_system);
+            .add_system_to_stage(stage::ANIMATE, animator_update_system)
+            .add_system_to_stage(stage::ANIMATE, animator_transform_update_system);
 
         // Skinning
         app.add_asset::<SkinAsset>()
@@ -51,7 +55,7 @@ impl Plugin for AnimationPlugin {
             .register_component_with::<SkinComponent>(|reg| reg.map_entities())
             .register_component::<SkinDebugger>()
             .add_startup_system(skinning_setup)
-            .add_system_to_stage(stage::ANIMATE, skinning_update)
+            .add_system_to_stage(stage::POST_UPDATE, skinning_update)
             .add_system_to_stage(stage::POST_UPDATE, skinning_debugger_update);
     }
 }

From 1d8fe77bdf9c746458ae13e27fcf36c3c2c30b61 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sun, 6 Dec 2020 12:19:30 -0300
Subject: [PATCH 031/153] small optimizations

---
 crates/bevy_animation/src/custom.rs | 202 +++++++++++++++++-----------
 1 file changed, 124 insertions(+), 78 deletions(-)

diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index cc25cdb76cded..16f11fddb5248 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -28,7 +28,12 @@ impl Default for Layer {
     }
 }
 
-#[derive(Default, Debug, Properties)]
+#[derive(Default, Debug)]
+struct Bind {
+    entities: Vec<Option<Entity>>,
+}
+
+#[derive(Debug, Properties)]
 pub struct Animator {
     clips: Vec<Handle<Clip>>,
     #[property(ignore)]
@@ -37,9 +42,15 @@ pub struct Animator {
     pub layers: Vec<Layer>,
 }
 
-#[derive(Default, Debug)]
-struct Bind {
-    entities: Vec<Option<Entity>>,
+impl Default for Animator {
+    fn default() -> Self {
+        Self {
+            clips: vec![],
+            bind_clips: vec![],
+            time_scale: 1.0,
+            layers: vec![],
+        }
+    }
 }
 
 impl Animator {
@@ -82,7 +93,7 @@ pub struct LayerIterator<'a> {
 }
 
 impl<'a> Iterator for LayerIterator<'a> {
-    type Item = (&'a Layer, &'a Handle<Clip>, &'a [Option<Entity>]);
+    type Item = (usize, &'a Layer, &'a Handle<Clip>, &'a [Option<Entity>]);
 
     fn next(&mut self) -> Option<Self::Item> {
         let index = self.index;
@@ -92,26 +103,52 @@ impl<'a> Iterator for LayerIterator<'a> {
         let clip_handle = self.animator.clips.get(layer.clip as usize)?;
         let entities = &self.animator.bind_clips.get(layer.clip as usize)?.entities[..];
 
-        return Some((layer, clip_handle, entities));
+        return Some((index, layer, clip_handle, entities));
+    }
+}
+
+#[derive(Default, Debug, Properties)]
+pub struct KeyframeCache {
+    cache: Vec<Vec<usize>>,
+}
+
+impl KeyframeCache {
+    pub fn get(&mut self, layer_index: usize) -> &mut Vec<usize> {
+        self.cache.resize_with(layer_index + 1, Default::default);
+        &mut self.cache[layer_index]
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+#[tracing::instrument(skip(commands, time, clips, animators_query, children_query, name_query))]
 pub(crate) fn animator_update_system(
+    commands: &mut Commands,
     time: Res<Time>,
     clips: Res<Assets<Clip>>,
-    mut animators_query: Query<(Entity, &mut Animator)>,
+    mut animators_query: Query<(
+        Entity,
+        &mut Animator,
+        Option<&KeyframeCache>,
+        Option<&Visited>,
+    )>,
     mut children_query: Query<(&Children,)>,
     mut name_query: Query<(&Parent, &Name)>,
 ) {
-    let delta_time = time.delta_seconds;
-
-    for (animator_entity, mut animator) in animators_query.iter_mut() {
+    for (animator_entity, mut animator, keyframe_cache, visited) in animators_query.iter_mut() {
         let animator = &mut *animator;
 
+        // Insert KeyframeCache if not already
+        if keyframe_cache.is_none() {
+            commands.insert_one(animator_entity, KeyframeCache::default());
+        }
+
+        if visited.is_none() {
+            commands.insert_one(animator_entity, Visited::default());
+        }
+
         // Time scales by component
-        let delta_time = delta_time * animator.time_scale;
+        let delta_time = time.delta_seconds * animator.time_scale;
 
         let w_total = animator
             .layers
@@ -192,9 +229,17 @@ pub(crate) fn animator_update_system(
     }
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+struct Ptr(*const u8);
+
+// SAFETY: Store pointers to each attribute to be updated, a clip can't have two pointers
+// with the same value. Each clip per Animator will be updated sequentially
+unsafe impl Send for Ptr {}
+unsafe impl Sync for Ptr {}
+
 #[derive(Default, Debug)]
 pub struct Visited {
-    table: fnv::FnvHashSet<*const u8>,
+    table: fnv::FnvHashSet<Ptr>,
 }
 
 impl Visited {
@@ -204,18 +249,19 @@ impl Visited {
 
     pub fn is_visited<T>(&mut self, ptr: *const T) -> bool {
         let ptr = ptr as *const u8;
-        if self.table.contains(&ptr) {
+        if self.table.contains(&Ptr(ptr)) {
             true
         } else {
-            self.table.insert(ptr);
+            self.table.insert(Ptr(ptr));
             false
         }
     }
 }
 
+#[tracing::instrument(skip(clips, animators_query, transform_query))]
 pub(crate) fn animator_transform_update_system(
     clips: Res<Assets<Clip>>,
-    mut animators_query: Query<(&mut Animator,)>,
+    mut animators_query: Query<(&Animator, &mut KeyframeCache, &mut Visited)>,
     mut transform_query: Query<(&mut Transform,)>,
 ) {
     // TODO: Make const
@@ -223,22 +269,26 @@ pub(crate) fn animator_transform_update_system(
     let rotation_name: Name = Name::from_str("Transform.rotation");
     let scale_name: Name = Name::from_str("Transform.scale");
 
-    let mut visited = Visited::default();
-    // let mut transforms = vec![];
+    let mut transforms = vec![];
+
+    for (animator, mut keyframe_cache, mut visited) in animators_query.iter_mut() {
+        let keyframe_cache = &mut *keyframe_cache;
 
-    for (mut animator,) in animators_query.iter_mut() {
-        let animator = &mut *animator;
         visited.clear();
 
-        for (layer, clip_handle, entities) in animator.animate() {
+        for (layer_index, layer, clip_handle, entities) in animator.animate() {
             let w = layer.weight;
             if w < 1.0e-8 {
                 continue;
             }
 
-            let time = layer.time;
-
             if let Some(clip) = clips.get(clip_handle) {
+                let time = layer.time;
+
+                // Get keyframes and ensure capacity
+                let keyframes = keyframe_cache.get(layer_index);
+                keyframes.resize(clip.len() as usize, 0);
+
                 // Fetch properties indexes for this particular clip
                 let mut translation = u16::MAX;
                 let mut rotation = u16::MAX;
@@ -254,79 +304,75 @@ pub(crate) fn animator_transform_update_system(
                     }
                 }
 
-                // transforms.clear();
-
-                // // SAFETY: Pre-fetch all transforms to avoid calling get_mut multiple fimes
-                // // this is safe because it doesn't change the safe logic
-                // unsafe {
-                //     for entry in entities {
-                //         transforms.push(
-                //             entry
-                //                 .map(|entity| transform_query.get_unsafe(entity).ok())
-                //                 .flatten()
-                //                 .map(|(transform,)| transform),
-                //         );
-                //     }
-                // }
+                transforms.clear();
+
+                // SAFETY: Pre-fetch all transforms to avoid calling get_mut multiple times
+                // this is safe because it doesn't change the safe logic
+                unsafe {
+                    for entry in entities {
+                        transforms.push(
+                            entry
+                                .map(|entity| transform_query.get_unsafe(entity).ok())
+                                .flatten()
+                                .map(|(transform,)| transform),
+                        );
+                    }
+                }
 
                 for (curve_index, (entry, curve)) in clip.curves().enumerate() {
                     let property_index = entry.property_index;
 
                     // Pre check before fetching the entity
                     if property_index != translation
-                        || property_index != rotation
-                        || property_index != scale
+                        && property_index != rotation
+                        && property_index != scale
                     {
                         continue;
                     }
 
-                    if let Some(entity) = entities[entry.entity_index as usize] {
+                    if let Some(Some(ref mut transform)) =
+                        transforms.get_mut(entry.entity_index as usize)
+                    {
                         // Entity found
                         // TODO: Optimize for entity fetch
-                        if let Ok((mut transform,)) = transform_query.get_mut(entity) {
-                            if property_index == translation {
-                                if let CurveUntyped::Vec3(curve) = curve {
-                                    // let (k, v) =
-                                    //     curve.sample_indexed(layer.keyframe[curve_index], time);
-                                    // layer.keyframe[curve_index] = k;
-                                    let v = curve.sample(time);
-
-                                    if visited.is_visited(transform.translation.as_ref().as_ptr()) {
-                                        transform.translation =
-                                            LerpValue::lerp(&transform.translation, &v, w);
-                                    } else {
-                                        transform.translation = v;
-                                    }
+                        // if let Ok((mut transform,)) = transform_query.get_mut(entity) {
+                        if property_index == translation {
+                            if let CurveUntyped::Vec3(curve) = curve {
+                                let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
+                                keyframes[curve_index] = k;
+
+                                if visited.is_visited(transform.translation.as_ref().as_ptr()) {
+                                    transform.translation =
+                                        LerpValue::lerp(&transform.translation, &v, w);
+                                } else {
+                                    transform.translation = v;
                                 }
-                            } else if property_index == rotation {
-                                if let CurveUntyped::Quat(curve) = curve {
-                                    // let (k, v) =
-                                    //     curve.sample_indexed(layer.keyframe[curve_index], time);
-                                    // layer.keyframe[curve_index] = k;
-                                    let v = curve.sample(time);
-
-                                    if visited.is_visited(transform.rotation.as_ref().as_ptr()) {
-                                        transform.rotation =
-                                            LerpValue::lerp(&transform.rotation, &v, w);
-                                    } else {
-                                        transform.rotation = v;
-                                    }
+                            }
+                        } else if property_index == rotation {
+                            if let CurveUntyped::Quat(curve) = curve {
+                                let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
+                                keyframes[curve_index] = k;
+
+                                if visited.is_visited(transform.rotation.as_ref().as_ptr()) {
+                                    transform.rotation =
+                                        LerpValue::lerp(&transform.rotation, &v, w);
+                                } else {
+                                    transform.rotation = v;
                                 }
-                            } else if property_index == scale {
-                                if let CurveUntyped::Vec3(curve) = curve {
-                                    // let (k, v) =
-                                    //     curve.sample_indexed(layer.keyframe[curve_index], time);
-                                    // layer.keyframe[curve_index] = k;
-                                    let v = curve.sample(time);
-
-                                    if visited.is_visited(transform.scale.as_ref().as_ptr()) {
-                                        transform.scale = LerpValue::lerp(&transform.scale, &v, w);
-                                    } else {
-                                        transform.scale = v;
-                                    }
+                            }
+                        } else if property_index == scale {
+                            if let CurveUntyped::Vec3(curve) = curve {
+                                let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
+                                keyframes[curve_index] = k;
+
+                                if visited.is_visited(transform.scale.as_ref().as_ptr()) {
+                                    transform.scale = LerpValue::lerp(&transform.scale, &v, w);
+                                } else {
+                                    transform.scale = v;
                                 }
                             }
                         }
+                        //}
                     }
                 }
             }

From 9842c03236b3ea7c37da8c0fb2207d8af0e5772d Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sun, 6 Dec 2020 21:27:19 -0300
Subject: [PATCH 032/153] changed the clip format, but still about the same
 perf

---
 crates/bevy_animation/src/curve.rs  |  48 ++--
 crates/bevy_animation/src/custom.rs | 395 +++++++++++++++++++++-------
 crates/bevy_animation/src/lib.rs    |  11 +-
 crates/bevy_gltf/src/loader.rs      |  32 +--
 4 files changed, 342 insertions(+), 144 deletions(-)

diff --git a/crates/bevy_animation/src/curve.rs b/crates/bevy_animation/src/curve.rs
index 2ea21666dc087..7649c7a86189e 100644
--- a/crates/bevy_animation/src/curve.rs
+++ b/crates/bevy_animation/src/curve.rs
@@ -64,10 +64,7 @@ impl<T: Clone> Clone for Curve<T> {
     }
 }
 
-impl<T> Curve<T>
-where
-    T: LerpValue + Clone + 'static,
-{
+impl<T> Curve<T> {
     pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
         // TODO: Result?
 
@@ -104,10 +101,34 @@ where
         }
     }
 
+    // pub fn insert(&mut self, time_sample: f32, value: T) {
+    // }
+
+    // pub fn remove(&mut self, index: usize) {
+    //assert!(samples.len() > 1, "curve can't be empty");
+    // }
+
     pub fn duration(&self) -> f32 {
         self.samples.last().copied().unwrap_or(0.0)
     }
 
+    pub fn add_offset_time(&mut self, time_offset: f32) {
+        self.samples.iter_mut().for_each(|t| *t += time_offset);
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
+        self.samples.iter().copied().zip(self.values.iter())
+    }
+
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
+        self.samples.iter().copied().zip(self.values.iter_mut())
+    }
+}
+
+impl<T> Curve<T>
+where
+    T: LerpValue + Clone + 'static,
+{
     /// Easer to use sampling method that don't have time restrictions or needs
     /// the keyframe index, but is more expensive always `O(n)`. Which means
     /// sampling takes longer to evaluate as much as time get closer to curve duration
@@ -167,25 +188,6 @@ where
         (index, value)
     }
 
-    pub fn add_offset_time(&mut self, time_offset: f32) {
-        self.samples.iter_mut().for_each(|t| *t += time_offset);
-    }
-
-    // pub fn insert(&mut self, time_sample: f32, value: T) {
-    // }
-
-    // pub fn remove(&mut self, index: usize) {
-    //assert!(samples.len() > 1, "curve can't be empty");
-    // }
-
-    pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
-        self.samples.iter().copied().zip(self.values.iter())
-    }
-
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
-        self.samples.iter().copied().zip(self.values.iter_mut())
-    }
-
     #[inline(always)]
     pub fn value_type(&self) -> TypeId {
         TypeId::of::<T>()
diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 16f11fddb5248..1f3207929f5b2 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -1,14 +1,218 @@
 use anyhow::Result;
-use bevy_asset::{Assets, Handle /*, HandleUntyped*/};
+use bevy_asset::{Assets, Handle /*HandleUntyped*/};
 use bevy_core::prelude::*;
 use bevy_ecs::prelude::*;
+use bevy_math::prelude::*;
 use bevy_property::Properties;
+//use bevy_render::color::Color;
 use bevy_transform::prelude::*;
+use bevy_type_registry::TypeUuid;
+use fnv::FnvHashMap as HashMap;
+use smallvec::{smallvec, SmallVec};
+use std::any::Any;
 
-use crate::clip::Clip;
-use crate::curve::CurveUntyped;
+use crate::curve::Curve;
+use crate::hierarchy::Hierarchy;
 use crate::lerping::LerpValue;
 
+#[derive(Debug)]
+pub struct Curves<T> {
+    id: usize,
+    /// Maps each curve to an entity index or other value
+    indexes: SmallVec<[u16; 8]>,
+    curves: Vec<Curve<T>>,
+}
+
+impl<T> Curves<T> {
+    #[inline(always)]
+    pub fn len(&self) -> usize {
+        self.curves.len()
+    }
+
+    #[inline(always)]
+    pub fn iter(&self) -> impl Iterator<Item = (u16, &Curve<T>)> {
+        self.indexes.iter().copied().zip(self.curves.iter())
+    }
+}
+
+#[derive(Debug)]
+pub struct CurvesUntyped {
+    duration: f32,
+    untyped: Box<dyn Any + 'static>,
+}
+
+unsafe impl Send for CurvesUntyped {}
+unsafe impl Sync for CurvesUntyped {}
+
+impl CurvesUntyped {
+    #[inline(always)]
+    pub fn downcast_ref<T: 'static>(&self) -> Option<&Curves<T>> {
+        self.untyped.downcast_ref()
+    }
+
+    #[inline(always)]
+    pub fn downcast_mut<T: 'static>(&mut self) -> Option<&mut Curves<T>> {
+        self.untyped.downcast_mut()
+    }
+}
+
+// TODO: impl Serialize, Deserialize
+#[derive(Debug, TypeUuid)]
+#[uuid = "79e2ea58-8bf7-43af-8219-5898edb02f80"]
+pub struct Clip {
+    //#[serde(default = "clip_default_warp")]
+    pub warp: bool,
+    duration: f32,
+    /// Entity identification made by parent index and name
+    hierarchy: Hierarchy,
+    properties: HashMap<String, CurvesUntyped>,
+}
+
+// fn clip_default_warp() -> bool {
+//     true
+// }
+
+impl Default for Clip {
+    fn default() -> Self {
+        Self {
+            warp: true,
+            duration: 0.0,
+            hierarchy: Hierarchy::default(),
+            properties: HashMap::default(),
+        }
+    }
+}
+
+impl Clip {
+    /// Property to be animated must be in the following format `"path/to/named_entity@Transform.translation.x"`
+    /// where the left side `@` defines a path to the entity to animate,
+    /// while the right side the path to a property to animate starting from the component.
+    ///
+    /// **NOTE** This is a expensive function
+    pub fn add_animated_prop<T>(&mut self, property_path: &str, mut curve: Curve<T>)
+    where
+        T: LerpValue + Clone + 'static,
+    {
+        // Split in entity and attribute path,
+        // NOTE: use rfind because it's expected the latter to be generally shorter
+        let path =
+            property_path.split_at(property_path.rfind('@').expect("property path missing @"));
+
+        let (entity_index, _) = self.hierarchy.get_or_insert_entity(path.0);
+        let target_name = path.1.split_at(1).1;
+
+        if let Some(curves_untyped) = self.properties.get_mut(target_name) {
+            let curves = curves_untyped
+                .downcast_mut::<T>()
+                .expect("properties can't have the same name and different curve types");
+
+            // If some entity was created it means this property is a new one so we can safely skip the attribute testing
+            if let Some(i) = curves
+                .indexes
+                .iter()
+                .position(|index| *index == entity_index)
+            {
+                // Found a property equal to the one been inserted, next replace the curve
+                std::mem::swap(&mut curves.curves[i], &mut curve);
+
+                // Update curve duration in two stages
+                let duration = curves
+                    .curves
+                    .iter()
+                    .map(|c| c.duration())
+                    .fold(0.0f32, |acc, x| acc.max(x));
+
+                std::mem::drop(curves);
+                curves_untyped.duration = duration;
+
+                std::mem::drop(curves_untyped);
+                self.duration = self
+                    .properties
+                    .iter()
+                    .map(|(_, c)| c.duration)
+                    .fold(0.0f32, |acc, x| acc.max(x));
+            } else {
+                // Append newly added curve
+                let duration = curve.duration();
+                curves.curves.push(curve);
+                curves.indexes.push(entity_index);
+                std::mem::drop(curves);
+
+                self.duration = self.duration.max(duration);
+                curves_untyped.duration = curves_untyped.duration.max(duration);
+            }
+            return;
+        }
+
+        self.duration = self.duration.max(curve.duration());
+        let id = self.properties.len();
+        self.properties.insert(
+            target_name.to_string(),
+            CurvesUntyped {
+                duration: curve.duration(),
+                untyped: Box::new(Curves {
+                    id,
+                    curves: vec![curve],
+                    indexes: smallvec![entity_index],
+                }),
+            },
+        );
+    }
+
+    // /// Number of animated properties in this clip
+    // #[inline(always)]
+    // pub fn len(&self) -> u16 {
+    //     self.curves.len() as u16
+    // }
+
+    // /// Returns the property curve property path.
+    // ///
+    // /// The clip stores a property path in a specific way to improve search performance
+    // /// thus it needs to rebuilt the curve property path in the human readable format
+    // pub fn get_property_path(&self, index: u16) -> String {
+    //     let CurveEntry {
+    //         entity_index,
+    //         property_index,
+    //     } = &self.entries[index as usize];
+    //
+    //     format!(
+    //         "{}@{}",
+    //         self.hierarchy
+    //             .get_entity_path_at(*entity_index)
+    //             .expect("property as an invalid entity"),
+    //         self.properties[*property_index as usize].as_str()
+    //     )
+    // }
+
+    /// Clip duration
+    #[inline(always)]
+    pub fn duration(&self) -> f32 {
+        self.duration
+    }
+
+    #[inline(always)]
+    pub fn hierarchy(&self) -> &Hierarchy {
+        &self.hierarchy
+    }
+
+    // #[inline(always)]
+    // pub fn properties(&self) -> &[Name] {
+    //     &self.properties[..]
+    // }
+
+    // #[inline(always)]
+    // pub fn curves(&self) -> impl Iterator<Item = (&Curves, &CurveUntyped)> {
+    //     self.entries.iter().zip(self.curves.iter())
+    // }
+
+    // #[inline(always)]
+    // pub fn get(&self, curve_index: u16) -> Option<&CurveUntyped> {
+    //     self.curves.get(curve_index as usize)
+    // }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 #[derive(Debug, Clone, Properties)]
 pub struct Layer {
     pub weight: f32,
@@ -113,9 +317,9 @@ pub struct KeyframeCache {
 }
 
 impl KeyframeCache {
-    pub fn get(&mut self, layer_index: usize) -> &mut Vec<usize> {
-        self.cache.resize_with(layer_index + 1, Default::default);
-        &mut self.cache[layer_index]
+    pub fn get(&mut self, index: usize) -> &mut Vec<usize> {
+        self.cache.resize_with(index + 1, Default::default);
+        &mut self.cache[index]
     }
 }
 
@@ -130,7 +334,7 @@ pub(crate) fn animator_update_system(
         Entity,
         &mut Animator,
         Option<&KeyframeCache>,
-        Option<&Visited>,
+        Option<&AnimatorBlending>,
     )>,
     mut children_query: Query<(&Children,)>,
     mut name_query: Query<(&Parent, &Name)>,
@@ -144,7 +348,7 @@ pub(crate) fn animator_update_system(
         }
 
         if visited.is_none() {
-            commands.insert_one(animator_entity, Visited::default());
+            commands.insert_one(animator_entity, AnimatorBlending::default());
         }
 
         // Time scales by component
@@ -238,22 +442,29 @@ unsafe impl Send for Ptr {}
 unsafe impl Sync for Ptr {}
 
 #[derive(Default, Debug)]
-pub struct Visited {
+pub struct AnimatorBlending {
     table: fnv::FnvHashSet<Ptr>,
 }
 
-impl Visited {
-    pub fn clear(&mut self) {
-        self.table.clear()
+impl AnimatorBlending {
+    pub fn begin_blending(&mut self) -> AnimatorBlendGroup {
+        self.table.clear();
+        AnimatorBlendGroup { blending: self }
     }
+}
 
-    pub fn is_visited<T>(&mut self, ptr: *const T) -> bool {
-        let ptr = ptr as *const u8;
-        if self.table.contains(&Ptr(ptr)) {
-            true
+pub struct AnimatorBlendGroup<'a> {
+    blending: &'a mut AnimatorBlending,
+}
+
+impl<'a> AnimatorBlendGroup<'a> {
+    pub fn blend_lerp<T: LerpValue>(&mut self, attribute: &mut T, value: T, weight: f32) {
+        let ptr = Ptr(attribute as *const _ as *const u8);
+        if self.blending.table.contains(&ptr) {
+            *attribute = LerpValue::lerp(&*attribute, &value, weight);
         } else {
-            self.table.insert(Ptr(ptr));
-            false
+            self.blending.table.insert(ptr);
+            *attribute = value;
         }
     }
 }
@@ -261,22 +472,16 @@ impl Visited {
 #[tracing::instrument(skip(clips, animators_query, transform_query))]
 pub(crate) fn animator_transform_update_system(
     clips: Res<Assets<Clip>>,
-    mut animators_query: Query<(&Animator, &mut KeyframeCache, &mut Visited)>,
-    mut transform_query: Query<(&mut Transform,)>,
+    mut animators_query: Query<(&Animator, &mut KeyframeCache, &mut AnimatorBlending)>,
+    transform_query: Query<(&mut Transform,)>,
 ) {
-    // TODO: Make const
-    let translation_name: Name = Name::from_str("Transform.translation");
-    let rotation_name: Name = Name::from_str("Transform.rotation");
-    let scale_name: Name = Name::from_str("Transform.scale");
+    let mut components = vec![];
 
-    let mut transforms = vec![];
-
-    for (animator, mut keyframe_cache, mut visited) in animators_query.iter_mut() {
+    for (animator, mut keyframe_cache, mut animator_blend) in animators_query.iter_mut() {
         let keyframe_cache = &mut *keyframe_cache;
+        let mut blend_group = animator_blend.begin_blending();
 
-        visited.clear();
-
-        for (layer_index, layer, clip_handle, entities) in animator.animate() {
+        for (_, layer, clip_handle, entities) in animator.animate() {
             let w = layer.weight;
             if w < 1.0e-8 {
                 continue;
@@ -285,32 +490,14 @@ pub(crate) fn animator_transform_update_system(
             if let Some(clip) = clips.get(clip_handle) {
                 let time = layer.time;
 
-                // Get keyframes and ensure capacity
-                let keyframes = keyframe_cache.get(layer_index);
-                keyframes.resize(clip.len() as usize, 0);
-
-                // Fetch properties indexes for this particular clip
-                let mut translation = u16::MAX;
-                let mut rotation = u16::MAX;
-                let mut scale = u16::MAX;
-
-                for (property_index, prop_name) in clip.properties().iter().enumerate() {
-                    if translation == u16::MAX && prop_name == &translation_name {
-                        translation = property_index as u16;
-                    } else if rotation == u16::MAX && prop_name == &rotation_name {
-                        rotation = property_index as u16;
-                    } else if scale == u16::MAX && prop_name == &scale_name {
-                        scale = property_index as u16;
-                    }
-                }
-
-                transforms.clear();
+                // ~15us
+                components.clear();
 
                 // SAFETY: Pre-fetch all transforms to avoid calling get_mut multiple times
                 // this is safe because it doesn't change the safe logic
                 unsafe {
                     for entry in entities {
-                        transforms.push(
+                        components.push(
                             entry
                                 .map(|entity| transform_query.get_unsafe(entity).ok())
                                 .flatten()
@@ -319,60 +506,66 @@ pub(crate) fn animator_transform_update_system(
                     }
                 }
 
-                for (curve_index, (entry, curve)) in clip.curves().enumerate() {
-                    let property_index = entry.property_index;
+                // ~23us
+                if let Some(curves) = clip
+                    .properties
+                    .get("Transform.translation")
+                    .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
+                    .flatten()
+                {
+                    // Get keyframes and ensure capacity
+                    let keyframes = keyframe_cache.get(curves.id);
+                    keyframes.resize(curves.len() as usize, 0);
+
+                    for (curve_index, (entity_index, curve)) in curves.iter().enumerate() {
+                        if let Some(ref mut component) = components[entity_index as usize] {
+                            let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
+                            keyframes[curve_index] = k;
+                            // let v = curve.sample(time);
+                            blend_group.blend_lerp(&mut component.translation, v, w);
+                        }
+                    }
+                }
 
-                    // Pre check before fetching the entity
-                    if property_index != translation
-                        && property_index != rotation
-                        && property_index != scale
-                    {
-                        continue;
+                // ~23us
+                if let Some(curves) = clip
+                    .properties
+                    .get("Transform.rotation")
+                    .map(|curve_untyped| curve_untyped.downcast_ref::<Quat>())
+                    .flatten()
+                {
+                    // Get keyframes and ensure capacity
+                    let keyframes = keyframe_cache.get(curves.id);
+                    keyframes.resize(curves.len() as usize, 0);
+
+                    for (curve_index, (entity_index, curve)) in curves.iter().enumerate() {
+                        if let Some(ref mut component) = components[entity_index as usize] {
+                            let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
+                            keyframes[curve_index] = k;
+                            // let v = curve.sample(time);
+                            blend_group.blend_lerp(&mut component.rotation, v, w);
+                        }
                     }
+                }
 
-                    if let Some(Some(ref mut transform)) =
-                        transforms.get_mut(entry.entity_index as usize)
-                    {
-                        // Entity found
-                        // TODO: Optimize for entity fetch
-                        // if let Ok((mut transform,)) = transform_query.get_mut(entity) {
-                        if property_index == translation {
-                            if let CurveUntyped::Vec3(curve) = curve {
-                                let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
-                                keyframes[curve_index] = k;
-
-                                if visited.is_visited(transform.translation.as_ref().as_ptr()) {
-                                    transform.translation =
-                                        LerpValue::lerp(&transform.translation, &v, w);
-                                } else {
-                                    transform.translation = v;
-                                }
-                            }
-                        } else if property_index == rotation {
-                            if let CurveUntyped::Quat(curve) = curve {
-                                let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
-                                keyframes[curve_index] = k;
-
-                                if visited.is_visited(transform.rotation.as_ref().as_ptr()) {
-                                    transform.rotation =
-                                        LerpValue::lerp(&transform.rotation, &v, w);
-                                } else {
-                                    transform.rotation = v;
-                                }
-                            }
-                        } else if property_index == scale {
-                            if let CurveUntyped::Vec3(curve) = curve {
-                                let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
-                                keyframes[curve_index] = k;
-
-                                if visited.is_visited(transform.scale.as_ref().as_ptr()) {
-                                    transform.scale = LerpValue::lerp(&transform.scale, &v, w);
-                                } else {
-                                    transform.scale = v;
-                                }
-                            }
+                // ~23us
+                if let Some(curves) = clip
+                    .properties
+                    .get("Transform.scale")
+                    .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
+                    .flatten()
+                {
+                    // Get keyframes and ensure capacity
+                    let keyframes = keyframe_cache.get(curves.id);
+                    keyframes.resize(curves.len() as usize, 0);
+
+                    for (curve_index, (entity_index, curve)) in curves.iter().enumerate() {
+                        if let Some(ref mut component) = components[entity_index as usize] {
+                            let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
+                            keyframes[curve_index] = k;
+                            //let v = curve.sample(time);
+                            blend_group.blend_lerp(&mut component.scale, v, w);
                         }
-                        //}
                     }
                 }
             }
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index db2a2ea2d7964..eba03ed65c28f 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -6,7 +6,7 @@ use bevy_type_registry::RegisterType;
 mod custom;
 //mod generic;
 
-pub mod clip;
+//pub mod clip;
 pub mod curve;
 mod hierarchy;
 pub mod lerping;
@@ -18,9 +18,10 @@ pub use crate::hierarchy::Hierarchy;
 pub use crate::skinned_mesh::*;
 
 pub mod prelude {
-    pub use crate::clip::Clip;
-    pub use crate::curve::*;
+    //pub use crate::clip::Clip;
+    pub use crate::curve::{Curve, CurveUntyped};
     pub use crate::custom::Animator;
+    pub use crate::custom::Clip;
     //pub use crate::generic::Animator;
     pub use crate::hierarchy::Hierarchy;
     pub use crate::lerping::LerpValue;
@@ -41,9 +42,9 @@ impl Plugin for AnimationPlugin {
         app.add_stage_after(stage::UPDATE, stage::ANIMATE);
 
         // Generic animation
-        app.add_asset::<clip::Clip>()
+        app.add_asset::<prelude::Clip>()
             //.add_asset_loader(ClipLoader)
-            .register_component::<Animator>()
+            .register_component::<prelude::Animator>()
             // .add_system_to_stage(stage::ANIMATE, animator_binding_system)
             // .add_system_to_stage(stage::ANIMATE, animator_update_system);
             .add_system_to_stage(stage::ANIMATE, animator_update_system)
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 1b6883e5220d6..ca12e64679b96 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -263,7 +263,9 @@ async fn load_gltf<'a, 'b>(
         clip.warp = true; // Enable warping by default
 
         let mut start_time = f32::MAX;
-        let mut clip_curves = vec![];
+
+        let mut clip_curves_rotation = vec![];
+        let mut clip_curves_translation_and_scale = vec![];
 
         // Each chanel defines how to sample the data and where it will be written
         for channel in animation.channels() {
@@ -299,29 +301,22 @@ async fn load_gltf<'a, 'b>(
                 ReadOutputs::Translations(values) => {
                     let values = values.map(|v| Vec3::from(v)).collect::<Vec<_>>();
                     property_path += "@Transform.translation";
-                    clip_curves.push((
-                        property_path,
-                        CurveUntyped::Vec3(Curve::new(time_stamps, values)),
-                    ));
+                    clip_curves_translation_and_scale
+                        .push((property_path, Curve::new(time_stamps, values)));
 
                     // TODO: This is a runtime importer so here's no place for further optimizations
                 }
                 ReadOutputs::Rotations(values) => {
                     let values = values.into_f32().map(|v| Quat::from(v)).collect::<Vec<_>>();
                     property_path += "@Transform.rotation";
-                    clip_curves.push((
-                        property_path,
-                        CurveUntyped::Quat(Curve::new(time_stamps, values)),
-                    ));
+                    clip_curves_rotation.push((property_path, Curve::new(time_stamps, values)));
                 }
                 ReadOutputs::Scales(values) => {
                     let values = values.map(|v| Vec3::from(v)).collect::<Vec<_>>();
 
                     property_path += "@Transform.scale";
-                    clip_curves.push((
-                        property_path,
-                        CurveUntyped::Vec3(Curve::new(time_stamps, values)),
-                    ));
+                    clip_curves_translation_and_scale
+                        .push((property_path, Curve::new(time_stamps, values)));
                 }
                 ReadOutputs::MorphTargetWeights(_) => {
                     unimplemented!("morph targets aren't current supported")
@@ -330,8 +325,15 @@ async fn load_gltf<'a, 'b>(
         }
 
         // Make sure the start frame is always 0.0
-        for (property_path, mut curve) in clip_curves {
-            curve.add_time_offset(-start_time);
+        for (property_path, mut curve) in clip_curves_rotation {
+            Curve::<Quat>::add_offset_time(&mut curve, -start_time);
+            //curve.add_time_offset(-start_time);
+            clip.add_animated_prop(&property_path, curve);
+        }
+
+        for (property_path, mut curve) in clip_curves_translation_and_scale {
+            Curve::<Vec3>::add_offset_time(&mut curve, -start_time);
+            //curve.add_time_offset(-start_time);
             clip.add_animated_prop(&property_path, curve);
         }
 

From 463ee345847abf3832faef64eb687ccffc967a8d Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Mon, 7 Dec 2020 00:55:29 -0300
Subject: [PATCH 033/153] last bits of optimization

---
 crates/bevy_animation/Cargo.toml    |   3 -
 crates/bevy_animation/src/custom.rs | 194 ++++++++++++++++++++++++++++
 2 files changed, 194 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index 1e282138df376..d023d0512fb11 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -30,9 +30,6 @@ tracing = { version = "0.1.21", features = ["attributes"] }
 [dev-dependencies]
 criterion = "0.3.3"
 
-# [profile.release]
-# debug = true
-
 [[bench]]
 name = "animator"
 harness = false
diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 1f3207929f5b2..b601f279b5e3e 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -447,6 +447,7 @@ pub struct AnimatorBlending {
 }
 
 impl AnimatorBlending {
+    #[inline(always)]
     pub fn begin_blending(&mut self) -> AnimatorBlendGroup {
         self.table.clear();
         AnimatorBlendGroup { blending: self }
@@ -458,6 +459,7 @@ pub struct AnimatorBlendGroup<'a> {
 }
 
 impl<'a> AnimatorBlendGroup<'a> {
+    #[inline(always)]
     pub fn blend_lerp<T: LerpValue>(&mut self, attribute: &mut T, value: T, weight: f32) {
         let ptr = Ptr(attribute as *const _ as *const u8);
         if self.blending.table.contains(&ptr) {
@@ -572,3 +574,195 @@ pub(crate) fn animator_transform_update_system(
         }
     }
 }
+
+// #[cfg(test)]
+// #[allow(dead_code)]
+// mod tests {
+//     use super::*;
+//     use crate::curve::Curve;
+//     use bevy_ecs::{ArchetypeComponent, TypeAccess};
+
+//     struct AnimatorTestBench {
+//         app: bevy_app::App,
+//         entities: Vec<Entity>,
+//         schedule: bevy_ecs::Schedule,
+//     }
+
+//     impl AnimatorTestBench {
+//         fn new() -> Self {
+//             let mut app_builder = bevy_app::App::build();
+//             app_builder
+//                 .add_plugin(bevy_type_registry::TypeRegistryPlugin::default())
+//                 .add_plugin(bevy_core::CorePlugin::default())
+//                 .add_plugin(bevy_app::ScheduleRunnerPlugin::default())
+//                 .add_plugin(bevy_asset::AssetPlugin)
+//                 .add_plugin(bevy_transform::TransformPlugin)
+//                 .add_plugin(crate::AnimationPlugin);
+
+//             let mut world = World::new();
+//             let mut world_builder = world.build();
+//             let base = (
+//                 GlobalTransform::default(),
+//                 Transform::from_translation(Vec3::new(0.0, 1.0, 0.0)),
+//             );
+
+//             // Create animator and assign some clips
+//             let mut animator = Animator::default();
+//             {
+//                 let mut clip_a = Clip::default();
+//                 clip_a.add_animated_prop(
+//                     "@Transform.translation",
+//                     Curve::from_linear(0.0, 1.0, Vec3::unit_x(), -Vec3::unit_x()),
+//                 );
+//                 let rot = Curve::from_constant(Quat::identity());
+//                 clip_a.add_animated_prop("@Transform.rotation", rot.clone());
+//                 clip_a.add_animated_prop("/Node1@Transform.rotation", rot.clone());
+//                 clip_a.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
+
+//                 let mut clip_b = Clip::default();
+//                 clip_b.add_animated_prop(
+//                     "@Transform.translation",
+//                     Curve::from_constant(Vec3::zero()),
+//                 );
+//                 let rot = Curve::from_linear(
+//                     0.0,
+//                     1.0,
+//                     Quat::from_axis_angle(Vec3::unit_z(), 0.1),
+//                     Quat::from_axis_angle(Vec3::unit_z(), -0.1),
+//                 );
+//                 clip_b.add_animated_prop("@Transform.rotation", rot.clone());
+//                 clip_b.add_animated_prop("/Node1@Transform.rotation", rot.clone());
+//                 clip_b.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
+
+//                 let mut clips = app_builder
+//                     .resources_mut()
+//                     .get_mut::<Assets<Clip>>()
+//                     .unwrap();
+//                 let clip_a = clips.add(clip_a);
+//                 let clip_b = clips.add(clip_b);
+
+//                 animator.add_layer(clip_a, 0.5);
+//                 animator.add_layer(clip_b, 0.5);
+//             }
+
+//             let mut entities = vec![];
+//             entities.push(
+//                 world_builder
+//                     .spawn(base.clone())
+//                     .with(Name::from_str("Root"))
+//                     .with(animator)
+//                     .current_entity
+//                     .unwrap(),
+//             );
+//             world_builder.with_children(|world_builder| {
+//                 entities.push(
+//                     world_builder
+//                         .spawn(base.clone())
+//                         .with(Name::from_str("Node1"))
+//                         .current_entity()
+//                         .unwrap(),
+//                 );
+
+//                 world_builder.with_children(|world_builder| {
+//                     entities.push(
+//                         world_builder
+//                             .spawn(base.clone())
+//                             .with(Name::from_str("Node2"))
+//                             .current_entity()
+//                             .unwrap(),
+//                     );
+
+//                     world_builder.with_children(|world_builder| {
+//                         entities.push(
+//                             world_builder
+//                                 .spawn(base.clone())
+//                                 .with(Name::from_str("Node3"))
+//                                 .current_entity()
+//                                 .unwrap(),
+//                         );
+//                     });
+//                 });
+//             });
+
+//             app_builder.set_world(world);
+
+//             let mut schedule = bevy_ecs::Schedule::default();
+//             schedule.add_stage("update");
+//             schedule.add_stage_after("update", "post_update");
+//             schedule.add_system_to_stage("update", animator_update_system);
+//             schedule.add_system_to_stage("update", animator_transform_update_system);
+//             schedule.add_system_to_stage("post_update", parent_update_system);
+//             //schedule.add_system_to_stage("update", transform_propagate_system);
+
+//             schedule.initialize(&mut app_builder.app.world, &mut app_builder.app.resources);
+//             schedule.run(&mut app_builder.app.world, &mut app_builder.app.resources);
+
+//             Self {
+//                 app: app_builder.app,
+//                 entities,
+//                 schedule,
+//             }
+//         }
+
+//         fn run(&mut self) {
+//             self.schedule
+//                 .run(&mut self.app.world, &mut self.app.resources);
+//         }
+//     }
+
+//     #[test]
+//     #[cfg(feature = "extra-profiling-tests")]
+//     fn test_bench_update() {
+//         // ? NOTE: Mimics a basic system update behavior good for pref since criterion will pollute the
+//         // ? annotations with many expensive instructions
+//         let mut test_bench = AnimatorTestBench::new();
+//         test_bench.run();
+//         test_bench.run();
+
+//         // let mut schedule = bevy_ecs::Schedule::default();
+//         // schedule.add_stage("update");
+//         // schedule.add_system_to_stage("update", animator_transform_update_system);
+//         // schedule.initialize(&mut test_bench.app.world, &mut test_bench.app.resources);
+
+//         // let mut transform_system: Box<dyn System<Input = (), Output = ()>> =
+//         //     Box::new(animator_transform_update_system.system());
+
+//         // transform_system.initialize(&mut test_bench.app.world, &mut test_bench.app.resources);
+
+//         // fn animator_transform_update_system(
+//         //     clips: Res<Assets<Clip>>,
+//         //     mut animators_query: Query<(&Animator, &mut KeyframeCache, &mut AnimatorBlending)>,
+//         //     transform_query: Query<(&mut Transform,)>,
+//         // );
+
+//         let type_access = <TypeAccess<ArchetypeComponent>>::new(vec![], vec![]);
+//         for _ in 0..100_000 {
+//             // // Time tick
+//             // {
+//             //     let mut time = test_bench.app.resources.get_mut::<Time>().unwrap();
+//             //     time.delta_seconds += 0.016;
+//             //     time.delta_seconds_f64 += 0.016;
+//             // }
+
+//             //schedule.run(&mut test_bench.app.world, &mut test_bench.app.resources);
+
+//             //transform_system.run((), &mut test_bench.app.world, &mut test_bench.app.resources);
+
+//             // Fetching
+//             let clips = &*test_bench.app.resources.get::<Assets<Clip>>().unwrap();
+//             let clips =
+//                 unsafe { Res::new(std::ptr::NonNull::new(clips as *const _ as *mut _).unwrap()) };
+//             let animators_query = unsafe {
+//                 <Query<(&Animator, &mut KeyframeCache, &mut AnimatorBlending)>>::new(
+//                     &test_bench.app.world,
+//                     &type_access,
+//                 )
+//             };
+//             let transform_query =
+//                 unsafe { <Query<(&mut Transform,)>>::new(&test_bench.app.world, &type_access) };
+
+//             // Running
+//             animator_transform_update_system(clips, animators_query, transform_query);
+//         }
+//     }
+// }

From efec93e26a179429e94d8e60c8d1e1598bb79320 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Mon, 7 Dec 2020 01:23:30 -0300
Subject: [PATCH 034/153] todos

---
 crates/bevy_animation/src/custom.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index b601f279b5e3e..0dadbef7ea8c8 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -375,6 +375,8 @@ pub(crate) fn animator_update_system(
             if let Some(clip) = clips.get(clip_handle) {
                 let bind = &mut animator.bind_clips[clip_index];
 
+                // TODO: Don't look for the entities every frame, only when something happens
+
                 // Prepare the entities table cache
                 bind.entities.clear();
                 bind.entities.resize(clip.hierarchy().len(), None);
@@ -471,6 +473,9 @@ impl<'a> AnimatorBlendGroup<'a> {
     }
 }
 
+// TODO: This should be auto derived using the "Animated" trait that just returns
+// a system able to animate the said component. Use "AnimatedAsset" for asset handles!
+
 #[tracing::instrument(skip(clips, animators_query, transform_query))]
 pub(crate) fn animator_transform_update_system(
     clips: Res<Assets<Clip>>,
@@ -495,6 +500,9 @@ pub(crate) fn animator_transform_update_system(
                 // ~15us
                 components.clear();
 
+                // TODO: Merge all the clips hierarchy into a single bigger one
+                // and do the component feching once per animator, instead of per clip
+
                 // SAFETY: Pre-fetch all transforms to avoid calling get_mut multiple times
                 // this is safe because it doesn't change the safe logic
                 unsafe {

From 551486b21ad1d575e2bd4dc1dff3fb90268ac2cb Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Mon, 7 Dec 2020 04:07:44 -0300
Subject: [PATCH 035/153] merge 2 hierarchies together + comments + todos

---
 crates/bevy_animation/src/custom.rs    | 10 ++++-
 crates/bevy_animation/src/hierarchy.rs | 52 ++++++++++++++++++++++++++
 2 files changed, 61 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 0dadbef7ea8c8..a2236ea3f8420 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -41,6 +41,8 @@ pub struct CurvesUntyped {
     untyped: Box<dyn Any + 'static>,
 }
 
+// TODO: This may require that Curves implement Send and Sync
+// SAFETY: CurvesUntyped will only hold on to Curves<T> which are Send and Sync
 unsafe impl Send for CurvesUntyped {}
 unsafe impl Sync for CurvesUntyped {}
 
@@ -60,10 +62,14 @@ impl CurvesUntyped {
 #[derive(Debug, TypeUuid)]
 #[uuid = "79e2ea58-8bf7-43af-8219-5898edb02f80"]
 pub struct Clip {
+    /// Should this clip loop (warping around) or hold
+    ///
+    /// **NOTE** Keep in mind that sampling with time greater
+    /// than the clips duration will always hold.
     //#[serde(default = "clip_default_warp")]
     pub warp: bool,
+    /// Clip compound duration
     duration: f32,
-    /// Entity identification made by parent index and name
     hierarchy: Hierarchy,
     properties: HashMap<String, CurvesUntyped>,
 }
@@ -503,6 +509,8 @@ pub(crate) fn animator_transform_update_system(
                 // TODO: Merge all the clips hierarchy into a single bigger one
                 // and do the component feching once per animator, instead of per clip
 
+                // TODO: Lazly get only the needed entities ?! (it will be bad for missing entities components)
+
                 // SAFETY: Pre-fetch all transforms to avoid calling get_mut multiple times
                 // this is safe because it doesn't change the safe logic
                 unsafe {
diff --git a/crates/bevy_animation/src/hierarchy.rs b/crates/bevy_animation/src/hierarchy.rs
index 09765c7d60be3..1ea3b92c1a45e 100644
--- a/crates/bevy_animation/src/hierarchy.rs
+++ b/crates/bevy_animation/src/hierarchy.rs
@@ -54,6 +54,58 @@ impl<I: Index> Hierarchy<I> {
         Self { entities, children }
     }
 
+    /// Merge other hierarchy into this one, it will collect the
+    /// new entities indexes of merged hierachy.
+    pub fn merge(&mut self, other_hierarchy: &Hierarchy<I>, mapped_entities: &mut Vec<I>) {
+        mapped_entities.clear();
+        mapped_entities.resize(other_hierarchy.len(), I::MAX_VALUE);
+
+        assert!(
+            other_hierarchy.entities[0].0 == I::MAX_VALUE,
+            "first element isn't the root"
+        );
+
+        let root_index = I::from_usize(0);
+        mapped_entities[0] = root_index;
+
+        // At this point they conincide
+        self.internal_merge(other_hierarchy, root_index, root_index, mapped_entities);
+    }
+
+    // TODO: Expose to allow for merging hierarchies with mutiple roots
+    fn internal_merge(
+        &mut self,
+        other_hierarchy: &Hierarchy<I>,
+        other_parent_index: I,
+        parent_index: I,
+        mapped_entities: &mut Vec<I>,
+    ) {
+        for other_index in &other_hierarchy.children[other_parent_index.as_usize()] {
+            let (_, other_name) = &other_hierarchy.entities[other_index.as_usize()];
+            let child = (&parent_index, other_name);
+
+            let entity_index =
+                if let Some(i) = self.entities.iter().position(|(i, n)| (i, n) == child) {
+                    let entity_index = I::from_usize(i);
+                    // Found coresponding entity
+                    mapped_entities[other_index.as_usize()] = entity_index;
+                    entity_index
+                } else {
+                    // Add entity
+                    // Soft limit added to save memory, identical to the curve limit
+                    let i = self.entities.len();
+                    let entity_index = I::from_usize_checked(i);
+                    self.entities.push((entity_index, other_name.clone()));
+                    self.children.push(smallvec![]);
+                    self.children[i].push(entity_index);
+                    mapped_entities[other_index.as_usize()] = entity_index;
+                    entity_index
+                };
+
+            self.internal_merge(other_hierarchy, *other_index, entity_index, mapped_entities);
+        }
+    }
+
     /// Number of entities registered.
     #[inline(always)]
     pub fn len(&self) -> usize {

From c0c2e5ee3518c66129a8dff2f36fad028e87185d Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Mon, 7 Dec 2020 04:18:38 -0300
Subject: [PATCH 036/153] expose relevant clip api + comments

---
 crates/bevy_animation/src/curve.rs  |  2 ++
 crates/bevy_animation/src/custom.rs | 11 ++++++++---
 crates/bevy_animation/src/lib.rs    | 11 ++++-------
 3 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_animation/src/curve.rs b/crates/bevy_animation/src/curve.rs
index 7649c7a86189e..8581e6979056c 100644
--- a/crates/bevy_animation/src/curve.rs
+++ b/crates/bevy_animation/src/curve.rs
@@ -129,6 +129,8 @@ impl<T> Curve<T>
 where
     T: LerpValue + Clone + 'static,
 {
+    // TODO: Profile sample_indexed vs sample, I want to know when use one over the other?
+
     /// Easer to use sampling method that don't have time restrictions or needs
     /// the keyframe index, but is more expensive always `O(n)`. Which means
     /// sampling takes longer to evaluate as much as time get closer to curve duration
diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index a2236ea3f8420..7f315f18cd15b 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -201,6 +201,12 @@ impl Clip {
         &self.hierarchy
     }
 
+    /// Get the curves an given property
+    #[inline(always)]
+    pub fn get(&self, property_name: &str) -> Option<&CurvesUntyped> {
+        self.properties.get(property_name)
+    }
+
     // #[inline(always)]
     // pub fn properties(&self) -> &[Name] {
     //     &self.properties[..]
@@ -382,6 +388,7 @@ pub(crate) fn animator_update_system(
                 let bind = &mut animator.bind_clips[clip_index];
 
                 // TODO: Don't look for the entities every frame, only when something happens
+                // TODO: Merge newarly added clips hierarchies into a single one
 
                 // Prepare the entities table cache
                 bind.entities.clear();
@@ -526,7 +533,6 @@ pub(crate) fn animator_transform_update_system(
 
                 // ~23us
                 if let Some(curves) = clip
-                    .properties
                     .get("Transform.translation")
                     .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
                     .flatten()
@@ -537,6 +543,7 @@ pub(crate) fn animator_transform_update_system(
 
                     for (curve_index, (entity_index, curve)) in curves.iter().enumerate() {
                         if let Some(ref mut component) = components[entity_index as usize] {
+                            // TODO: I'm not nocing any discernible peformance change from using just `sample`
                             let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
                             keyframes[curve_index] = k;
                             // let v = curve.sample(time);
@@ -547,7 +554,6 @@ pub(crate) fn animator_transform_update_system(
 
                 // ~23us
                 if let Some(curves) = clip
-                    .properties
                     .get("Transform.rotation")
                     .map(|curve_untyped| curve_untyped.downcast_ref::<Quat>())
                     .flatten()
@@ -568,7 +574,6 @@ pub(crate) fn animator_transform_update_system(
 
                 // ~23us
                 if let Some(curves) = clip
-                    .properties
                     .get("Transform.scale")
                     .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
                     .flatten()
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index eba03ed65c28f..19bf0d67f39f9 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -4,25 +4,20 @@ use bevy_asset::AddAsset;
 use bevy_type_registry::RegisterType;
 
 mod custom;
-//mod generic;
+mod hierarchy;
+mod skinned_mesh;
 
-//pub mod clip;
 pub mod curve;
-mod hierarchy;
 pub mod lerping;
-mod skinned_mesh;
 
 pub use crate::custom::*;
-//pub use crate::generic::*;
 pub use crate::hierarchy::Hierarchy;
 pub use crate::skinned_mesh::*;
 
 pub mod prelude {
-    //pub use crate::clip::Clip;
     pub use crate::curve::{Curve, CurveUntyped};
     pub use crate::custom::Animator;
     pub use crate::custom::Clip;
-    //pub use crate::generic::Animator;
     pub use crate::hierarchy::Hierarchy;
     pub use crate::lerping::LerpValue;
     pub use crate::skinned_mesh::{SkinAsset, SkinComponent, SkinDebugger};
@@ -60,3 +55,5 @@ impl Plugin for AnimationPlugin {
             .add_system_to_stage(stage::POST_UPDATE, skinning_debugger_update);
     }
 }
+
+// TODO: AppBuilder trait to add animated components and assets

From 4b893865b532f3eaa297bf6930997bd9c495c8aa Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Mon, 7 Dec 2020 18:17:58 -0300
Subject: [PATCH 037/153] successfully mergin hierarchies (and tests)

---
 crates/bevy_animation/src/hierarchy.rs | 78 ++++++++++++++++++++++++--
 1 file changed, 73 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_animation/src/hierarchy.rs b/crates/bevy_animation/src/hierarchy.rs
index 1ea3b92c1a45e..5a1a63ab871d0 100644
--- a/crates/bevy_animation/src/hierarchy.rs
+++ b/crates/bevy_animation/src/hierarchy.rs
@@ -32,6 +32,10 @@ impl<I: Index> Default for Hierarchy<I> {
 }
 
 impl<I: Index> Hierarchy<I> {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
     /// Used when the hierarchy must be in a specific order,
     /// this function takes an vec of entities defined by their parent index
     /// (on the same vec) and name.
@@ -93,11 +97,10 @@ impl<I: Index> Hierarchy<I> {
                 } else {
                     // Add entity
                     // Soft limit added to save memory, identical to the curve limit
-                    let i = self.entities.len();
-                    let entity_index = I::from_usize_checked(i);
-                    self.entities.push((entity_index, other_name.clone()));
+                    let entity_index = I::from_usize_checked(self.entities.len());
+                    self.entities.push((parent_index, other_name.clone()));
                     self.children.push(smallvec![]);
-                    self.children[i].push(entity_index);
+                    self.children[parent_index.as_usize()].push(entity_index);
                     mapped_entities[other_index.as_usize()] = entity_index;
                     entity_index
                 };
@@ -194,6 +197,8 @@ impl<I: Index> Hierarchy<I> {
         path
     }
 
+    // TODO: find_all_entities_inspired in the `internal_merge` function
+
     /// Finds an entity given a set of queries, see the example bellow
     /// how to proper call this function,
     ///
@@ -315,9 +320,10 @@ impl<I: Index> Hierarchy<I> {
 
 mod private {
     use std::convert::TryFrom;
+    use std::fmt::{Debug, Display};
 
     /// Implemented by unsigned types
-    pub trait Index: Sized + PartialEq + Copy + Clone {
+    pub trait Index: Sized + PartialEq + Copy + Clone + Debug + Display {
         const MAX_VALUE: Self;
 
         fn as_usize(&self) -> usize;
@@ -354,3 +360,65 @@ mod private {
     impl_index!(u64);
     impl_index!(usize);
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn merge_different_hierarchies() {
+        let mut hierarchy_a = Hierarchy::<u16>::new();
+        hierarchy_a.get_or_insert_entity("/NodeA0/NodeB0");
+        hierarchy_a.get_or_insert_entity("/NodeA1/NodeB1/NodeC0");
+        hierarchy_a.get_or_insert_entity("/NodeA2/NodeB1/NodeC1");
+
+        let mut hierarchy_b = Hierarchy::<u16>::new();
+        hierarchy_b.get_or_insert_entity("/NodeA1/NodeB2/NodeC2");
+        hierarchy_b.get_or_insert_entity("/NodeA1/NodeB0/NodeC3");
+
+        let mut mapped_entities = vec![];
+        hierarchy_a.merge(&hierarchy_b, &mut mapped_entities);
+
+        assert!(
+            mapped_entities.iter().all(|index| *index < u16::MAX),
+            "some entities weren't mapped or merged"
+        );
+
+        for i in 0..hierarchy_b.len() {
+            assert_eq!(
+                hierarchy_a.get_entity_path_at(mapped_entities[i]),
+                hierarchy_b.get_entity_path_at(i as u16)
+            );
+        }
+    }
+
+    #[test]
+    fn merge_equal_but_scrambled_hierarchies() {
+        let mut hierarchy_a = Hierarchy::<u16>::new();
+        hierarchy_a.get_or_insert_entity("/NodeA0/NodeB0");
+        hierarchy_a.get_or_insert_entity("/NodeA1/NodeB1/NodeC0");
+        hierarchy_a.get_or_insert_entity("/NodeA2/NodeB1/NodeC1");
+        hierarchy_a.get_or_insert_entity("/NodeA1/NodeB0/NodeC3");
+
+        let mut hierarchy_b = Hierarchy::<u16>::new();
+        hierarchy_b.get_or_insert_entity("/NodeA2/NodeB1/NodeC1");
+        hierarchy_b.get_or_insert_entity("/NodeA1/NodeB0/NodeC3");
+        hierarchy_b.get_or_insert_entity("/NodeA1/NodeB1/NodeC0");
+        hierarchy_b.get_or_insert_entity("/NodeA0/NodeB0");
+
+        let mut mapped_entities = vec![];
+        hierarchy_a.merge(&hierarchy_b, &mut mapped_entities);
+
+        assert!(
+            mapped_entities.iter().all(|index| *index < u16::MAX),
+            "some entities weren't mapped or merged"
+        );
+
+        for i in 0..hierarchy_b.len() {
+            assert_eq!(
+                hierarchy_a.get_entity_path_at(mapped_entities[i]),
+                hierarchy_b.get_entity_path_at(i as u16)
+            );
+        }
+    }
+}

From d85619054d77a6ad896cb8c2637d840840ce837b Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Mon, 7 Dec 2020 23:38:04 -0300
Subject: [PATCH 038/153] comments + ptr hasher (performance tests needed)

---
 crates/bevy_animation/src/custom.rs    | 100 +++++++++++++------------
 crates/bevy_animation/src/hierarchy.rs |   8 +-
 2 files changed, 58 insertions(+), 50 deletions(-)

diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 7f315f18cd15b..231933afd3a31 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -7,9 +7,11 @@ use bevy_property::Properties;
 //use bevy_render::color::Color;
 use bevy_transform::prelude::*;
 use bevy_type_registry::TypeUuid;
-use fnv::FnvHashMap as HashMap;
+use fnv::FnvBuildHasher;
 use smallvec::{smallvec, SmallVec};
 use std::any::Any;
+use std::collections::{HashMap, HashSet};
+use std::hash::{BuildHasherDefault, Hash, Hasher};
 
 use crate::curve::Curve;
 use crate::hierarchy::Hierarchy;
@@ -41,12 +43,21 @@ pub struct CurvesUntyped {
     untyped: Box<dyn Any + 'static>,
 }
 
-// TODO: This may require that Curves implement Send and Sync
-// SAFETY: CurvesUntyped will only hold on to Curves<T> which are Send and Sync
+// SAFETY: CurvesUntyped will only hold on to Curves<T> which also implement Send and Sync
 unsafe impl Send for CurvesUntyped {}
 unsafe impl Sync for CurvesUntyped {}
 
 impl CurvesUntyped {
+    fn new<T: Send + Sync + 'static>(curves: Curves<T>) -> Self {
+        CurvesUntyped {
+            duration: curves
+                .iter()
+                .map(|(_, c)| c.duration())
+                .fold(0.0, |acc, d| acc.max(d)),
+            untyped: Box::new(curves),
+        }
+    }
+
     #[inline(always)]
     pub fn downcast_ref<T: 'static>(&self) -> Option<&Curves<T>> {
         self.untyped.downcast_ref()
@@ -71,7 +82,7 @@ pub struct Clip {
     /// Clip compound duration
     duration: f32,
     hierarchy: Hierarchy,
-    properties: HashMap<String, CurvesUntyped>,
+    properties: HashMap<String, CurvesUntyped, FnvBuildHasher>,
 }
 
 // fn clip_default_warp() -> bool {
@@ -97,7 +108,7 @@ impl Clip {
     /// **NOTE** This is a expensive function
     pub fn add_animated_prop<T>(&mut self, property_path: &str, mut curve: Curve<T>)
     where
-        T: LerpValue + Clone + 'static,
+        T: LerpValue + Clone + Send + Sync + 'static,
     {
         // Split in entity and attribute path,
         // NOTE: use rfind because it's expected the latter to be generally shorter
@@ -154,14 +165,11 @@ impl Clip {
         let id = self.properties.len();
         self.properties.insert(
             target_name.to_string(),
-            CurvesUntyped {
-                duration: curve.duration(),
-                untyped: Box::new(Curves {
-                    id,
-                    curves: vec![curve],
-                    indexes: smallvec![entity_index],
-                }),
-            },
+            CurvesUntyped::new(Curves {
+                id,
+                curves: vec![curve],
+                indexes: smallvec![entity_index],
+            }),
         );
     }
 
@@ -206,21 +214,6 @@ impl Clip {
     pub fn get(&self, property_name: &str) -> Option<&CurvesUntyped> {
         self.properties.get(property_name)
     }
-
-    // #[inline(always)]
-    // pub fn properties(&self) -> &[Name] {
-    //     &self.properties[..]
-    // }
-
-    // #[inline(always)]
-    // pub fn curves(&self) -> impl Iterator<Item = (&Curves, &CurveUntyped)> {
-    //     self.entries.iter().zip(self.curves.iter())
-    // }
-
-    // #[inline(always)]
-    // pub fn get(&self, curve_index: u16) -> Option<&CurveUntyped> {
-    //     self.curves.get(curve_index as usize)
-    // }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -388,7 +381,9 @@ pub(crate) fn animator_update_system(
                 let bind = &mut animator.bind_clips[clip_index];
 
                 // TODO: Don't look for the entities every frame, only when something happens
-                // TODO: Merge newarly added clips hierarchies into a single one
+                // TODO: Handle parent changed events
+                // TODO: Handle name changed events
+                // TODO: Merge newly added clips hierarchies into a single one
 
                 // Prepare the entities table cache
                 bind.entities.clear();
@@ -396,7 +391,7 @@ pub(crate) fn animator_update_system(
                 // Assign the root entity as the first element
                 bind.entities[0] = Some(animator_entity);
 
-                // Find entitites ...
+                // Find entities ...
                 for entity_index in 1..clip.hierarchy().len() {
                     clip.hierarchy().find_entity(
                         entity_index as u16,
@@ -406,21 +401,11 @@ pub(crate) fn animator_update_system(
                     );
                 }
 
-                // let curves_count = clip.len() as usize;
-
                 for layer in &mut animator.layers {
                     if layer.clip as usize != clip_index {
                         continue;
                     }
 
-                    // // Ensure capacity for cached keyframe index vec
-                    // if layer.keyframe.len() != curves_count {
-                    //     layer.keyframe.clear();
-                    //     layer
-                    //         .keyframe
-                    //         .resize_with(curves_count, || Default::default());
-                    // }
-
                     // Update time
                     let mut time = layer.time + delta_time * layer.time_scale;
 
@@ -429,11 +414,7 @@ pub(crate) fn animator_update_system(
                         // Warp Around
                         if time > clip.duration() {
                             time = (time / clip.duration()).fract() * clip.duration();
-                            // // Reset all keyframes cached indexes
-                            // layer
-                            //     .keyframe
-                            //     .iter_mut()
-                            //     .for_each(|x| *x = Default::default())
+                            // TODO: Reset all keyframes cached indexes (speedup)
                         }
                     } else {
                         // Hold
@@ -456,9 +437,36 @@ struct Ptr(*const u8);
 unsafe impl Send for Ptr {}
 unsafe impl Sync for Ptr {}
 
+/// Hasher for `Ptr` type, it trivially copies the bytes
+#[derive(Default)]
+struct PtrHasher(u64);
+
+impl Hasher for PtrHasher {
+    #[inline(always)]
+    fn finish(&self) -> u64 {
+        self.0
+    }
+
+    fn write(&mut self, _: &[u8]) {
+        unreachable!("hash type not supported");
+    }
+
+    #[inline(always)]
+    fn write_u64(&mut self, i: u64) {
+        self.0 = i;
+    }
+
+    #[inline(always)]
+    fn write_usize(&mut self, i: usize) {
+        self.0 = i as u64;
+    }
+}
+
 #[derive(Default, Debug)]
 pub struct AnimatorBlending {
-    table: fnv::FnvHashSet<Ptr>,
+    // TODO: Test the performance of FvnHash against the PtrHasher
+    // TODO: Use instead a vector, the Ptr type can be used as his on hash code
+    table: HashSet<Ptr, BuildHasherDefault<PtrHasher>>,
 }
 
 impl AnimatorBlending {
diff --git a/crates/bevy_animation/src/hierarchy.rs b/crates/bevy_animation/src/hierarchy.rs
index 5a1a63ab871d0..c294fac60eda8 100644
--- a/crates/bevy_animation/src/hierarchy.rs
+++ b/crates/bevy_animation/src/hierarchy.rs
@@ -59,7 +59,7 @@ impl<I: Index> Hierarchy<I> {
     }
 
     /// Merge other hierarchy into this one, it will collect the
-    /// new entities indexes of merged hierachy.
+    /// new entities indexes of merged hierarchy.
     pub fn merge(&mut self, other_hierarchy: &Hierarchy<I>, mapped_entities: &mut Vec<I>) {
         mapped_entities.clear();
         mapped_entities.resize(other_hierarchy.len(), I::MAX_VALUE);
@@ -72,11 +72,11 @@ impl<I: Index> Hierarchy<I> {
         let root_index = I::from_usize(0);
         mapped_entities[0] = root_index;
 
-        // At this point they conincide
+        // At this point they coincide
         self.internal_merge(other_hierarchy, root_index, root_index, mapped_entities);
     }
 
-    // TODO: Expose to allow for merging hierarchies with mutiple roots
+    // TODO: Expose to allow for merging hierarchies with multiple roots
     fn internal_merge(
         &mut self,
         other_hierarchy: &Hierarchy<I>,
@@ -91,7 +91,7 @@ impl<I: Index> Hierarchy<I> {
             let entity_index =
                 if let Some(i) = self.entities.iter().position(|(i, n)| (i, n) == child) {
                     let entity_index = I::from_usize(i);
-                    // Found coresponding entity
+                    // Found corresponding entity
                     mapped_entities[other_index.as_usize()] = entity_index;
                     entity_index
                 } else {

From 789b3adb45afe367d2b64ac82db78bd3049d9fec Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Tue, 8 Dec 2020 01:31:49 -0300
Subject: [PATCH 039/153] tested some hashers (fnv won)

---
 crates/bevy_animation/src/custom.rs | 31 +++--------------------------
 crates/bevy_core/src/name.rs        |  1 +
 2 files changed, 4 insertions(+), 28 deletions(-)

diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 231933afd3a31..58e23bad68131 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -11,7 +11,6 @@ use fnv::FnvBuildHasher;
 use smallvec::{smallvec, SmallVec};
 use std::any::Any;
 use std::collections::{HashMap, HashSet};
-use std::hash::{BuildHasherDefault, Hash, Hasher};
 
 use crate::curve::Curve;
 use crate::hierarchy::Hierarchy;
@@ -82,6 +81,7 @@ pub struct Clip {
     /// Clip compound duration
     duration: f32,
     hierarchy: Hierarchy,
+    // ? NOTE: AHash performed worse than FnvHasher
     properties: HashMap<String, CurvesUntyped, FnvBuildHasher>,
 }
 
@@ -437,36 +437,11 @@ struct Ptr(*const u8);
 unsafe impl Send for Ptr {}
 unsafe impl Sync for Ptr {}
 
-/// Hasher for `Ptr` type, it trivially copies the bytes
-#[derive(Default)]
-struct PtrHasher(u64);
-
-impl Hasher for PtrHasher {
-    #[inline(always)]
-    fn finish(&self) -> u64 {
-        self.0
-    }
-
-    fn write(&mut self, _: &[u8]) {
-        unreachable!("hash type not supported");
-    }
-
-    #[inline(always)]
-    fn write_u64(&mut self, i: u64) {
-        self.0 = i;
-    }
-
-    #[inline(always)]
-    fn write_usize(&mut self, i: usize) {
-        self.0 = i as u64;
-    }
-}
-
 #[derive(Default, Debug)]
 pub struct AnimatorBlending {
-    // TODO: Test the performance of FvnHash against the PtrHasher
+    // ? NOTE: FnvHasher performed better over the PtrHasher (ptr value as hash) and AHash
     // TODO: Use instead a vector, the Ptr type can be used as his on hash code
-    table: HashSet<Ptr, BuildHasherDefault<PtrHasher>>,
+    table: HashSet<Ptr, FnvBuildHasher>,
 }
 
 impl AnimatorBlending {
diff --git a/crates/bevy_core/src/name.rs b/crates/bevy_core/src/name.rs
index 120f6941ce4e2..6eb5da7f036cb 100644
--- a/crates/bevy_core/src/name.rs
+++ b/crates/bevy_core/src/name.rs
@@ -52,6 +52,7 @@ impl Name {
     }
 
     fn update_hash(&mut self) {
+        // TODO: Try with Fnv and AHash (I'm goging to need a test suit for that, but my money is on ahash)
         let mut hasher = DefaultHasher::default();
         self.name.hash(&mut hasher);
         self.hash = hasher.finish();

From ee1c4f597d2e91aa6eae0d54d4af5712a3c532dc Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Tue, 8 Dec 2020 10:25:23 -0300
Subject: [PATCH 040/153] proper layer blending functions for boolean and
 handles

---
 crates/bevy_animation/src/blending.rs  | 114 +++++++++++++++++++++++++
 crates/bevy_animation/src/curve.rs     |   4 +-
 crates/bevy_animation/src/custom.rs    |  89 +++++++------------
 crates/bevy_animation/src/hierarchy.rs |   1 +
 crates/bevy_animation/src/lerping.rs   |  34 ++++++--
 crates/bevy_animation/src/lib.rs       |   4 +-
 6 files changed, 177 insertions(+), 69 deletions(-)
 create mode 100644 crates/bevy_animation/src/blending.rs

diff --git a/crates/bevy_animation/src/blending.rs b/crates/bevy_animation/src/blending.rs
new file mode 100644
index 0000000000000..329650e7fe7c3
--- /dev/null
+++ b/crates/bevy_animation/src/blending.rs
@@ -0,0 +1,114 @@
+use bevy_asset::{Asset, Handle, HandleUntyped};
+use bevy_math::prelude::*;
+use bevy_render::color::Color;
+use fnv::FnvBuildHasher;
+use std::collections::{HashMap, HashSet};
+
+use crate::lerping::Lerp;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+struct Ptr(*const u8);
+
+// SAFETY: Store pointers to each attribute to be updated, a clip can't have two pointers
+// with the same value. Each clip per Animator will be updated sequentially
+unsafe impl Send for Ptr {}
+unsafe impl Sync for Ptr {}
+
+#[derive(Default, Debug)]
+pub struct AnimatorBlending {
+    // ? NOTE: FnvHasher performed better over the PtrHasher (ptr value as hash) and AHash
+    blend: HashSet<Ptr, FnvBuildHasher>,
+    /// Used for contest blend type
+    blend_memory: HashMap<Ptr, f32, FnvBuildHasher>,
+}
+
+impl AnimatorBlending {
+    #[inline(always)]
+    pub fn begin_blending(&mut self) -> AnimatorBlendGroup {
+        self.blend.clear();
+        self.blend_memory.clear();
+        AnimatorBlendGroup { blending: self }
+    }
+}
+
+pub struct AnimatorBlendGroup<'a> {
+    blending: &'a mut AnimatorBlending,
+}
+
+impl<'a> AnimatorBlendGroup<'a> {
+    /// Blend using lerping
+    pub fn blend_lerp<T: Lerp>(&mut self, attribute: &mut T, value: T, weight: f32) {
+        let ptr = Ptr(attribute as *const _ as *const u8);
+        if self.blending.blend.contains(&ptr) {
+            *attribute = Lerp::lerp(&*attribute, &value, weight);
+        } else {
+            self.blending.blend.insert(ptr);
+            *attribute = value;
+        }
+    }
+
+    /// Contest blending, only the value with the highest weight value will remain
+    pub fn blend_contest<T>(&mut self, attribute: &mut T, value: T, weight: f32) {
+        let ptr = Ptr(attribute as *const _ as *const u8);
+        let w = self.blending.blend_memory.entry(ptr).or_insert(0.0);
+        if weight > *w {
+            *w = weight;
+            *attribute = value;
+        }
+    }
+}
+
+/// Instructs on how blend multiple layers togethers based on their value,
+/// normally there is two types of blend, lerp and contest blending, the first
+/// is used by floats, vectors and quaternions, while the second keeps only the value
+/// with higher weight and is used for booleans and asset handles.
+///
+/// Here's how to correctly implement it:
+/// ```rust
+/// struct MyType;
+///
+/// impl Blend for MyType {
+///     #[inline(always)]
+///     fn blend(&mut self, blend_group: &mut AnimatorBlendGroup, value: Self, weight: f32) {
+///         blend_group.blend_contest(self, value, weight);
+///         // or
+///         // blend_group.blend_lerp(self, value, weight);
+///     }
+/// }
+/// ```
+pub trait Blend {
+    fn blend(&mut self, blend_group: &mut AnimatorBlendGroup, value: Self, weight: f32);
+}
+
+macro_rules! lerp {
+    ($t:ty) => {
+        impl Blend for $t {
+            #[inline(always)]
+            fn blend(&mut self, blend_group: &mut AnimatorBlendGroup, value: Self, weight: f32) {
+                blend_group.blend_lerp(self, value, weight);
+            }
+        }
+    };
+}
+
+lerp!(bool);
+lerp!(f32);
+lerp!(Vec2);
+lerp!(Vec3);
+lerp!(Vec4);
+lerp!(Quat);
+lerp!(Color);
+
+impl<T: Asset + 'static> Blend for Handle<T> {
+    #[inline(always)]
+    fn blend(&mut self, blend_group: &mut AnimatorBlendGroup, value: Self, weight: f32) {
+        blend_group.blend_contest(self, value, weight);
+    }
+}
+
+impl Blend for HandleUntyped {
+    #[inline(always)]
+    fn blend(&mut self, blend_group: &mut AnimatorBlendGroup, value: Self, weight: f32) {
+        blend_group.blend_contest(self, value, weight);
+    }
+}
diff --git a/crates/bevy_animation/src/curve.rs b/crates/bevy_animation/src/curve.rs
index 8581e6979056c..287d0d5ed4a58 100644
--- a/crates/bevy_animation/src/curve.rs
+++ b/crates/bevy_animation/src/curve.rs
@@ -1,7 +1,7 @@
 use bevy_math::prelude::*;
 use std::any::TypeId;
 
-use super::lerping::LerpValue;
+use super::lerping::Lerp;
 
 // TODO: impl Serialize, Deserialize
 #[derive(Debug, Clone)]
@@ -127,7 +127,7 @@ impl<T> Curve<T> {
 
 impl<T> Curve<T>
 where
-    T: LerpValue + Clone + 'static,
+    T: Lerp + Clone + 'static,
 {
     // TODO: Profile sample_indexed vs sample, I want to know when use one over the other?
 
diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 58e23bad68131..945a029cf80c6 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -4,17 +4,17 @@ use bevy_core::prelude::*;
 use bevy_ecs::prelude::*;
 use bevy_math::prelude::*;
 use bevy_property::Properties;
-//use bevy_render::color::Color;
 use bevy_transform::prelude::*;
 use bevy_type_registry::TypeUuid;
 use fnv::FnvBuildHasher;
 use smallvec::{smallvec, SmallVec};
 use std::any::Any;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 
+use crate::blending::{AnimatorBlending, Blend};
 use crate::curve::Curve;
 use crate::hierarchy::Hierarchy;
-use crate::lerping::LerpValue;
+use crate::lerping::Lerp;
 
 #[derive(Debug)]
 pub struct Curves<T> {
@@ -25,6 +25,14 @@ pub struct Curves<T> {
 }
 
 impl<T> Curves<T> {
+    fn calculate_duration(&self) -> f32 {
+        self.curves
+            .iter()
+            .map(|c| c.duration())
+            .fold(0.0f32, |acc, d| acc.max(d))
+    }
+
+    /// Number of curves inside
     #[inline(always)]
     pub fn len(&self) -> usize {
         self.curves.len()
@@ -38,6 +46,7 @@ impl<T> Curves<T> {
 
 #[derive(Debug)]
 pub struct CurvesUntyped {
+    /// Cached calculated curves duration
     duration: f32,
     untyped: Box<dyn Any + 'static>,
 }
@@ -57,6 +66,11 @@ impl CurvesUntyped {
         }
     }
 
+    #[inline(always)]
+    pub fn duration(&self) -> f32 {
+        self.duration
+    }
+
     #[inline(always)]
     pub fn downcast_ref<T: 'static>(&self) -> Option<&Curves<T>> {
         self.untyped.downcast_ref()
@@ -108,7 +122,7 @@ impl Clip {
     /// **NOTE** This is a expensive function
     pub fn add_animated_prop<T>(&mut self, property_path: &str, mut curve: Curve<T>)
     where
-        T: LerpValue + Clone + Send + Sync + 'static,
+        T: Lerp + Clone + Send + Sync + 'static,
     {
         // Split in entity and attribute path,
         // NOTE: use rfind because it's expected the latter to be generally shorter
@@ -133,21 +147,15 @@ impl Clip {
                 std::mem::swap(&mut curves.curves[i], &mut curve);
 
                 // Update curve duration in two stages
-                let duration = curves
-                    .curves
-                    .iter()
-                    .map(|c| c.duration())
-                    .fold(0.0f32, |acc, x| acc.max(x));
+                let duration = curves.calculate_duration();
 
+                // Drop the down casted ref and update the parent curve
                 std::mem::drop(curves);
                 curves_untyped.duration = duration;
 
+                // Drop the curves untyped (which as a mut borrow) and update the total duration
                 std::mem::drop(curves_untyped);
-                self.duration = self
-                    .properties
-                    .iter()
-                    .map(|(_, c)| c.duration)
-                    .fold(0.0f32, |acc, x| acc.max(x));
+                self.duration = self.calculate_duration();
             } else {
                 // Append newly added curve
                 let duration = curve.duration();
@@ -198,6 +206,13 @@ impl Clip {
     //     )
     // }
 
+    fn calculate_duration(&self) -> f32 {
+        self.properties
+            .iter()
+            .map(|(_, c)| c.duration)
+            .fold(0.0f32, |acc, x| acc.max(x))
+    }
+
     /// Clip duration
     #[inline(always)]
     pub fn duration(&self) -> f32 {
@@ -429,46 +444,6 @@ pub(crate) fn animator_update_system(
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-struct Ptr(*const u8);
-
-// SAFETY: Store pointers to each attribute to be updated, a clip can't have two pointers
-// with the same value. Each clip per Animator will be updated sequentially
-unsafe impl Send for Ptr {}
-unsafe impl Sync for Ptr {}
-
-#[derive(Default, Debug)]
-pub struct AnimatorBlending {
-    // ? NOTE: FnvHasher performed better over the PtrHasher (ptr value as hash) and AHash
-    // TODO: Use instead a vector, the Ptr type can be used as his on hash code
-    table: HashSet<Ptr, FnvBuildHasher>,
-}
-
-impl AnimatorBlending {
-    #[inline(always)]
-    pub fn begin_blending(&mut self) -> AnimatorBlendGroup {
-        self.table.clear();
-        AnimatorBlendGroup { blending: self }
-    }
-}
-
-pub struct AnimatorBlendGroup<'a> {
-    blending: &'a mut AnimatorBlending,
-}
-
-impl<'a> AnimatorBlendGroup<'a> {
-    #[inline(always)]
-    pub fn blend_lerp<T: LerpValue>(&mut self, attribute: &mut T, value: T, weight: f32) {
-        let ptr = Ptr(attribute as *const _ as *const u8);
-        if self.blending.table.contains(&ptr) {
-            *attribute = LerpValue::lerp(&*attribute, &value, weight);
-        } else {
-            self.blending.table.insert(ptr);
-            *attribute = value;
-        }
-    }
-}
-
 // TODO: This should be auto derived using the "Animated" trait that just returns
 // a system able to animate the said component. Use "AnimatedAsset" for asset handles!
 
@@ -530,7 +505,7 @@ pub(crate) fn animator_transform_update_system(
                             let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
                             keyframes[curve_index] = k;
                             // let v = curve.sample(time);
-                            blend_group.blend_lerp(&mut component.translation, v, w);
+                            component.translation.blend(&mut blend_group, v, w);
                         }
                     }
                 }
@@ -550,7 +525,7 @@ pub(crate) fn animator_transform_update_system(
                             let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
                             keyframes[curve_index] = k;
                             // let v = curve.sample(time);
-                            blend_group.blend_lerp(&mut component.rotation, v, w);
+                            component.rotation.blend(&mut blend_group, v, w);
                         }
                     }
                 }
@@ -570,7 +545,7 @@ pub(crate) fn animator_transform_update_system(
                             let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
                             keyframes[curve_index] = k;
                             //let v = curve.sample(time);
-                            blend_group.blend_lerp(&mut component.scale, v, w);
+                            component.scale.blend(&mut blend_group, v, w);
                         }
                     }
                 }
diff --git a/crates/bevy_animation/src/hierarchy.rs b/crates/bevy_animation/src/hierarchy.rs
index c294fac60eda8..947450cd9b593 100644
--- a/crates/bevy_animation/src/hierarchy.rs
+++ b/crates/bevy_animation/src/hierarchy.rs
@@ -18,6 +18,7 @@ pub struct Hierarchy<I: Index = u16> {
     entities: Vec<(I, Name)>,
     // ? NOTE: SmallVec<[u16; 10]> occupy the same 32 bytes as the SmallVec<[u16; 8]>, but the latter
     // ? should be only take 24 bytes using the "union" feature
+    // TODO: Use instead a const to figure out this value based on `I`
     children: Vec<SmallVec<[I; 10]>>,
 }
 
diff --git a/crates/bevy_animation/src/lerping.rs b/crates/bevy_animation/src/lerping.rs
index ffa1fcf3b6bc4..465a7e4195f45 100644
--- a/crates/bevy_animation/src/lerping.rs
+++ b/crates/bevy_animation/src/lerping.rs
@@ -1,36 +1,52 @@
-// use bevy_asset::prelude::*;
 use bevy_asset::{Asset, Handle, HandleUntyped};
 use bevy_math::prelude::*;
+use bevy_render::color::Color;
 
-pub trait LerpValue {
+pub trait Lerp {
     fn lerp(a: &Self, b: &Self, t: f32) -> Self;
 }
 
-impl LerpValue for f32 {
+impl Lerp for bool {
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        if t > 0.99 {
+            b.clone()
+        } else {
+            a.clone()
+        }
+    }
+}
+
+impl Lerp for f32 {
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        (*a) * (1.0 - t) + (*b) * t
+    }
+}
+
+impl Lerp for Vec2 {
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
 }
 
-impl LerpValue for Vec2 {
+impl Lerp for Vec3 {
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
 }
 
-impl LerpValue for Vec3 {
+impl Lerp for Vec4 {
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
 }
 
-impl LerpValue for Vec4 {
+impl Lerp for Color {
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
 }
 
-impl LerpValue for Quat {
+impl Lerp for Quat {
     /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
     /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
@@ -44,7 +60,7 @@ impl LerpValue for Quat {
     }
 }
 
-impl<T: Asset + 'static> LerpValue for Handle<T> {
+impl<T: Asset + 'static> Lerp for Handle<T> {
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         if t > 0.99 {
             b.clone()
@@ -54,7 +70,7 @@ impl<T: Asset + 'static> LerpValue for Handle<T> {
     }
 }
 
-impl LerpValue for HandleUntyped {
+impl Lerp for HandleUntyped {
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         if t > 0.99 {
             b.clone()
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 19bf0d67f39f9..577fca58ac4d8 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -7,6 +7,7 @@ mod custom;
 mod hierarchy;
 mod skinned_mesh;
 
+pub mod blending;
 pub mod curve;
 pub mod lerping;
 
@@ -15,11 +16,12 @@ pub use crate::hierarchy::Hierarchy;
 pub use crate::skinned_mesh::*;
 
 pub mod prelude {
+    pub use crate::blending::AnimatorBlending;
     pub use crate::curve::{Curve, CurveUntyped};
     pub use crate::custom::Animator;
     pub use crate::custom::Clip;
     pub use crate::hierarchy::Hierarchy;
-    pub use crate::lerping::LerpValue;
+    pub use crate::lerping::Lerp;
     pub use crate::skinned_mesh::{SkinAsset, SkinComponent, SkinDebugger};
 }
 

From 603f268b7d5a4d40f49f04829bdbf201feb7365a Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Tue, 8 Dec 2020 11:59:38 -0300
Subject: [PATCH 041/153] lazy feching components (proto type)

---
 crates/bevy_animation/src/custom.rs | 66 +++++++++++++++++++++--------
 1 file changed, 48 insertions(+), 18 deletions(-)

diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 945a029cf80c6..2bb637846e41f 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -345,6 +345,36 @@ impl KeyframeCache {
 
 ///////////////////////////////////////////////////////////////////////////////
 
+pub enum FetchState<T> {
+    None,
+    Missing,
+    Found(T),
+}
+
+impl<T> FetchState<T> {
+    pub fn fetch_mut<F: Fn() -> Option<T>>(&mut self, fetch_fn: F) -> Option<&mut T> {
+        match self {
+            FetchState::None => {
+                if let Some(t) = fetch_fn() {
+                    *self = FetchState::Found(t);
+                    if let FetchState::Found(t) = self {
+                        Some(t)
+                    } else {
+                        unreachable!()
+                    }
+                } else {
+                    *self = FetchState::Missing;
+                    None
+                }
+            }
+            FetchState::Missing => None,
+            FetchState::Found(t) => Some(t),
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 #[tracing::instrument(skip(commands, time, clips, animators_query, children_query, name_query))]
 pub(crate) fn animator_update_system(
     commands: &mut Commands,
@@ -453,7 +483,7 @@ pub(crate) fn animator_transform_update_system(
     mut animators_query: Query<(&Animator, &mut KeyframeCache, &mut AnimatorBlending)>,
     transform_query: Query<(&mut Transform,)>,
 ) {
-    let mut components = vec![];
+    let mut components: Vec<FetchState<Mut<Transform>>> = vec![];
 
     for (animator, mut keyframe_cache, mut animator_blend) in animators_query.iter_mut() {
         let keyframe_cache = &mut *keyframe_cache;
@@ -474,20 +504,14 @@ pub(crate) fn animator_transform_update_system(
                 // TODO: Merge all the clips hierarchy into a single bigger one
                 // and do the component feching once per animator, instead of per clip
 
-                // TODO: Lazly get only the needed entities ?! (it will be bad for missing entities components)
-
-                // SAFETY: Pre-fetch all transforms to avoid calling get_mut multiple times
-                // this is safe because it doesn't change the safe logic
-                unsafe {
-                    for entry in entities {
-                        components.push(
-                            entry
-                                .map(|entity| transform_query.get_unsafe(entity).ok())
-                                .flatten()
-                                .map(|(transform,)| transform),
-                        );
-                    }
-                }
+                // SAFETY: These are the only mutable references to these components,
+                // and each one will be modified one at the time
+                let fetch_fn = |i: usize| unsafe {
+                    entities[i]
+                        .map(|entity| transform_query.get_unsafe(entity).ok())
+                        .flatten()
+                        .map(|(transform,)| transform)
+                };
 
                 // ~23us
                 if let Some(curves) = clip
@@ -500,7 +524,9 @@ pub(crate) fn animator_transform_update_system(
                     keyframes.resize(curves.len() as usize, 0);
 
                     for (curve_index, (entity_index, curve)) in curves.iter().enumerate() {
-                        if let Some(ref mut component) = components[entity_index as usize] {
+                        if let Some(ref mut component) = components[entity_index as usize]
+                            .fetch_mut(|| fetch_fn(entity_index as usize))
+                        {
                             // TODO: I'm not nocing any discernible peformance change from using just `sample`
                             let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
                             keyframes[curve_index] = k;
@@ -521,7 +547,9 @@ pub(crate) fn animator_transform_update_system(
                     keyframes.resize(curves.len() as usize, 0);
 
                     for (curve_index, (entity_index, curve)) in curves.iter().enumerate() {
-                        if let Some(ref mut component) = components[entity_index as usize] {
+                        if let Some(ref mut component) = components[entity_index as usize]
+                            .fetch_mut(|| fetch_fn(entity_index as usize))
+                        {
                             let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
                             keyframes[curve_index] = k;
                             // let v = curve.sample(time);
@@ -541,7 +569,9 @@ pub(crate) fn animator_transform_update_system(
                     keyframes.resize(curves.len() as usize, 0);
 
                     for (curve_index, (entity_index, curve)) in curves.iter().enumerate() {
-                        if let Some(ref mut component) = components[entity_index as usize] {
+                        if let Some(ref mut component) = components[entity_index as usize]
+                            .fetch_mut(|| fetch_fn(entity_index as usize))
+                        {
                             let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
                             keyframes[curve_index] = k;
                             //let v = curve.sample(time);

From 20d6611567393d7242f5e40512c2b9b602beb3b2 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Tue, 8 Dec 2020 13:31:13 -0300
Subject: [PATCH 042/153] lazy fetching wasn't a good idea after all

---
 crates/bevy_animation/src/custom.rs | 37 ++++++++++++++---------------
 crates/bevy_core/src/name.rs        |  2 +-
 2 files changed, 19 insertions(+), 20 deletions(-)

diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 2bb637846e41f..f7e4b4e9aedf1 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -483,7 +483,7 @@ pub(crate) fn animator_transform_update_system(
     mut animators_query: Query<(&Animator, &mut KeyframeCache, &mut AnimatorBlending)>,
     transform_query: Query<(&mut Transform,)>,
 ) {
-    let mut components: Vec<FetchState<Mut<Transform>>> = vec![];
+    let mut components = vec![];
 
     for (animator, mut keyframe_cache, mut animator_blend) in animators_query.iter_mut() {
         let keyframe_cache = &mut *keyframe_cache;
@@ -504,14 +504,18 @@ pub(crate) fn animator_transform_update_system(
                 // TODO: Merge all the clips hierarchy into a single bigger one
                 // and do the component feching once per animator, instead of per clip
 
-                // SAFETY: These are the only mutable references to these components,
-                // and each one will be modified one at the time
-                let fetch_fn = |i: usize| unsafe {
-                    entities[i]
-                        .map(|entity| transform_query.get_unsafe(entity).ok())
-                        .flatten()
-                        .map(|(transform,)| transform)
-                };
+                // SAFETY: Pre-fetch all transforms to avoid calling get_mut multiple times
+                // this is safe because it doesn't change the safe logic
+                unsafe {
+                    for entry in entities {
+                        components.push(
+                            entry
+                                .map(|entity| transform_query.get_unsafe(entity).ok())
+                                .flatten()
+                                .map(|(transform,)| transform),
+                        );
+                    }
+                }
 
                 // ~23us
                 if let Some(curves) = clip
@@ -519,15 +523,14 @@ pub(crate) fn animator_transform_update_system(
                     .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
                     .flatten()
                 {
+                    // TODO: Got to improve how the keyframes are handled
                     // Get keyframes and ensure capacity
                     let keyframes = keyframe_cache.get(curves.id);
                     keyframes.resize(curves.len() as usize, 0);
 
                     for (curve_index, (entity_index, curve)) in curves.iter().enumerate() {
-                        if let Some(ref mut component) = components[entity_index as usize]
-                            .fetch_mut(|| fetch_fn(entity_index as usize))
-                        {
-                            // TODO: I'm not nocing any discernible peformance change from using just `sample`
+                        if let Some(ref mut component) = components[entity_index as usize] {
+                            // TODO: I'm not noticing any discernible performance change from using just `sample`
                             let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
                             keyframes[curve_index] = k;
                             // let v = curve.sample(time);
@@ -547,9 +550,7 @@ pub(crate) fn animator_transform_update_system(
                     keyframes.resize(curves.len() as usize, 0);
 
                     for (curve_index, (entity_index, curve)) in curves.iter().enumerate() {
-                        if let Some(ref mut component) = components[entity_index as usize]
-                            .fetch_mut(|| fetch_fn(entity_index as usize))
-                        {
+                        if let Some(ref mut component) = components[entity_index as usize] {
                             let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
                             keyframes[curve_index] = k;
                             // let v = curve.sample(time);
@@ -569,9 +570,7 @@ pub(crate) fn animator_transform_update_system(
                     keyframes.resize(curves.len() as usize, 0);
 
                     for (curve_index, (entity_index, curve)) in curves.iter().enumerate() {
-                        if let Some(ref mut component) = components[entity_index as usize]
-                            .fetch_mut(|| fetch_fn(entity_index as usize))
-                        {
+                        if let Some(ref mut component) = components[entity_index as usize] {
                             let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
                             keyframes[curve_index] = k;
                             //let v = curve.sample(time);
diff --git a/crates/bevy_core/src/name.rs b/crates/bevy_core/src/name.rs
index 6eb5da7f036cb..09d3b30bb4323 100644
--- a/crates/bevy_core/src/name.rs
+++ b/crates/bevy_core/src/name.rs
@@ -52,7 +52,7 @@ impl Name {
     }
 
     fn update_hash(&mut self) {
-        // TODO: Try with Fnv and AHash (I'm goging to need a test suit for that, but my money is on ahash)
+        // TODO: Try with Fnv and AHash (I'm going to need a test suit for that, but my money is on ahash)
         let mut hasher = DefaultHasher::default();
         self.name.hash(&mut hasher);
         self.hash = hasher.finish();

From c44cf1e76421f6236e163212109ad80702d2d685 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Tue, 8 Dec 2020 20:16:15 -0300
Subject: [PATCH 043/153] animator merged hierachy

---
 crates/bevy_animation/src/custom.rs | 142 ++++++++++++++++++----------
 1 file changed, 90 insertions(+), 52 deletions(-)

diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index f7e4b4e9aedf1..9144496634384 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -254,14 +254,18 @@ impl Default for Layer {
 
 #[derive(Default, Debug)]
 struct Bind {
-    entities: Vec<Option<Entity>>,
+    entities_indexes: Vec<u16>,
 }
 
 #[derive(Debug, Properties)]
 pub struct Animator {
     clips: Vec<Handle<Clip>>,
     #[property(ignore)]
-    bind_clips: Vec<Bind>,
+    bind_clips: Vec<Option<Bind>>,
+    #[property(ignore)]
+    hierarchy: Hierarchy,
+    #[property(ignore)]
+    entities: Vec<Option<Entity>>,
     pub time_scale: f32,
     pub layers: Vec<Layer>,
 }
@@ -271,6 +275,8 @@ impl Default for Animator {
         Self {
             clips: vec![],
             bind_clips: vec![],
+            hierarchy: Hierarchy::default(),
+            entities: vec![],
             time_scale: 1.0,
             layers: vec![],
         }
@@ -311,23 +317,35 @@ impl Animator {
         }
     }
 }
+
 pub struct LayerIterator<'a> {
     index: usize,
     animator: &'a Animator,
 }
 
 impl<'a> Iterator for LayerIterator<'a> {
-    type Item = (usize, &'a Layer, &'a Handle<Clip>, &'a [Option<Entity>]);
+    type Item = (usize, &'a Layer, &'a Handle<Clip>, &'a [u16]);
 
     fn next(&mut self) -> Option<Self::Item> {
-        let index = self.index;
-        self.index += 1;
+        loop {
+            // Get next layer or stop the iterator
+            let layer = self.animator.layers.get(self.index)?;
+            let index = self.index;
+            self.index += 1;
+
+            let clip_index = layer.clip as usize;
+            if let Some(clip_handle) = self.animator.clips.get(clip_index) {
+                if let Some(Some(bind)) = self.animator.bind_clips.get(clip_index) {
+                    return Some((index, layer, clip_handle, &bind.entities_indexes[..]));
+                }
 
-        let layer = self.animator.layers.get(index)?;
-        let clip_handle = self.animator.clips.get(layer.clip as usize)?;
-        let entities = &self.animator.bind_clips.get(layer.clip as usize)?.entities[..];
+                // Missing clip bind continue to the next layer
+                // TODO: log error
+            }
 
-        return Some((index, layer, clip_handle, entities));
+            // Invalid clip continue to the next layer
+            // TODO: log error
+        }
     }
 }
 
@@ -419,32 +437,51 @@ pub(crate) fn animator_update_system(
         // Make run for the binds
         animator
             .bind_clips
-            .resize_with(animator.clips.len(), Bind::default);
+            .resize_with(animator.clips.len(), || None);
+
+        // TODO: Invalidate clip binds on clip change
 
         for (clip_index, clip_handle) in animator.clips.iter().enumerate() {
             if let Some(clip) = clips.get(clip_handle) {
-                let bind = &mut animator.bind_clips[clip_index];
-
-                // TODO: Don't look for the entities every frame, only when something happens
-                // TODO: Handle parent changed events
-                // TODO: Handle name changed events
-                // TODO: Merge newly added clips hierarchies into a single one
-
-                // Prepare the entities table cache
-                bind.entities.clear();
-                bind.entities.resize(clip.hierarchy().len(), None);
-                // Assign the root entity as the first element
-                bind.entities[0] = Some(animator_entity);
-
-                // Find entities ...
-                for entity_index in 1..clip.hierarchy().len() {
-                    clip.hierarchy().find_entity(
-                        entity_index as u16,
-                        &mut bind.entities,
-                        &mut children_query,
-                        &mut name_query,
-                    );
-                }
+                let opt_bind = &mut animator.bind_clips[clip_index];
+                if opt_bind.is_none() {
+                    // Merge newly added clip hierarchy into the animator global hierarchy
+                    let mut bind = Bind::default();
+                    animator
+                        .hierarchy
+                        .merge(&clip.hierarchy, &mut bind.entities_indexes);
+
+                    // Prepare the entities table cache
+                    animator.entities.resize(animator.hierarchy.len(), None);
+                    // Assign the root entity as the first element
+                    animator.entities[0] = Some(animator_entity);
+
+                    // Find missing entities that where just added in the hierarchy
+                    for entity_index in &bind.entities_indexes {
+                        animator.hierarchy.find_entity(
+                            *entity_index,
+                            &mut animator.entities,
+                            &mut children_query,
+                            &mut name_query,
+                        );
+                    }
+
+                    *opt_bind = Some(bind);
+                };
+
+                // TODO: Invalidate binds on parent changed events
+                // TODO: Invalidate binds on name changed events
+                // if hierarchy_invalidated {
+                //     // Find any missing entities
+                //     for entity_index in 1..clip.hierarchy().len() {
+                //         animator.hierarchy.find_entity(
+                //             entity_index as u16,
+                //             &mut bind.entities,
+                //             &mut children_query,
+                //             &mut name_query,
+                //         );
+                //     }
+                // }
 
                 for layer in &mut animator.layers {
                     if layer.clip as usize != clip_index {
@@ -489,7 +526,24 @@ pub(crate) fn animator_transform_update_system(
         let keyframe_cache = &mut *keyframe_cache;
         let mut blend_group = animator_blend.begin_blending();
 
-        for (_, layer, clip_handle, entities) in animator.animate() {
+        // ~15us
+        components.clear();
+
+        // ? NOTE: Lazy get each component is worse than just fetching everything at once
+        // SAFETY: Pre-fetch all transforms to avoid calling get_mut multiple times
+        // this is safe because it doesn't change the safe logic
+        unsafe {
+            for entity in &animator.entities {
+                components.push(
+                    entity
+                        .map(|entity| transform_query.get_unsafe(entity).ok())
+                        .flatten()
+                        .map(|(transform,)| transform),
+                );
+            }
+        }
+
+        for (_, layer, clip_handle, entities_map) in animator.animate() {
             let w = layer.weight;
             if w < 1.0e-8 {
                 continue;
@@ -498,25 +552,6 @@ pub(crate) fn animator_transform_update_system(
             if let Some(clip) = clips.get(clip_handle) {
                 let time = layer.time;
 
-                // ~15us
-                components.clear();
-
-                // TODO: Merge all the clips hierarchy into a single bigger one
-                // and do the component feching once per animator, instead of per clip
-
-                // SAFETY: Pre-fetch all transforms to avoid calling get_mut multiple times
-                // this is safe because it doesn't change the safe logic
-                unsafe {
-                    for entry in entities {
-                        components.push(
-                            entry
-                                .map(|entity| transform_query.get_unsafe(entity).ok())
-                                .flatten()
-                                .map(|(transform,)| transform),
-                        );
-                    }
-                }
-
                 // ~23us
                 if let Some(curves) = clip
                     .get("Transform.translation")
@@ -529,6 +564,7 @@ pub(crate) fn animator_transform_update_system(
                     keyframes.resize(curves.len() as usize, 0);
 
                     for (curve_index, (entity_index, curve)) in curves.iter().enumerate() {
+                        let entity_index = entities_map[entity_index as usize];
                         if let Some(ref mut component) = components[entity_index as usize] {
                             // TODO: I'm not noticing any discernible performance change from using just `sample`
                             let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
@@ -550,6 +586,7 @@ pub(crate) fn animator_transform_update_system(
                     keyframes.resize(curves.len() as usize, 0);
 
                     for (curve_index, (entity_index, curve)) in curves.iter().enumerate() {
+                        let entity_index = entities_map[entity_index as usize];
                         if let Some(ref mut component) = components[entity_index as usize] {
                             let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
                             keyframes[curve_index] = k;
@@ -570,6 +607,7 @@ pub(crate) fn animator_transform_update_system(
                     keyframes.resize(curves.len() as usize, 0);
 
                     for (curve_index, (entity_index, curve)) in curves.iter().enumerate() {
+                        let entity_index = entities_map[entity_index as usize];
                         if let Some(ref mut component) = components[entity_index as usize] {
                             let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
                             keyframes[curve_index] = k;

From 3117811801cfa0a8f3190774be62c15b58b83e8f Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Wed, 9 Dec 2020 10:45:52 -0300
Subject: [PATCH 044/153] handle clip changed, parent and name changes,
 prefering tracing span

---
 crates/bevy_animation/Cargo.toml          |   2 +-
 crates/bevy_animation/src/custom.rs       | 185 +++++++++++++++++-----
 crates/bevy_animation/src/hierarchy.rs    |   4 +-
 crates/bevy_animation/src/skinned_mesh.rs |  19 ++-
 4 files changed, 153 insertions(+), 57 deletions(-)

diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index d023d0512fb11..361890f172006 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -25,7 +25,7 @@ smallvec = { version = "1.4", features = ["serde"] }
 anyhow = "1.0"
 float-cmp = "0.8.0"
 fnv = "1.0.7"
-tracing = { version = "0.1.21", features = ["attributes"] }
+tracing = "0.1.21"
 
 [dev-dependencies]
 criterion = "0.3.3"
diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 9144496634384..8da42cd1145aa 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -1,5 +1,6 @@
 use anyhow::Result;
-use bevy_asset::{Assets, Handle /*HandleUntyped*/};
+use bevy_app::prelude::{EventReader, Events};
+use bevy_asset::{AssetEvent, Assets, Handle /*HandleUntyped*/};
 use bevy_core::prelude::*;
 use bevy_ecs::prelude::*;
 use bevy_math::prelude::*;
@@ -9,7 +10,7 @@ use bevy_type_registry::TypeUuid;
 use fnv::FnvBuildHasher;
 use smallvec::{smallvec, SmallVec};
 use std::any::Any;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 use crate::blending::{AnimatorBlending, Blend};
 use crate::curve::Curve;
@@ -236,7 +237,7 @@ impl Clip {
 #[derive(Debug, Clone, Properties)]
 pub struct Layer {
     pub weight: f32,
-    pub clip: u16,
+    pub clip: usize,
     pub time: f32,
     pub time_scale: f32,
 }
@@ -265,6 +266,8 @@ pub struct Animator {
     #[property(ignore)]
     hierarchy: Hierarchy,
     #[property(ignore)]
+    missing_entities: bool,
+    #[property(ignore)]
     entities: Vec<Option<Entity>>,
     pub time_scale: f32,
     pub layers: Vec<Layer>,
@@ -276,6 +279,7 @@ impl Default for Animator {
             clips: vec![],
             bind_clips: vec![],
             hierarchy: Hierarchy::default(),
+            missing_entities: false,
             entities: vec![],
             time_scale: 1.0,
             layers: vec![],
@@ -284,18 +288,20 @@ impl Default for Animator {
 }
 
 impl Animator {
-    pub fn add_clip(&mut self, clip: Handle<Clip>) -> u16 {
+    pub fn add_clip(&mut self, clip: Handle<Clip>) -> usize {
         if let Some(i) = self.clips.iter().position(|c| *c == clip) {
-            i as u16
+            i
         } else {
             // TODO: assert too many clips ...
             let i = self.clips.len();
             self.clips.push(clip);
-            i as u16
+            i
         }
     }
 
-    pub fn add_layer(&mut self, clip: Handle<Clip>, weight: f32) -> u16 {
+    // TODO: remove clip
+
+    pub fn add_layer(&mut self, clip: Handle<Clip>, weight: f32) -> usize {
         let clip = self.add_clip(clip);
         let layer_index = self.layers.len();
         self.layers.push(Layer {
@@ -303,11 +309,15 @@ impl Animator {
             weight,
             ..Default::default()
         });
-        layer_index as u16
+        layer_index
     }
 
-    pub fn clips_len(&self) -> u16 {
-        self.clips.len() as u16
+    // TODO: remove layer at index
+
+    // TODO: cleanup, clears hierarchy entities and binds
+
+    pub fn clips(&self) -> &[Handle<Clip>] {
+        &self.clips[..]
     }
 
     pub fn animate<'a>(&'a self) -> LayerIterator<'a> {
@@ -393,9 +403,17 @@ impl<T> FetchState<T> {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[tracing::instrument(skip(commands, time, clips, animators_query, children_query, name_query))]
+/// State info for the system `animator_binding_system`
+#[derive(Default)]
+pub(crate) struct BindingState {
+    clips_event_reader: EventReader<AssetEvent<Clip>>,
+    clips_modified: HashSet<Handle<Clip>, FnvBuildHasher>,
+}
+
 pub(crate) fn animator_update_system(
     commands: &mut Commands,
+    mut state: Local<BindingState>,
+    clip_events: Res<Events<AssetEvent<Clip>>>,
     time: Res<Time>,
     clips: Res<Assets<Clip>>,
     mut animators_query: Query<(
@@ -404,10 +422,28 @@ pub(crate) fn animator_update_system(
         Option<&KeyframeCache>,
         Option<&AnimatorBlending>,
     )>,
-    mut children_query: Query<(&Children,)>,
-    mut name_query: Query<(&Parent, &Name)>,
+    children_query: Query<(&Children,)>,
+    name_query: Query<(&Parent, &Name)>,
+    parent_or_name_changed_query: Query<(Option<&Parent>, &Name), (Changed<Parent>, Changed<Name>)>,
 ) {
-    for (animator_entity, mut animator, keyframe_cache, visited) in animators_query.iter_mut() {
+    let __span = tracing::info_span!("animator_update_system");
+    let __guard = __span.enter();
+
+    // ? NOTE: Changing a clip on fly is supported, but very expensive so use with caution
+    // TODO: Put a warning somewhere in the docs on how expensive is changing a clip on the fly
+    // Query all clips that changed and remove their binds from the animator
+    state.clips_modified.clear();
+    for event in state.clips_event_reader.iter(&clip_events) {
+        match event {
+            AssetEvent::Removed { handle } => state.clips_modified.insert(handle.clone()),
+            AssetEvent::Modified { handle } => state.clips_modified.insert(handle.clone()),
+            _ => false,
+        };
+    }
+
+    for (animator_entity, mut animator, keyframe_cache, animator_blending) in
+        animators_query.iter_mut()
+    {
         let animator = &mut *animator;
 
         // Insert KeyframeCache if not already
@@ -415,7 +451,7 @@ pub(crate) fn animator_update_system(
             commands.insert_one(animator_entity, KeyframeCache::default());
         }
 
-        if visited.is_none() {
+        if animator_blending.is_none() {
             commands.insert_one(animator_entity, AnimatorBlending::default());
         }
 
@@ -434,17 +470,75 @@ pub(crate) fn animator_update_system(
             layer.weight *= norm;
         }
 
+        // Invalidate entities on parent or name changed events
+        for (entity_index, ((parent_index, name), _)) in animator.hierarchy.iter().enumerate() {
+            // Ignore the root entity as we don't care about it's parent nor it's name
+            if entity_index == 0 {
+                continue;
+            }
+
+            let entity = animator.entities[entity_index];
+
+            // ? NOTE: Use a changed events for both parent and name because name
+            // ? comparison isn't fast, as result it won't notice changes before the
+            // ? POST_UPDATE stage
+            if let Some((entity_parent, entity_name)) = entity
+                .map(|entity| parent_or_name_changed_query.get(entity).ok())
+                .flatten()
+            {
+                let parent = animator.entities[*parent_index as usize];
+                if entity_parent.map(|p| p.0) != parent || name != entity_name {
+                    animator.entities[entity_index] = None;
+                    animator.missing_entities = true;
+                }
+            }
+        }
+
+        // TODO: Figure out how expensive this might be with a couple of entities missing
+        // Look for missing entities if any
+        if animator.missing_entities {
+            let mut missing = false;
+            let count = animator.hierarchy.len();
+
+            // Prepare the entities table cache
+            animator.entities.resize(count, None);
+            // Assign the root entity as the first element
+            animator.entities[0] = Some(animator_entity);
+
+            // Find missing entities that where just added in the hierarchy
+            for entity_index in 0..count {
+                missing |= animator
+                    .hierarchy
+                    .find_entity(
+                        entity_index as u16,
+                        &mut animator.entities,
+                        &children_query,
+                        &name_query,
+                    )
+                    .is_none();
+            }
+
+            // Update missing entities state
+            animator.missing_entities = missing;
+            println!("missing entities ...");
+        }
+
         // Make run for the binds
         animator
             .bind_clips
             .resize_with(animator.clips.len(), || None);
 
-        // TODO: Invalidate clip binds on clip change
-
         for (clip_index, clip_handle) in animator.clips.iter().enumerate() {
+            // Invalidate clip binds on clip change
+            // NOTE: The clip might be gone so it's necessary to update it here
+            if state.clips_modified.contains(clip_handle) {
+                animator.bind_clips[clip_index] = None;
+                // TODO: warning clip modified while assigned to an animator
+            }
+
             if let Some(clip) = clips.get(clip_handle) {
-                let opt_bind = &mut animator.bind_clips[clip_index];
-                if opt_bind.is_none() {
+                let bind_slot = &mut animator.bind_clips[clip_index];
+                if bind_slot.is_none() {
                     // Merge newly added clip hierarchy into the animator global hierarchy
                     let mut bind = Bind::default();
                     animator
@@ -456,32 +550,25 @@ pub(crate) fn animator_update_system(
                     // Assign the root entity as the first element
                     animator.entities[0] = Some(animator_entity);
 
+                    let mut missing = false;
                     // Find missing entities that where just added in the hierarchy
                     for entity_index in &bind.entities_indexes {
-                        animator.hierarchy.find_entity(
-                            *entity_index,
-                            &mut animator.entities,
-                            &mut children_query,
-                            &mut name_query,
-                        );
+                        missing |= animator
+                            .hierarchy
+                            .find_entity(
+                                *entity_index,
+                                &mut animator.entities,
+                                &children_query,
+                                &name_query,
+                            )
+                            .is_none();
                     }
 
-                    *opt_bind = Some(bind);
-                };
+                    // Set missing entities if any
+                    animator.missing_entities |= missing;
 
-                // TODO: Invalidate binds on parent changed events
-                // TODO: Invalidate binds on name changed events
-                // if hierarchy_invalidated {
-                //     // Find any missing entities
-                //     for entity_index in 1..clip.hierarchy().len() {
-                //         animator.hierarchy.find_entity(
-                //             entity_index as u16,
-                //             &mut bind.entities,
-                //             &mut children_query,
-                //             &mut name_query,
-                //         );
-                //     }
-                // }
+                    *bind_slot = Some(bind);
+                };
 
                 for layer in &mut animator.layers {
                     if layer.clip as usize != clip_index {
@@ -509,17 +596,21 @@ pub(crate) fn animator_update_system(
             }
         }
     }
+
+    std::mem::drop(__guard);
 }
 
 // TODO: This should be auto derived using the "Animated" trait that just returns
 // a system able to animate the said component. Use "AnimatedAsset" for asset handles!
 
-#[tracing::instrument(skip(clips, animators_query, transform_query))]
 pub(crate) fn animator_transform_update_system(
     clips: Res<Assets<Clip>>,
     mut animators_query: Query<(&Animator, &mut KeyframeCache, &mut AnimatorBlending)>,
     transform_query: Query<(&mut Transform,)>,
 ) {
+    let __span = tracing::info_span!("animator_transform_update_system");
+    let __guard = __span.enter();
+
     let mut components = vec![];
 
     for (animator, mut keyframe_cache, mut animator_blend) in animators_query.iter_mut() {
@@ -530,8 +621,10 @@ pub(crate) fn animator_transform_update_system(
         components.clear();
 
         // ? NOTE: Lazy get each component is worse than just fetching everything at once
-        // SAFETY: Pre-fetch all transforms to avoid calling get_mut multiple times
-        // this is safe because it doesn't change the safe logic
+        // Pre-fetch all transforms to avoid calling get_mut multiple times
+        // SAFETY: each component will be updated one at the time and this function
+        // currently has the mutability over the Transform type, so no race conditions
+        // are possible
         unsafe {
             for entity in &animator.entities {
                 components.push(
@@ -566,7 +659,7 @@ pub(crate) fn animator_transform_update_system(
                     for (curve_index, (entity_index, curve)) in curves.iter().enumerate() {
                         let entity_index = entities_map[entity_index as usize];
                         if let Some(ref mut component) = components[entity_index as usize] {
-                            // TODO: I'm not noticing any discernible performance change from using just `sample`
+                            // TODO: I'm not noticing any discernible performance change from using just `sample` so there's probably something wrong
                             let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
                             keyframes[curve_index] = k;
                             // let v = curve.sample(time);
@@ -619,8 +712,12 @@ pub(crate) fn animator_transform_update_system(
             }
         }
     }
+
+    std::mem::drop(__guard);
 }
 
+// TODO: Port tests from the generic unsafe
+
 // #[cfg(test)]
 // #[allow(dead_code)]
 // mod tests {
diff --git a/crates/bevy_animation/src/hierarchy.rs b/crates/bevy_animation/src/hierarchy.rs
index 947450cd9b593..01f33e269f8cd 100644
--- a/crates/bevy_animation/src/hierarchy.rs
+++ b/crates/bevy_animation/src/hierarchy.rs
@@ -219,8 +219,8 @@ impl<I: Index> Hierarchy<I> {
         &self,
         entity_index: I,
         entities_table_cache: &mut Vec<Option<Entity>>,
-        children_query: &mut Query<(&Children,)>,
-        name_query: &mut Query<(&Parent, &Name)>,
+        children_query: &Query<(&Children,)>,
+        name_query: &Query<(&Parent, &Name)>,
     ) -> Option<Entity> {
         if let Some(entity) = &entities_table_cache[entity_index.as_usize()] {
             Some(*entity)
diff --git a/crates/bevy_animation/src/skinned_mesh.rs b/crates/bevy_animation/src/skinned_mesh.rs
index 129f963b2287c..75c6664a49774 100644
--- a/crates/bevy_animation/src/skinned_mesh.rs
+++ b/crates/bevy_animation/src/skinned_mesh.rs
@@ -103,12 +103,14 @@ impl MapEntities for SkinComponent {
     }
 }
 
-#[tracing::instrument(skip(pipelines, shaders, render_graph))]
 pub(crate) fn skinning_setup(
     mut pipelines: ResMut<Assets<PipelineDescriptor>>,
     mut shaders: ResMut<Assets<Shader>>,
     mut render_graph: ResMut<RenderGraph>,
 ) {
+    let __span = tracing::info_span!("skinning_setup");
+    let __guard = __span.enter();
+
     let mut forward_skinned_pipeline = pipelines
         .get(bevy_pbr::render_graph::FORWARD_PIPELINE_HANDLE)
         .expect("missing forward pipeline")
@@ -132,19 +134,12 @@ pub(crate) fn skinning_setup(
     render_graph
         .add_node_edge("skin_instance", base::node::MAIN_PASS)
         .unwrap();
+
+    std::mem::drop(__guard);
 }
 
 // ? NOTE: You can check the follow link, for more details
 // ? https://github.com/KhronosGroup/glTF-Tutorials/blob/master/gltfTutorial/gltfTutorial_020_Skins.md
-#[tracing::instrument(skip(
-    commands,
-    skin_assets,
-    skin_instances,
-    binds_query,
-    children_query,
-    name_query,
-    transforms_query
-))]
 pub(crate) fn skinning_update(
     commands: &mut Commands,
     skin_assets: Res<Assets<SkinAsset>>,
@@ -157,6 +152,8 @@ pub(crate) fn skinning_update(
     transforms_query: Query<(&GlobalTransform,)>,
     mut renderers_query: Query<(&mut RenderPipelines,)>,
 ) {
+    let __span = tracing::info_span!("skinning_update");
+    let __guard = __span.enter();
     for (skin_asset_handle, mut skin_bind, skin_children) in binds_query.iter_mut() {
         // Already assigned
         if Some(skin_asset_handle) != skin_bind.previous_skin.as_ref() {
@@ -245,6 +242,8 @@ pub(crate) fn skinning_update(
                 });
         }
     }
+
+    std::mem::drop(__guard);
 }
 
 ///////////////////////////////////////////////////////////////////////////////

From c59e4a8318c396643a8964469391c0ef8108e6f0 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Wed, 9 Dec 2020 13:37:16 -0300
Subject: [PATCH 045/153] proper keyframe caching

---
 crates/bevy_animation/src/custom.rs | 156 +++++++++++++---------------
 1 file changed, 70 insertions(+), 86 deletions(-)

diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 8da42cd1145aa..3f060ef7bebd9 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -11,6 +11,7 @@ use fnv::FnvBuildHasher;
 use smallvec::{smallvec, SmallVec};
 use std::any::Any;
 use std::collections::{HashMap, HashSet};
+use std::marker::PhantomData;
 
 use crate::blending::{AnimatorBlending, Blend};
 use crate::curve::Curve;
@@ -19,17 +20,16 @@ use crate::lerping::Lerp;
 
 #[derive(Debug)]
 pub struct Curves<T> {
-    id: usize,
-    /// Maps each curve to an entity index or other value
-    indexes: SmallVec<[u16; 8]>,
-    curves: Vec<Curve<T>>,
+    property_index: usize,
+    entity_indexes: SmallVec<[u16; 8]>,
+    curves: Vec<(usize, Curve<T>)>,
 }
 
 impl<T> Curves<T> {
     fn calculate_duration(&self) -> f32 {
         self.curves
             .iter()
-            .map(|c| c.duration())
+            .map(|(_, c)| c.duration())
             .fold(0.0f32, |acc, d| acc.max(d))
     }
 
@@ -40,8 +40,8 @@ impl<T> Curves<T> {
     }
 
     #[inline(always)]
-    pub fn iter(&self) -> impl Iterator<Item = (u16, &Curve<T>)> {
-        self.indexes.iter().copied().zip(self.curves.iter())
+    pub fn iter(&self) -> impl Iterator<Item = (u16, &(usize, Curve<T>))> {
+        self.entity_indexes.iter().copied().zip(self.curves.iter())
     }
 }
 
@@ -59,10 +59,7 @@ unsafe impl Sync for CurvesUntyped {}
 impl CurvesUntyped {
     fn new<T: Send + Sync + 'static>(curves: Curves<T>) -> Self {
         CurvesUntyped {
-            duration: curves
-                .iter()
-                .map(|(_, c)| c.duration())
-                .fold(0.0, |acc, d| acc.max(d)),
+            duration: curves.calculate_duration(),
             untyped: Box::new(curves),
         }
     }
@@ -98,6 +95,8 @@ pub struct Clip {
     hierarchy: Hierarchy,
     // ? NOTE: AHash performed worse than FnvHasher
     properties: HashMap<String, CurvesUntyped, FnvBuildHasher>,
+    /// Number of animated properties
+    len: usize,
 }
 
 // fn clip_default_warp() -> bool {
@@ -111,6 +110,7 @@ impl Default for Clip {
             duration: 0.0,
             hierarchy: Hierarchy::default(),
             properties: HashMap::default(),
+            len: 0,
         }
     }
 }
@@ -140,12 +140,12 @@ impl Clip {
 
             // If some entity was created it means this property is a new one so we can safely skip the attribute testing
             if let Some(i) = curves
-                .indexes
+                .entity_indexes
                 .iter()
                 .position(|index| *index == entity_index)
             {
                 // Found a property equal to the one been inserted, next replace the curve
-                std::mem::swap(&mut curves.curves[i], &mut curve);
+                std::mem::swap(&mut curves.curves[i].1, &mut curve);
 
                 // Update curve duration in two stages
                 let duration = curves.calculate_duration();
@@ -158,12 +158,17 @@ impl Clip {
                 std::mem::drop(curves_untyped);
                 self.duration = self.calculate_duration();
             } else {
+                let curve_index = self.len;
+                self.len += 1;
+
                 // Append newly added curve
                 let duration = curve.duration();
-                curves.curves.push(curve);
-                curves.indexes.push(entity_index);
+
+                curves.curves.push((curve_index, curve));
+                curves.entity_indexes.push(entity_index);
                 std::mem::drop(curves);
 
+                self.len += 1;
                 self.duration = self.duration.max(duration);
                 curves_untyped.duration = curves_untyped.duration.max(duration);
             }
@@ -171,22 +176,24 @@ impl Clip {
         }
 
         self.duration = self.duration.max(curve.duration());
-        let id = self.properties.len();
+        let property_index = self.properties.len();
+        let curve_index = self.len;
+        self.len += 1;
         self.properties.insert(
             target_name.to_string(),
             CurvesUntyped::new(Curves {
-                id,
-                curves: vec![curve],
-                indexes: smallvec![entity_index],
+                property_index,
+                curves: vec![(curve_index, curve)],
+                entity_indexes: smallvec![entity_index],
             }),
         );
     }
 
-    // /// Number of animated properties in this clip
-    // #[inline(always)]
-    // pub fn len(&self) -> u16 {
-    //     self.curves.len() as u16
-    // }
+    /// Number of animated properties in this clip
+    #[inline(always)]
+    pub fn len(&self) -> usize {
+        self.len
+    }
 
     // /// Returns the property curve property path.
     // ///
@@ -240,6 +247,7 @@ pub struct Layer {
     pub clip: usize,
     pub time: f32,
     pub time_scale: f32,
+    keyframes: Vec<usize>,
 }
 
 impl Default for Layer {
@@ -249,13 +257,14 @@ impl Default for Layer {
             clip: 0,
             time: 0.0,
             time_scale: 1.0,
+            keyframes: vec![],
         }
     }
 }
 
 #[derive(Default, Debug)]
 struct Bind {
-    entities_indexes: Vec<u16>,
+    entity_indexes: Vec<u16>,
 }
 
 #[derive(Debug, Properties)]
@@ -320,33 +329,41 @@ impl Animator {
         &self.clips[..]
     }
 
-    pub fn animate<'a>(&'a self) -> LayerIterator<'a> {
+    pub fn animate<'a>(&'a mut self) -> LayerIterator<'a> {
         LayerIterator {
             index: 0,
             animator: self,
+            marker: PhantomData,
         }
     }
 }
 
 pub struct LayerIterator<'a> {
     index: usize,
-    animator: &'a Animator,
+    animator: *mut Animator,
+    marker: PhantomData<&'a ()>,
 }
 
 impl<'a> Iterator for LayerIterator<'a> {
-    type Item = (usize, &'a Layer, &'a Handle<Clip>, &'a [u16]);
+    type Item = (usize, &'a mut Layer, &'a Handle<Clip>, &'a [u16]);
 
     fn next(&mut self) -> Option<Self::Item> {
         loop {
+            // SAFETY: `self.maker` makes ensure to hold a mutable borrow to the
+            // base `Animator`, with that in mind we can safely mutable iterate over
+            // each valid layer while returning some other immutable data related
+            // to that said layer
+            let animator = unsafe { &mut *(self.animator) };
+
             // Get next layer or stop the iterator
-            let layer = self.animator.layers.get(self.index)?;
+            let layer = animator.layers.get_mut(self.index)?;
             let index = self.index;
             self.index += 1;
 
             let clip_index = layer.clip as usize;
-            if let Some(clip_handle) = self.animator.clips.get(clip_index) {
-                if let Some(Some(bind)) = self.animator.bind_clips.get(clip_index) {
-                    return Some((index, layer, clip_handle, &bind.entities_indexes[..]));
+            if let Some(clip_handle) = animator.clips.get(clip_index) {
+                if let Some(Some(bind)) = animator.bind_clips.get(clip_index) {
+                    return Some((index, layer, clip_handle, &bind.entity_indexes[..]));
                 }
 
                 // Missing clip bind continue to the next layer
@@ -359,18 +376,6 @@ impl<'a> Iterator for LayerIterator<'a> {
     }
 }
 
-#[derive(Default, Debug, Properties)]
-pub struct KeyframeCache {
-    cache: Vec<Vec<usize>>,
-}
-
-impl KeyframeCache {
-    pub fn get(&mut self, index: usize) -> &mut Vec<usize> {
-        self.cache.resize_with(index + 1, Default::default);
-        &mut self.cache[index]
-    }
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 pub enum FetchState<T> {
@@ -416,12 +421,7 @@ pub(crate) fn animator_update_system(
     clip_events: Res<Events<AssetEvent<Clip>>>,
     time: Res<Time>,
     clips: Res<Assets<Clip>>,
-    mut animators_query: Query<(
-        Entity,
-        &mut Animator,
-        Option<&KeyframeCache>,
-        Option<&AnimatorBlending>,
-    )>,
+    mut animators_query: Query<(Entity, &mut Animator, Option<&AnimatorBlending>)>,
     children_query: Query<(&Children,)>,
     name_query: Query<(&Parent, &Name)>,
     parent_or_name_changed_query: Query<(Option<&Parent>, &Name), (Changed<Parent>, Changed<Name>)>,
@@ -441,16 +441,9 @@ pub(crate) fn animator_update_system(
         };
     }
 
-    for (animator_entity, mut animator, keyframe_cache, animator_blending) in
-        animators_query.iter_mut()
-    {
+    for (animator_entity, mut animator, animator_blending) in animators_query.iter_mut() {
         let animator = &mut *animator;
 
-        // Insert KeyframeCache if not already
-        if keyframe_cache.is_none() {
-            commands.insert_one(animator_entity, KeyframeCache::default());
-        }
-
         if animator_blending.is_none() {
             commands.insert_one(animator_entity, AnimatorBlending::default());
         }
@@ -543,7 +536,7 @@ pub(crate) fn animator_update_system(
                     let mut bind = Bind::default();
                     animator
                         .hierarchy
-                        .merge(&clip.hierarchy, &mut bind.entities_indexes);
+                        .merge(&clip.hierarchy, &mut bind.entity_indexes);
 
                     // Prepare the entities table cache
                     animator.entities.resize(animator.hierarchy.len(), None);
@@ -552,7 +545,7 @@ pub(crate) fn animator_update_system(
 
                     let mut missing = false;
                     // Find missing entities that where just added in the hierarchy
-                    for entity_index in &bind.entities_indexes {
+                    for entity_index in &bind.entity_indexes {
                         missing |= animator
                             .hierarchy
                             .find_entity(
@@ -583,7 +576,8 @@ pub(crate) fn animator_update_system(
                         // Warp Around
                         if time > clip.duration() {
                             time = (time / clip.duration()).fract() * clip.duration();
-                            // TODO: Reset all keyframes cached indexes (speedup)
+                            // Reset keyframes indexes (speedup sampling)
+                            layer.keyframes.iter_mut().for_each(|k| *k = 0);
                         }
                     } else {
                         // Hold
@@ -605,7 +599,7 @@ pub(crate) fn animator_update_system(
 
 pub(crate) fn animator_transform_update_system(
     clips: Res<Assets<Clip>>,
-    mut animators_query: Query<(&Animator, &mut KeyframeCache, &mut AnimatorBlending)>,
+    mut animators_query: Query<(&mut Animator, &mut AnimatorBlending)>,
     transform_query: Query<(&mut Transform,)>,
 ) {
     let __span = tracing::info_span!("animator_transform_update_system");
@@ -613,8 +607,7 @@ pub(crate) fn animator_transform_update_system(
 
     let mut components = vec![];
 
-    for (animator, mut keyframe_cache, mut animator_blend) in animators_query.iter_mut() {
-        let keyframe_cache = &mut *keyframe_cache;
+    for (mut animator, mut animator_blend) in animators_query.iter_mut() {
         let mut blend_group = animator_blend.begin_blending();
 
         // ~15us
@@ -645,23 +638,22 @@ pub(crate) fn animator_transform_update_system(
             if let Some(clip) = clips.get(clip_handle) {
                 let time = layer.time;
 
+                // Get keyframes and ensure capacity
+                let keyframes = &mut layer.keyframes;
+                keyframes.resize(clip.len(), 0);
+
                 // ~23us
                 if let Some(curves) = clip
                     .get("Transform.translation")
                     .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
                     .flatten()
                 {
-                    // TODO: Got to improve how the keyframes are handled
-                    // Get keyframes and ensure capacity
-                    let keyframes = keyframe_cache.get(curves.id);
-                    keyframes.resize(curves.len() as usize, 0);
-
-                    for (curve_index, (entity_index, curve)) in curves.iter().enumerate() {
+                    for (entity_index, (curve_index, curve)) in curves.iter() {
                         let entity_index = entities_map[entity_index as usize];
                         if let Some(ref mut component) = components[entity_index as usize] {
                             // TODO: I'm not noticing any discernible performance change from using just `sample` so there's probably something wrong
-                            let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
-                            keyframes[curve_index] = k;
+                            let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
+                            keyframes[*curve_index] = k;
                             // let v = curve.sample(time);
                             component.translation.blend(&mut blend_group, v, w);
                         }
@@ -674,15 +666,11 @@ pub(crate) fn animator_transform_update_system(
                     .map(|curve_untyped| curve_untyped.downcast_ref::<Quat>())
                     .flatten()
                 {
-                    // Get keyframes and ensure capacity
-                    let keyframes = keyframe_cache.get(curves.id);
-                    keyframes.resize(curves.len() as usize, 0);
-
-                    for (curve_index, (entity_index, curve)) in curves.iter().enumerate() {
+                    for (entity_index, (curve_index, curve)) in curves.iter() {
                         let entity_index = entities_map[entity_index as usize];
                         if let Some(ref mut component) = components[entity_index as usize] {
-                            let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
-                            keyframes[curve_index] = k;
+                            let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
+                            keyframes[*curve_index] = k;
                             // let v = curve.sample(time);
                             component.rotation.blend(&mut blend_group, v, w);
                         }
@@ -695,15 +683,11 @@ pub(crate) fn animator_transform_update_system(
                     .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
                     .flatten()
                 {
-                    // Get keyframes and ensure capacity
-                    let keyframes = keyframe_cache.get(curves.id);
-                    keyframes.resize(curves.len() as usize, 0);
-
-                    for (curve_index, (entity_index, curve)) in curves.iter().enumerate() {
+                    for (entity_index, (curve_index, curve)) in curves.iter() {
                         let entity_index = entities_map[entity_index as usize];
                         if let Some(ref mut component) = components[entity_index as usize] {
-                            let (k, v) = curve.sample_indexed(keyframes[curve_index], time);
-                            keyframes[curve_index] = k;
+                            let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
+                            keyframes[*curve_index] = k;
                             //let v = curve.sample(time);
                             component.scale.blend(&mut blend_group, v, w);
                         }

From 03deddca94b2a2b0e8e8edb3afb6ed6aad17baf9 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Thu, 10 Dec 2020 09:40:26 -0300
Subject: [PATCH 046/153] added simple animation example

---
 Cargo.toml                                    |    4 +
 .../character_medium/character_medium.gltf    | 1462 +++++
 assets/models/character_medium/idle.gltf      | 5319 +++++++++++++++++
 assets/models/character_medium/run.gltf       | 3723 ++++++++++++
 examples/animations/run_animation.rs          |   95 +
 5 files changed, 10603 insertions(+)
 create mode 100644 assets/models/character_medium/character_medium.gltf
 create mode 100644 assets/models/character_medium/idle.gltf
 create mode 100644 assets/models/character_medium/run.gltf
 create mode 100644 examples/animations/run_animation.rs

diff --git a/Cargo.toml b/Cargo.toml
index ebf31153438bd..b4451163da986 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -333,6 +333,10 @@ crate-type = ["cdylib"]
 name = "android"
 path = "examples/android/android.rs"
 
+[[example]]
+name = "run_animation"
+path = "examples/animations/run_animation.rs"
+
 [package.metadata.android]
 apk_label = "Bevy Example"
 assets = "assets"
diff --git a/assets/models/character_medium/character_medium.gltf b/assets/models/character_medium/character_medium.gltf
new file mode 100644
index 0000000000000..ed1131e38c2c1
--- /dev/null
+++ b/assets/models/character_medium/character_medium.gltf
@@ -0,0 +1,1462 @@
+{
+    "asset" : {
+        "generator" : "Khronos glTF Blender I/O v1.2.75",
+        "version" : "2.0"
+    },
+    "scene" : 0,
+    "scenes" : [
+        {
+            "name" : "Scene",
+            "nodes" : [
+                59
+            ]
+        }
+    ],
+    "nodes" : [
+        {
+            "name" : "LeftFootIK_end",
+            "rotation" : [
+                8.370261639356613e-08,
+                -6.146728992462158e-08,
+                5.029142258194952e-08,
+                1
+            ],
+            "scale" : [
+                0.9999999403953552,
+                1,
+                1
+            ],
+            "translation" : [
+                -1.0360963642597198e-08,
+                0.3012543320655823,
+                5.587935447692871e-09
+            ]
+        },
+        {
+            "children" : [
+                0
+            ],
+            "name" : "LeftFootIK",
+            "rotation" : [
+                -0.9461289048194885,
+                0.02187088504433632,
+                -0.07550261914730072,
+                0.3141039311885834
+            ],
+            "scale" : [
+                0.9999998807907104,
+                0.9999997019767761,
+                0.9999997019767761
+            ],
+            "translation" : [
+                -0.0018213894218206406,
+                0.24152174592018127,
+                0.18005000054836273
+            ]
+        },
+        {
+            "children" : [
+                1
+            ],
+            "name" : "LeftToeRoll",
+            "rotation" : [
+                -0.015743978321552277,
+                0.0020794300362467766,
+                -0.994624674320221,
+                0.10232134908437729
+            ],
+            "scale" : [
+                0.9999993443489075,
+                0.9999999403953552,
+                1.0000001192092896
+            ],
+            "translation" : [
+                -0.028664225712418556,
+                0.3069329559803009,
+                0.0010430027032271028
+            ]
+        },
+        {
+            "children" : [
+                2
+            ],
+            "name" : "LeftHeelRoll",
+            "rotation" : [
+                0.5075158476829529,
+                -0.5082323551177979,
+                0.49190211296081543,
+                0.4920974373817444
+            ],
+            "scale" : [
+                1,
+                0.9999999403953552,
+                0.9999998211860657
+            ],
+            "translation" : [
+                0.07085255533456802,
+                0.1799013763666153,
+                -0.022240422666072845
+            ]
+        },
+        {
+            "name" : "LeftFootRollCtrl_end",
+            "rotation" : [
+                -1.2309296693047145e-08,
+                6.436162891532149e-08,
+                -2.8218843345470708e-14,
+                1
+            ],
+            "translation" : [
+                -3.657278924151797e-08,
+                0.2927666902542114,
+                1.4783219981495677e-08
+            ]
+        },
+        {
+            "children" : [
+                4
+            ],
+            "name" : "LeftFootRollCtrl",
+            "rotation" : [
+                0.4999999701976776,
+                0.4999999701976776,
+                -0.49999991059303284,
+                0.5000001192092896
+            ],
+            "scale" : [
+                1,
+                1,
+                0.9999998807907104
+            ],
+            "translation" : [
+                2.110799357524229e-08,
+                -1.453767595194222e-07,
+                1.194414700478319e-08
+            ]
+        },
+        {
+            "name" : "LeftKneeCtrl_end",
+            "rotation" : [
+                6.403720931302814e-08,
+                -1.5653962958647521e-15,
+                -8.848255106386205e-08,
+                1
+            ],
+            "translation" : [
+                -7.078496011558855e-09,
+                0.3368157744407654,
+                4.481264781475147e-08
+            ]
+        },
+        {
+            "children" : [
+                6
+            ],
+            "name" : "LeftKneeCtrl",
+            "rotation" : [
+                0.7071069478988647,
+                -5.338493025419666e-08,
+                -0.7071065902709961,
+                7.174813276833447e-08
+            ],
+            "scale" : [
+                1,
+                0.9999998807907104,
+                1
+            ],
+            "translation" : [
+                -0.6179579496383667,
+                -0.5867008566856384,
+                0.025887109339237213
+            ]
+        },
+        {
+            "children" : [
+                3,
+                5,
+                7
+            ],
+            "name" : "LeftFootCtrl",
+            "rotation" : [
+                -0.7071065902709961,
+                1.0716389198250909e-07,
+                0.7071069478988647,
+                -1.5225005256525037e-08
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999997615814209,
+                0.9999998807907104
+            ],
+            "translation" : [
+                0.20420880615711212,
+                0.19320480525493622,
+                -0.14880995452404022
+            ]
+        },
+        {
+            "name" : "RightFootIK_end",
+            "rotation" : [
+                9.313225746154785e-09,
+                1.3969838619232178e-08,
+                -1.6763806343078613e-08,
+                1
+            ],
+            "translation" : [
+                2.130400389432907e-08,
+                0.30125436186790466,
+                -8.381903171539307e-09
+            ]
+        },
+        {
+            "children" : [
+                9
+            ],
+            "name" : "RightFootIK",
+            "rotation" : [
+                -0.9481120109558105,
+                -0.011444882489740849,
+                0.04409303143620491,
+                0.31465616822242737
+            ],
+            "scale" : [
+                1.0000001192092896,
+                0.9999999403953552,
+                1.0000008344650269
+            ],
+            "translation" : [
+                0.0018214210867881775,
+                0.24152177572250366,
+                0.18005001544952393
+            ]
+        },
+        {
+            "children" : [
+                10
+            ],
+            "name" : "RightToeRoll",
+            "rotation" : [
+                0.015668466687202454,
+                0.0011510740732774138,
+                0.9946258068084717,
+                0.1023358404636383
+            ],
+            "scale" : [
+                1.000000238418579,
+                1.0000001192092896,
+                1.0000001192092896
+            ],
+            "translation" : [
+                0.02867291308939457,
+                0.3069329857826233,
+                -0.0007682866998948157
+            ]
+        },
+        {
+            "children" : [
+                11
+            ],
+            "name" : "RightHeelRoll",
+            "rotation" : [
+                0.5076821446418762,
+                -0.5078983902931213,
+                0.4917316138744354,
+                0.4924410283565521
+            ],
+            "scale" : [
+                0.9999998211860657,
+                0.9999998211860657,
+                0.9999998211860657
+            ],
+            "translation" : [
+                0.07085256278514862,
+                0.1799013912677765,
+                0.022240404039621353
+            ]
+        },
+        {
+            "name" : "RightFootRollCtrl_end",
+            "rotation" : [
+                3.858188790673012e-08,
+                6.436162891532149e-08,
+                -3.174906491138982e-14,
+                1
+            ],
+            "translation" : [
+                2.3031857310229498e-08,
+                0.2927666902542114,
+                9.662918465380699e-09
+            ]
+        },
+        {
+            "children" : [
+                13
+            ],
+            "name" : "RightFootRollCtrl",
+            "rotation" : [
+                0.4999999701976776,
+                0.4999999701976776,
+                -0.49999991059303284,
+                0.5000001192092896
+            ],
+            "scale" : [
+                1,
+                1,
+                0.9999998807907104
+            ],
+            "translation" : [
+                -9.718464255570325e-09,
+                -1.6095333421617397e-07,
+                1.1944128353036376e-08
+            ]
+        },
+        {
+            "name" : "RightKneeCtrl_end",
+            "rotation" : [
+                6.403065810900443e-08,
+                -1.565655487946612e-15,
+                -8.848255106386205e-08,
+                1
+            ],
+            "translation" : [
+                -7.078497787915694e-09,
+                0.3368157744407654,
+                6.228514592976353e-08
+            ]
+        },
+        {
+            "children" : [
+                15
+            ],
+            "name" : "RightKneeCtrl",
+            "rotation" : [
+                0.7071069478988647,
+                -5.338493025419666e-08,
+                -0.7071065902709961,
+                7.174813276833447e-08
+            ],
+            "scale" : [
+                1,
+                0.9999998807907104,
+                1
+            ],
+            "translation" : [
+                -0.6179579496383667,
+                -0.5867008566856384,
+                -0.02919813245534897
+            ]
+        },
+        {
+            "children" : [
+                12,
+                14,
+                16
+            ],
+            "name" : "RightFootCtrl",
+            "rotation" : [
+                -0.7071065902709961,
+                1.0715462650523477e-07,
+                0.7071069478988647,
+                -1.522037251788788e-08
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999997615814209,
+                0.9999998807907104
+            ],
+            "translation" : [
+                -0.2075204998254776,
+                0.19320477545261383,
+                -0.14881004393100739
+            ]
+        },
+        {
+            "name" : "Head_end",
+            "rotation" : [
+                6.752088665962219e-09,
+                1.932102481477793e-15,
+                -1.1268926330271212e-16,
+                1
+            ],
+            "translation" : [
+                -1.8246099076080213e-11,
+                1.0044100284576416,
+                1.3970630208248735e-09
+            ]
+        },
+        {
+            "children" : [
+                18
+            ],
+            "name" : "Head",
+            "rotation" : [
+                -0.07413530349731445,
+                -4.5896997313832344e-10,
+                -2.5659066885119763e-11,
+                0.9972482919692993
+            ],
+            "scale" : [
+                1.0000040531158447,
+                1.0000001192092896,
+                1.000000238418579
+            ],
+            "translation" : [
+                2.096879961333009e-12,
+                0.2780095040798187,
+                -1.7256125417475232e-08
+            ]
+        },
+        {
+            "children" : [
+                19
+            ],
+            "name" : "Neck",
+            "rotation" : [
+                0.07661580294370651,
+                5.109638823164175e-10,
+                5.3365756258472175e-11,
+                0.9970607161521912
+            ],
+            "scale" : [
+                1,
+                0.9999999403953552,
+                0.9999998807907104
+            ],
+            "translation" : [
+                5.244972208287568e-13,
+                0.2708642780780792,
+                -7.385657863068218e-09
+            ]
+        },
+        {
+            "name" : "LeftHandIndex3_end",
+            "rotation" : [
+                8.268706324088271e-07,
+                -8.514544447280059e-07,
+                2.646538277417676e-08,
+                1
+            ],
+            "scale" : [
+                0.9999999403953552,
+                1,
+                1
+            ],
+            "translation" : [
+                4.773028194904327e-09,
+                0.13049842417240143,
+                7.307971827685833e-08
+            ]
+        },
+        {
+            "children" : [
+                21
+            ],
+            "name" : "LeftHandIndex3",
+            "rotation" : [
+                0.030971510335803032,
+                -0.03052385337650776,
+                0.0008921303669922054,
+                0.9990537166595459
+            ],
+            "scale" : [
+                0.999999463558197,
+                1.0000001192092896,
+                0.9999999403953552
+            ],
+            "translation" : [
+                0,
+                0.10213042795658112,
+                -5.30388206243515e-07
+            ]
+        },
+        {
+            "children" : [
+                22
+            ],
+            "name" : "LeftHandIndex2",
+            "rotation" : [
+                0.08137369900941849,
+                0.06692241877317429,
+                -0.0006391204078681767,
+                0.9944341778755188
+            ],
+            "scale" : [
+                1,
+                1.0000001192092896,
+                1
+            ],
+            "translation" : [
+                3.6048586338210953e-10,
+                0.11282090097665787,
+                -2.835694772329589e-07
+            ]
+        },
+        {
+            "children" : [
+                23
+            ],
+            "name" : "LeftHandIndex1",
+            "rotation" : [
+                0.05672774836421013,
+                -0.07746566832065582,
+                0.00014866096898913383,
+                0.9953799247741699
+            ],
+            "scale" : [
+                0.9999998211860657,
+                1.0000001192092896,
+                1
+            ],
+            "translation" : [
+                -3.079692234564391e-08,
+                0.13859933614730835,
+                6.95489461577381e-08
+            ]
+        },
+        {
+            "name" : "LeftHandThumb2_end",
+            "rotation" : [
+                7.161870030358841e-07,
+                -3.2559034934820374e-06,
+                1.842155825215741e-06,
+                1
+            ],
+            "scale" : [
+                1.0000001192092896,
+                1.0000001192092896,
+                1
+            ],
+            "translation" : [
+                -9.685754776000977e-08,
+                0.132259339094162,
+                1.4901161193847656e-08
+            ]
+        },
+        {
+            "children" : [
+                25
+            ],
+            "name" : "LeftHandThumb2",
+            "rotation" : [
+                0.2011990249156952,
+                -0.013489622622728348,
+                0.003929006401449442,
+                0.9794496297836304
+            ],
+            "scale" : [
+                0.9999998211860657,
+                0.9999998807907104,
+                1
+            ],
+            "translation" : [
+                1.4901161193847656e-08,
+                0.10586751997470856,
+                -6.146728992462158e-08
+            ]
+        },
+        {
+            "children" : [
+                26
+            ],
+            "name" : "LeftHandThumb1",
+            "rotation" : [
+                -0.3360734283924103,
+                0.6307118535041809,
+                0.4469287395477295,
+                0.5380632877349854
+            ],
+            "scale" : [
+                1.000000238418579,
+                1,
+                1
+            ],
+            "translation" : [
+                -0.06514839082956314,
+                0.050980810075998306,
+                0.0024456013925373554
+            ]
+        },
+        {
+            "children" : [
+                24,
+                27
+            ],
+            "name" : "LeftHand",
+            "rotation" : [
+                -0.02654673345386982,
+                0.7247395515441895,
+                -0.021308565512299538,
+                0.6881815791130066
+            ],
+            "scale" : [
+                1,
+                1.0000001192092896,
+                1
+            ],
+            "translation" : [
+                2.367887645959854e-07,
+                0.5272260904312134,
+                -3.725290298461914e-09
+            ]
+        },
+        {
+            "children" : [
+                28
+            ],
+            "name" : "LeftForeArm",
+            "rotation" : [
+                0.04676171392202377,
+                0.012574327178299427,
+                0.005446834489703178,
+                0.9988120794296265
+            ],
+            "scale" : [
+                0.9999998211860657,
+                1,
+                1.000000238418579
+            ],
+            "translation" : [
+                -3.4744152799248695e-07,
+                0.47077298164367676,
+                4.190951585769653e-09
+            ]
+        },
+        {
+            "children" : [
+                29
+            ],
+            "name" : "LeftArm",
+            "rotation" : [
+                0.0838901549577713,
+                0.7108123898506165,
+                0.06131066381931305,
+                0.695664644241333
+            ],
+            "scale" : [
+                1.0000007152557373,
+                0.9999958276748657,
+                1.0000066757202148
+            ],
+            "translation" : [
+                0,
+                0.25880056619644165,
+                -2.1167215891182423e-07
+            ]
+        },
+        {
+            "children" : [
+                30
+            ],
+            "name" : "LeftShoulder",
+            "rotation" : [
+                -0.5868821144104004,
+                -0.41065308451652527,
+                -0.5482949018478394,
+                0.43163198232650757
+            ],
+            "scale" : [
+                0.9999998211860657,
+                1,
+                1
+            ],
+            "translation" : [
+                0.08827968686819077,
+                0.2810816168785095,
+                0.06496106833219528
+            ]
+        },
+        {
+            "name" : "RightHandIndex3_end",
+            "rotation" : [
+                -1.514141700909022e-08,
+                -1.5126715879887342e-08,
+                1.2847731767351434e-09,
+                1
+            ],
+            "scale" : [
+                0.9999999403953552,
+                1,
+                1
+            ],
+            "translation" : [
+                3.3760443329811096e-09,
+                0.13049854338169098,
+                1.4057877706363797e-07
+            ]
+        },
+        {
+            "children" : [
+                32
+            ],
+            "name" : "RightHandIndex3",
+            "rotation" : [
+                -0.030975427478551865,
+                -0.03052145428955555,
+                -0.0008922049892134964,
+                0.9990536570549011
+            ],
+            "scale" : [
+                0.9999999403953552,
+                1.0000001192092896,
+                0.9999998807907104
+            ],
+            "translation" : [
+                7.471588681084995e-09,
+                0.10213025659322739,
+                -3.2560538443249243e-07
+            ]
+        },
+        {
+            "children" : [
+                33
+            ],
+            "name" : "RightHandIndex2",
+            "rotation" : [
+                -0.08137170225381851,
+                0.06692012399435043,
+                0.0006392838549800217,
+                0.9944344758987427
+            ],
+            "scale" : [
+                1,
+                0.9999996423721313,
+                0.9999998807907104
+            ],
+            "translation" : [
+                2.0489096641540527e-08,
+                0.11282122880220413,
+                5.98374754190445e-08
+            ]
+        },
+        {
+            "children" : [
+                34
+            ],
+            "name" : "RightHandIndex1",
+            "rotation" : [
+                -0.05672965571284294,
+                -0.07746145129203796,
+                -0.0001482291118009016,
+                0.9953801035881042
+            ],
+            "scale" : [
+                1,
+                1,
+                1.000000238418579
+            ],
+            "translation" : [
+                3.7977645916953406e-08,
+                0.1385994255542755,
+                -9.515289889350242e-08
+            ]
+        },
+        {
+            "name" : "RightHandThumb2_end",
+            "rotation" : [
+                1.4230608940124512e-06,
+                4.498288490140112e-06,
+                1.462176555833139e-06,
+                1
+            ],
+            "scale" : [
+                0.9999999403953552,
+                1,
+                0.9999999403953552
+            ],
+            "translation" : [
+                -4.470348358154297e-08,
+                0.13225963711738586,
+                1.4901161193847656e-08
+            ]
+        },
+        {
+            "children" : [
+                36
+            ],
+            "name" : "RightHandThumb2",
+            "rotation" : [
+                -0.1909036785364151,
+                -0.025678735226392746,
+                0.06366036832332611,
+                0.9792056679725647
+            ],
+            "scale" : [
+                0.9999998807907104,
+                0.9999999403953552,
+                0.9999997615814209
+            ],
+            "translation" : [
+                -1.4901161193847656e-07,
+                0.10586771368980408,
+                -1.4156103134155273e-07
+            ]
+        },
+        {
+            "children" : [
+                37
+            ],
+            "name" : "RightHandThumb1",
+            "rotation" : [
+                0.3583732545375824,
+                -0.7295961976051331,
+                0.4292539060115814,
+                0.3936992883682251
+            ],
+            "scale" : [
+                0.9999998807907104,
+                0.9999997615814209,
+                0.9999998211860657
+            ],
+            "translation" : [
+                -0.06391932815313339,
+                0.050981007516384125,
+                -0.012829545885324478
+            ]
+        },
+        {
+            "children" : [
+                35,
+                38
+            ],
+            "name" : "RightHand",
+            "rotation" : [
+                0.008206424303352833,
+                0.00033079335116781294,
+                -0.03303736448287964,
+                0.9994204044342041
+            ],
+            "scale" : [
+                0.9999998211860657,
+                0.9999998807907104,
+                1
+            ],
+            "translation" : [
+                -3.725290298461914e-09,
+                0.5272259712219238,
+                -5.657784640789032e-08
+            ]
+        },
+        {
+            "children" : [
+                39
+            ],
+            "name" : "RightForeArm",
+            "rotation" : [
+                0.0007336858543567359,
+                -0.004767546895891428,
+                0.047072023153305054,
+                0.9988798499107361
+            ],
+            "scale" : [
+                1.0000001192092896,
+                0.9999998807907104,
+                0.9999997615814209
+            ],
+            "translation" : [
+                5.887966558759672e-09,
+                0.47077327966690063,
+                2.4496065975654346e-07
+            ]
+        },
+        {
+            "children" : [
+                40
+            ],
+            "name" : "RightArm",
+            "rotation" : [
+                0.0009364550351165235,
+                -0.9648762941360474,
+                0.10390287637710571,
+                0.24128225445747375
+            ],
+            "scale" : [
+                1.0000067949295044,
+                0.9999957084655762,
+                1.0000011920928955
+            ],
+            "translation" : [
+                3.426094608016683e-08,
+                0.25880059599876404,
+                2.1839389319211477e-07
+            ]
+        },
+        {
+            "children" : [
+                41
+            ],
+            "name" : "RightShoulder",
+            "rotation" : [
+                0.6583799123764038,
+                -0.5076109170913696,
+                0.45999348163604736,
+                0.31188639998435974
+            ],
+            "scale" : [
+                0.9999995827674866,
+                0.9999995231628418,
+                0.9999999403953552
+            ],
+            "translation" : [
+                -0.08827970921993256,
+                0.2810816764831543,
+                0.06496106088161469
+            ]
+        },
+        {
+            "children" : [
+                20,
+                31,
+                42
+            ],
+            "name" : "UpperChest",
+            "rotation" : [
+                0.0491657592356205,
+                2.674357957310747e-10,
+                -6.23675347477537e-11,
+                0.9987906813621521
+            ],
+            "scale" : [
+                1,
+                0.9999999403953552,
+                1.0000001192092896
+            ],
+            "translation" : [
+                2.1510883352338084e-12,
+                0.305276483297348,
+                1.1175486314130012e-08
+            ]
+        },
+        {
+            "children" : [
+                43
+            ],
+            "name" : "Chest",
+            "rotation" : [
+                0.011894624680280685,
+                1.0085403623349976e-08,
+                1.1045127479292205e-08,
+                0.9999292492866516
+            ],
+            "scale" : [
+                1,
+                1,
+                0.9999998211860657
+            ],
+            "translation" : [
+                2.1854787077280058e-11,
+                0.28704869747161865,
+                3.379044244411489e-08
+            ]
+        },
+        {
+            "children" : [
+                44
+            ],
+            "name" : "Spine",
+            "rotation" : [
+                -0.06104256585240364,
+                -1.0930059524127955e-08,
+                -1.0441144837614047e-08,
+                0.9981352090835571
+            ],
+            "scale" : [
+                1.0000040531158447,
+                0.9999998211860657,
+                1.0000001192092896
+            ],
+            "translation" : [
+                -1.3281885357166456e-12,
+                0.3219517171382904,
+                -7.401257384742621e-10
+            ]
+        },
+        {
+            "name" : "LeftToes_end",
+            "rotation" : [
+                -6.897608262335098e-09,
+                -1.5718733266112395e-06,
+                1.0501594260858838e-08,
+                1
+            ],
+            "scale" : [
+                1,
+                0.9999999403953552,
+                1
+            ],
+            "translation" : [
+                -1.219996192958206e-08,
+                0.21323668956756592,
+                6.984919309616089e-10
+            ]
+        },
+        {
+            "children" : [
+                46
+            ],
+            "name" : "LeftToes",
+            "rotation" : [
+                -0.019816284999251366,
+                0.952286958694458,
+                -0.29825514554977417,
+                0.06165122613310814
+            ],
+            "scale" : [
+                0.9999998807907104,
+                0.9999998807907104,
+                1
+            ],
+            "translation" : [
+                -1.7792441298070116e-08,
+                0.30125415325164795,
+                -6.15441742013445e-09
+            ]
+        },
+        {
+            "children" : [
+                47
+            ],
+            "name" : "LeftFoot",
+            "rotation" : [
+                -0.5438073873519897,
+                -0.19418132305145264,
+                -0.1875459998846054,
+                0.7946028709411621
+            ],
+            "scale" : [
+                1.0000202655792236,
+                0.9999834895133972,
+                0.9999954104423523
+            ],
+            "translation" : [
+                1.4435499906539917e-08,
+                0.608812153339386,
+                -6.213667802512646e-09
+            ]
+        },
+        {
+            "children" : [
+                48
+            ],
+            "name" : "LeftLeg",
+            "rotation" : [
+                0.14157429337501526,
+                0.03244359791278839,
+                0.05285508558154106,
+                0.9879830479621887
+            ],
+            "scale" : [
+                0.9999995231628418,
+                0.9999991655349731,
+                1.000002145767212
+            ],
+            "translation" : [
+                4.0745362639427185e-10,
+                0.5261742472648621,
+                1.5133991837501526e-09
+            ]
+        },
+        {
+            "children" : [
+                49
+            ],
+            "name" : "LeftUpLeg",
+            "rotation" : [
+                0.9867032170295715,
+                0.001059696078300476,
+                0.16252805292606354,
+                0.0006704009720124304
+            ],
+            "scale" : [
+                1.0000277757644653,
+                0.9999996423721313,
+                1.0000001192092896
+            ],
+            "translation" : [
+                0.20152832567691803,
+                0.05846330150961876,
+                7.484280217795458e-08
+            ]
+        },
+        {
+            "name" : "RightToes_end",
+            "rotation" : [
+                -6.219488568603992e-08,
+                -4.0326270323021163e-07,
+                -4.343747139756715e-09,
+                1
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999998807907104,
+                1
+            ],
+            "translation" : [
+                3.6852725315839052e-09,
+                0.21323607861995697,
+                2.3283064365386963e-10
+            ]
+        },
+        {
+            "children" : [
+                51
+            ],
+            "name" : "RightToes",
+            "rotation" : [
+                -0.028261758387088776,
+                -0.9539412260055542,
+                0.2975737154483795,
+                0.025444308295845985
+            ],
+            "scale" : [
+                0.9999998211860657,
+                1,
+                1
+            ],
+            "translation" : [
+                1.624374768027792e-08,
+                0.30125439167022705,
+                -1.4761256217354912e-08
+            ]
+        },
+        {
+            "children" : [
+                52
+            ],
+            "name" : "RightFoot",
+            "rotation" : [
+                -0.5484951734542847,
+                0.228828564286232,
+                0.17182011902332306,
+                0.7856643199920654
+            ],
+            "scale" : [
+                0.9999948740005493,
+                1.0000035762786865,
+                1.0000011920928955
+            ],
+            "translation" : [
+                1.9907020032405853e-08,
+                0.6088116765022278,
+                -5.282345227897167e-09
+            ]
+        },
+        {
+            "children" : [
+                53
+            ],
+            "name" : "RightLeg",
+            "rotation" : [
+                0.13894768059253693,
+                0.01151115819811821,
+                -0.05917293205857277,
+                0.988463282585144
+            ],
+            "scale" : [
+                0.9999990463256836,
+                1.000000238418579,
+                0.9999998807907104
+            ],
+            "translation" : [
+                3.026798367500305e-09,
+                0.5261741280555725,
+                -5.587935447692871e-09
+            ]
+        },
+        {
+            "children" : [
+                54
+            ],
+            "name" : "RightUpLeg",
+            "rotation" : [
+                0.9765874147415161,
+                -0.0013587353751063347,
+                -0.21511615812778473,
+                0.00048400997184216976
+            ],
+            "scale" : [
+                0.9999951124191284,
+                0.9999997019767761,
+                0.9999991655349731
+            ],
+            "translation" : [
+                -0.20152829587459564,
+                0.05846330150961876,
+                7.381081701396397e-08
+            ]
+        },
+        {
+            "children" : [
+                45,
+                50,
+                55
+            ],
+            "name" : "Hips",
+            "rotation" : [
+                9.301415411755443e-05,
+                -2.667252942956111e-07,
+                0.9999990463256836,
+                0.0014431028394028544
+            ],
+            "scale" : [
+                1.0000041723251343,
+                1,
+                0.9999999403953552
+            ],
+            "translation" : [
+                0.0004645993176382035,
+                0.3219510316848755,
+                -4.877409409687061e-08
+            ]
+        },
+        {
+            "children" : [
+                56
+            ],
+            "name" : "HipsCtrl",
+            "rotation" : [
+                9.30154710658826e-05,
+                -8.257158867763792e-08,
+                0.9999989867210388,
+                -0.001443103072233498
+            ],
+            "scale" : [
+                0.9999999403953552,
+                1,
+                1
+            ],
+            "translation" : [
+                -0.00022340929717756808,
+                1.564172387123108,
+                0.031240252777934074
+            ]
+        },
+        {
+            "mesh" : 0,
+            "name" : "characterMedium",
+            "skin" : 0
+        },
+        {
+            "children" : [
+                58,
+                8,
+                17,
+                57
+            ],
+            "name" : "Root"
+        }
+    ],
+    "materials" : [
+        {
+            "doubleSided" : true,
+            "emissiveFactor" : [
+                0,
+                0,
+                0
+            ],
+            "name" : "skin",
+            "pbrMetallicRoughness" : {
+                "baseColorFactor" : [
+                    0.800000011920929,
+                    0.800000011920929,
+                    0.800000011920929,
+                    1
+                ],
+                "metallicFactor" : 0,
+                "roughnessFactor" : 0.690034806728363
+            }
+        }
+    ],
+    "meshes" : [
+        {
+            "name" : "characterMedium",
+            "primitives" : [
+                {
+                    "attributes" : {
+                        "POSITION" : 0,
+                        "NORMAL" : 1,
+                        "TEXCOORD_0" : 2,
+                        "COLOR_0" : 3,
+                        "JOINTS_0" : 4,
+                        "WEIGHTS_0" : 5
+                    },
+                    "indices" : 6,
+                    "material" : 0
+                }
+            ]
+        }
+    ],
+    "skins" : [
+        {
+            "inverseBindMatrices" : 7,
+            "joints" : [
+                8,
+                3,
+                2,
+                1,
+                0,
+                5,
+                4,
+                7,
+                6,
+                17,
+                12,
+                11,
+                10,
+                9,
+                14,
+                13,
+                16,
+                15,
+                57,
+                56,
+                45,
+                44,
+                43,
+                20,
+                19,
+                18,
+                31,
+                30,
+                29,
+                28,
+                24,
+                23,
+                22,
+                21,
+                27,
+                26,
+                25,
+                42,
+                41,
+                40,
+                39,
+                35,
+                34,
+                33,
+                32,
+                38,
+                37,
+                36,
+                50,
+                49,
+                48,
+                47,
+                46,
+                55,
+                54,
+                53,
+                52,
+                51
+            ],
+            "name" : "Root"
+        }
+    ],
+    "accessors" : [
+        {
+            "bufferView" : 0,
+            "componentType" : 5126,
+            "count" : 1029,
+            "max" : [
+                1.809532642364502,
+                3.7653701305389404,
+                0.514235258102417
+            ],
+            "min" : [
+                -1.80905020236969,
+                0.0006840709247626364,
+                -0.5339085459709167
+            ],
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 1,
+            "componentType" : 5126,
+            "count" : 1029,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 2,
+            "componentType" : 5126,
+            "count" : 1029,
+            "type" : "VEC2"
+        },
+        {
+            "bufferView" : 3,
+            "componentType" : 5126,
+            "count" : 1029,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 4,
+            "componentType" : 5123,
+            "count" : 1029,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 5,
+            "componentType" : 5126,
+            "count" : 1029,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 6,
+            "componentType" : 5123,
+            "count" : 4812,
+            "type" : "SCALAR"
+        },
+        {
+            "bufferView" : 7,
+            "componentType" : 5126,
+            "count" : 58,
+            "type" : "MAT4"
+        }
+    ],
+    "bufferViews" : [
+        {
+            "buffer" : 0,
+            "byteLength" : 12348,
+            "byteOffset" : 0
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 12348,
+            "byteOffset" : 12348
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 8232,
+            "byteOffset" : 24696
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 16464,
+            "byteOffset" : 32928
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 8232,
+            "byteOffset" : 49392
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 16464,
+            "byteOffset" : 57624
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 9624,
+            "byteOffset" : 74088
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 3712,
+            "byteOffset" : 83712
+        }
+    ],
+    "buffers" : [
+        {
+            "byteLength" : 87424,
+            "uri" : "data:application/octet-stream;base64,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"
+        }
+    ]
+}
diff --git a/assets/models/character_medium/idle.gltf b/assets/models/character_medium/idle.gltf
new file mode 100644
index 0000000000000..b737c262cf0cf
--- /dev/null
+++ b/assets/models/character_medium/idle.gltf
@@ -0,0 +1,5319 @@
+{
+    "asset" : {
+        "generator" : "Khronos glTF Blender I/O v1.2.75",
+        "version" : "2.0"
+    },
+    "scene" : 0,
+    "scenes" : [
+        {
+            "name" : "Scene",
+            "nodes" : [
+                58
+            ]
+        }
+    ],
+    "nodes" : [
+        {
+            "name" : "LeftFootIK_end",
+            "rotation" : [
+                -2.7939673685750677e-08,
+                -4.1350719470756303e-07,
+                2.220446049250313e-16,
+                1
+            ],
+            "scale" : [
+                1,
+                1.0000001192092896,
+                1.0000001192092896
+            ],
+            "translation" : [
+                -3.934837877750397e-08,
+                0.3012542426586151,
+                -1.955777406692505e-08
+            ]
+        },
+        {
+            "children" : [
+                0
+            ],
+            "name" : "LeftFootIK",
+            "rotation" : [
+                -0.9461288452148438,
+                0.021870823577046394,
+                -0.07550253719091415,
+                0.31410375237464905
+            ],
+            "scale" : [
+                0.9999998807907104,
+                1,
+                1.0000001192092896
+            ],
+            "translation" : [
+                -0.0018214269075542688,
+                0.24152173101902008,
+                0.18005003035068512
+            ]
+        },
+        {
+            "children" : [
+                1
+            ],
+            "name" : "LeftToeRoll",
+            "rotation" : [
+                -0.015735773369669914,
+                0.0020797578617930412,
+                -0.9946247339248657,
+                0.10232114046812057
+            ],
+            "scale" : [
+                1.0000057220458984,
+                1.0000001192092896,
+                1
+            ],
+            "translation" : [
+                -0.02866431325674057,
+                0.30693289637565613,
+                0.0010425348300486803
+            ]
+        },
+        {
+            "children" : [
+                2
+            ],
+            "name" : "LeftHeelRoll",
+            "rotation" : [
+                0.5075123310089111,
+                -0.5082277655601501,
+                0.4919067323207855,
+                0.49210116267204285
+            ],
+            "translation" : [
+                0.07085254788398743,
+                0.17990142107009888,
+                -0.022240448743104935
+            ]
+        },
+        {
+            "name" : "LeftFootRollCtrl_end",
+            "rotation" : [
+                5.156953530871533e-09,
+                4.1370483927494206e-08,
+                5.960465898624534e-08,
+                1
+            ],
+            "translation" : [
+                -5.856242601964823e-09,
+                0.2927667796611786,
+                1.4789018010219479e-08
+            ]
+        },
+        {
+            "children" : [
+                4
+            ],
+            "name" : "LeftFootRollCtrl",
+            "rotation" : [
+                0.5,
+                0.4999999403953552,
+                -0.4999999403953552,
+                0.5000001192092896
+            ],
+            "translation" : [
+                1.9318052935091146e-08,
+                -1.1766196905682591e-07,
+                -3.6953171078657476e-10
+            ]
+        },
+        {
+            "name" : "LeftKneeCtrl_end",
+            "rotation" : [
+                6.782003936223191e-08,
+                7.450587702351186e-09,
+                3.253829206073533e-09,
+                1
+            ],
+            "translation" : [
+                9.239116138815007e-09,
+                0.3368157744407654,
+                5.068936559382564e-08
+            ]
+        },
+        {
+            "children" : [
+                6
+            ],
+            "name" : "LeftKneeCtrl",
+            "rotation" : [
+                0.7071069478988647,
+                5.865616437006338e-09,
+                -0.7071065902709961,
+                -5.8656177692739675e-09
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999998211860657,
+                0.9999999403953552
+            ],
+            "translation" : [
+                -0.6179578304290771,
+                -0.5867006778717041,
+                0.025887062773108482
+            ]
+        },
+        {
+            "children" : [
+                3,
+                5,
+                7
+            ],
+            "name" : "LeftFootCtrl",
+            "rotation" : [
+                -0.6058326959609985,
+                1.0412455964114997e-07,
+                0.7955920696258545,
+                -2.1813370665313414e-08
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999997615814209,
+                0.9999998807907104
+            ],
+            "translation" : [
+                0.20420880615711212,
+                0.1932048201560974,
+                -0.14880996942520142
+            ]
+        },
+        {
+            "name" : "RightFootIK_end",
+            "rotation" : [
+                4.7963112592697144e-08,
+                1.8440186977386475e-07,
+                0,
+                1
+            ],
+            "translation" : [
+                -1.1408701539039612e-08,
+                0.3012544512748718,
+                -3.725290298461914e-09
+            ]
+        },
+        {
+            "children" : [
+                9
+            ],
+            "name" : "RightFootIK",
+            "rotation" : [
+                -0.9481120109558105,
+                -0.011444996111094952,
+                0.04409310221672058,
+                0.31465622782707214
+            ],
+            "scale" : [
+                0.9999998807907104,
+                0.9999999403953552,
+                0.9999997615814209
+            ],
+            "translation" : [
+                0.0018214818555861712,
+                0.24152179062366486,
+                0.18005000054836273
+            ]
+        },
+        {
+            "children" : [
+                10
+            ],
+            "name" : "RightToeRoll",
+            "rotation" : [
+                0.015675298869609833,
+                0.0011522267013788223,
+                0.9946256875991821,
+                0.10233629494905472
+            ],
+            "scale" : [
+                1.0000040531158447,
+                1,
+                1
+            ],
+            "translation" : [
+                0.028672894462943077,
+                0.3069329559803009,
+                -0.0007686819299124181
+            ]
+        },
+        {
+            "children" : [
+                11
+            ],
+            "name" : "RightHeelRoll",
+            "rotation" : [
+                0.5076853632926941,
+                -0.5079019069671631,
+                0.4917282164096832,
+                0.49243754148483276
+            ],
+            "scale" : [
+                0.9999998807907104,
+                0.9999998807907104,
+                1
+            ],
+            "translation" : [
+                0.0708526000380516,
+                0.1799013763666153,
+                0.0222404133528471
+            ]
+        },
+        {
+            "name" : "RightFootRollCtrl_end",
+            "rotation" : [
+                6.05117520535714e-08,
+                3.153171235226182e-08,
+                -2.980230462412692e-08,
+                1
+            ],
+            "translation" : [
+                -4.356808247507615e-09,
+                0.292766809463501,
+                3.1849591408672495e-08
+            ]
+        },
+        {
+            "children" : [
+                13
+            ],
+            "name" : "RightFootRollCtrl",
+            "rotation" : [
+                0.5000001192092896,
+                0.4999999701976776,
+                -0.49999985098838806,
+                0.5000002384185791
+            ],
+            "translation" : [
+                -2.8933051510193764e-09,
+                -1.796718152036192e-07,
+                -5.058877206032264e-10
+            ]
+        },
+        {
+            "name" : "RightKneeCtrl_end",
+            "rotation" : [
+                -3.299455642036264e-08,
+                5.587932783157612e-09,
+                -5.141259862284642e-09,
+                1
+            ],
+            "translation" : [
+                -4.732150671316049e-09,
+                0.33681580424308777,
+                7.909009269724265e-08
+            ]
+        },
+        {
+            "children" : [
+                15
+            ],
+            "name" : "RightKneeCtrl",
+            "rotation" : [
+                0.7071070671081543,
+                -6.036728450453666e-08,
+                -0.7071065902709961,
+                -7.233501975179024e-08
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999998211860657,
+                0.9999999403953552
+            ],
+            "translation" : [
+                -0.6179578900337219,
+                -0.5867008566856384,
+                -0.02919832244515419
+            ]
+        },
+        {
+            "children" : [
+                12,
+                14,
+                16
+            ],
+            "name" : "RightFootCtrl",
+            "rotation" : [
+                0.7461758852005005,
+                -6.915196593126893e-08,
+                -0.6657488942146301,
+                -2.4155694333671818e-08
+            ],
+            "scale" : [
+                0.9999998807907104,
+                0.9999998211860657,
+                0.9999998211860657
+            ],
+            "translation" : [
+                -0.2075204849243164,
+                0.19320480525493622,
+                0.030460702255368233
+            ]
+        },
+        {
+            "name" : "Head_end",
+            "rotation" : [
+                2.9802318834981634e-08,
+                2.4961359486042056e-06,
+                4.6363002326188507e-10,
+                1
+            ],
+            "translation" : [
+                -7.767084753140807e-10,
+                1.0044056177139282,
+                1.1043101721952553e-07
+            ]
+        },
+        {
+            "children" : [
+                18
+            ],
+            "name" : "Head",
+            "rotation" : [
+                -0.10882600396871567,
+                0.04372953623533249,
+                -0.010362982749938965,
+                0.9930444359779358
+            ],
+            "scale" : [
+                0.9999999403953552,
+                1,
+                1
+            ],
+            "translation" : [
+                -2.1974935648927385e-08,
+                0.2780052423477173,
+                9.870334594097585e-08
+            ]
+        },
+        {
+            "children" : [
+                19
+            ],
+            "name" : "Neck",
+            "rotation" : [
+                0.0766126811504364,
+                3.3859963721738495e-09,
+                5.83792403308081e-10,
+                0.9970609545707703
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999999403953552,
+                0.9999998807907104
+            ],
+            "translation" : [
+                3.026798367500305e-09,
+                0.27086231112480164,
+                1.5309220557924164e-08
+            ]
+        },
+        {
+            "name" : "LeftHandIndex3_end",
+            "rotation" : [
+                -2.421438694000244e-08,
+                1.8040882423520088e-06,
+                -7.002381607890129e-08,
+                1
+            ],
+            "translation" : [
+                6.984919309616089e-10,
+                0.13049866259098053,
+                4.470348358154297e-08
+            ]
+        },
+        {
+            "children" : [
+                21
+            ],
+            "name" : "LeftHandIndex3",
+            "rotation" : [
+                0.41093507409095764,
+                -0.027863040566444397,
+                0.012506107799708843,
+                0.9111528992652893
+            ],
+            "scale" : [
+                0.9999998807907104,
+                1,
+                1
+            ],
+            "translation" : [
+                -5.075708031654358e-08,
+                0.10213052481412888,
+                -4.842877388000488e-08
+            ]
+        },
+        {
+            "children" : [
+                22
+            ],
+            "name" : "LeftHandIndex2",
+            "rotation" : [
+                0.7716672420501709,
+                0.04664381965994835,
+                0.0019650054164230824,
+                0.6343109011650085
+            ],
+            "scale" : [
+                1,
+                0.9999999403953552,
+                0.9999999403953552
+            ],
+            "translation" : [
+                7.450580596923828e-09,
+                0.155512273311615,
+                -7.264316082000732e-08
+            ]
+        },
+        {
+            "children" : [
+                23
+            ],
+            "name" : "LeftHandIndex1",
+            "rotation" : [
+                0.01625003106892109,
+                -0.0775846317410469,
+                4.2538191337371245e-05,
+                0.9968533515930176
+            ],
+            "scale" : [
+                1,
+                0.9999999403953552,
+                0.9999998807907104
+            ],
+            "translation" : [
+                1.4899119271660766e-08,
+                0.09553961455821991,
+                6.44536655158845e-08
+            ]
+        },
+        {
+            "name" : "LeftHandThumb2_end",
+            "rotation" : [
+                -3.5529956221580505e-07,
+                -3.2186508178710938e-06,
+                -1.6577541828155518e-07,
+                1
+            ],
+            "translation" : [
+                0,
+                0.13152235746383667,
+                -1.4901161193847656e-08
+            ]
+        },
+        {
+            "children" : [
+                25
+            ],
+            "name" : "LeftHandThumb2",
+            "rotation" : [
+                0.6606285572052002,
+                -0.07544834911823273,
+                0.11934629827737808,
+                0.7373154163360596
+            ],
+            "scale" : [
+                1.0000001192092896,
+                0.9999998807907104,
+                0.9999999403953552
+            ],
+            "translation" : [
+                -7.450580596923828e-08,
+                0.10601531714200974,
+                4.470348358154297e-08
+            ]
+        },
+        {
+            "children" : [
+                26
+            ],
+            "name" : "LeftHandThumb1",
+            "rotation" : [
+                -0.21305054426193237,
+                0.6950411200523376,
+                0.3584302067756653,
+                0.5857090950012207
+            ],
+            "scale" : [
+                0.9999998807907104,
+                1.0000001192092896,
+                1
+            ],
+            "translation" : [
+                -0.09356530755758286,
+                0.0682639479637146,
+                0.012918964959681034
+            ]
+        },
+        {
+            "children" : [
+                24,
+                27
+            ],
+            "name" : "LeftHand",
+            "rotation" : [
+                -0.01508378516882658,
+                0.7243562936782837,
+                -0.03157876431941986,
+                0.6885371208190918
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999999403953552,
+                0.9999999403953552
+            ],
+            "translation" : [
+                2.3283064365386963e-08,
+                0.5272260904312134,
+                -5.960464477539063e-08
+            ]
+        },
+        {
+            "children" : [
+                28
+            ],
+            "name" : "LeftForeArm",
+            "rotation" : [
+                0.35119718313217163,
+                -0.0730518326163292,
+                -0.0707712173461914,
+                0.9307606816291809
+            ],
+            "translation" : [
+                5.634501576423645e-08,
+                0.4707694351673126,
+                -5.820766091346741e-09
+            ]
+        },
+        {
+            "children" : [
+                29
+            ],
+            "name" : "LeftArm",
+            "rotation" : [
+                -0.3596045970916748,
+                0.6730210781097412,
+                -0.24034574627876282,
+                0.5999675989151001
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999998211860657,
+                0.9999998807907104
+            ],
+            "translation" : [
+                4.6566128730773926e-08,
+                0.2588014602661133,
+                1.7881393432617188e-07
+            ]
+        },
+        {
+            "children" : [
+                30
+            ],
+            "name" : "LeftShoulder",
+            "rotation" : [
+                -0.5976499915122986,
+                -0.395496666431427,
+                -0.5656543970108032,
+                0.4079608917236328
+            ],
+            "scale" : [
+                0.9999997019767761,
+                0.9999998807907104,
+                0.9999998807907104
+            ],
+            "translation" : [
+                0.08827995508909225,
+                0.2810768187046051,
+                0.06495606899261475
+            ]
+        },
+        {
+            "name" : "RightHandIndex3_end",
+            "rotation" : [
+                -9.033828973770142e-08,
+                1.8373249304204364e-06,
+                -4.687172250328331e-08,
+                1
+            ],
+            "scale" : [
+                0.9999998807907104,
+                1,
+                1
+            ],
+            "translation" : [
+                5.745096132159233e-08,
+                0.13049884140491486,
+                6.705522537231445e-08
+            ]
+        },
+        {
+            "children" : [
+                32
+            ],
+            "name" : "RightHandIndex3",
+            "rotation" : [
+                -0.4109368920326233,
+                -0.027861490845680237,
+                -0.012504566460847855,
+                0.911152184009552
+            ],
+            "scale" : [
+                0.9999998807907104,
+                1,
+                1
+            ],
+            "translation" : [
+                3.8387952372431755e-08,
+                0.10213036835193634,
+                -6.845220923423767e-08
+            ]
+        },
+        {
+            "children" : [
+                33
+            ],
+            "name" : "RightHandIndex2",
+            "rotation" : [
+                -0.7474005222320557,
+                0.04220942035317421,
+                0.00765560008585453,
+                0.6629874110221863
+            ],
+            "scale" : [
+                0.9999999403953552,
+                1,
+                0.9999998807907104
+            ],
+            "translation" : [
+                -2.60770320892334e-08,
+                0.15551209449768066,
+                1.955777406692505e-08
+            ]
+        },
+        {
+            "children" : [
+                34
+            ],
+            "name" : "RightHandIndex1",
+            "rotation" : [
+                -0.016250334680080414,
+                -0.07758451253175735,
+                -4.2504441807977855e-05,
+                0.9968533515930176
+            ],
+            "scale" : [
+                1.0000001192092896,
+                1,
+                1
+            ],
+            "translation" : [
+                -4.101877948414767e-08,
+                0.09553945809602737,
+                1.8840282667298425e-09
+            ]
+        },
+        {
+            "name" : "RightHandThumb2_end",
+            "rotation" : [
+                -1.8347054719924927e-07,
+                1.1380761861801147e-06,
+                -1.5366822481155396e-07,
+                1
+            ],
+            "scale" : [
+                1,
+                0.9999998807907104,
+                1.0000001192092896
+            ],
+            "translation" : [
+                2.9802322387695312e-08,
+                0.13152271509170532,
+                1.4901161193847656e-08
+            ]
+        },
+        {
+            "children" : [
+                36
+            ],
+            "name" : "RightHandThumb2",
+            "rotation" : [
+                -0.5951220393180847,
+                0.045914698392152786,
+                0.31064850091934204,
+                0.7397425770759583
+            ],
+            "scale" : [
+                1,
+                1.0000001192092896,
+                1
+            ],
+            "translation" : [
+                -2.9802322387695312e-08,
+                0.10601511597633362,
+                5.21540641784668e-08
+            ]
+        },
+        {
+            "children" : [
+                37
+            ],
+            "name" : "RightHandThumb1",
+            "rotation" : [
+                0.2310098260641098,
+                -0.8024979829788208,
+                0.3471252918243408,
+                0.4267735481262207
+            ],
+            "scale" : [
+                1,
+                1.000000238418579,
+                1
+            ],
+            "translation" : [
+                -0.09029583632946014,
+                0.06826385855674744,
+                -0.02771192416548729
+            ]
+        },
+        {
+            "children" : [
+                35,
+                38
+            ],
+            "name" : "RightHand",
+            "rotation" : [
+                -0.010813283734023571,
+                0.10929541289806366,
+                -0.0332837775349617,
+                0.993393063545227
+            ],
+            "scale" : [
+                1.0000001192092896,
+                0.9999999403953552,
+                0.9999998211860657
+            ],
+            "translation" : [
+                7.450580596923828e-09,
+                0.5272266268730164,
+                -7.450580596923828e-09
+            ]
+        },
+        {
+            "children" : [
+                39
+            ],
+            "name" : "RightForeArm",
+            "rotation" : [
+                -0.06782904267311096,
+                -0.021085543558001518,
+                0.3517768085002899,
+                0.9333850741386414
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999999403953552,
+                1
+            ],
+            "translation" : [
+                1.862645149230957e-08,
+                0.4707683324813843,
+                5.005858838558197e-08
+            ]
+        },
+        {
+            "children" : [
+                40
+            ],
+            "name" : "RightArm",
+            "rotation" : [
+                -0.0473024919629097,
+                -0.9062519669532776,
+                -0.40121355652809143,
+                0.1244896650314331
+            ],
+            "scale" : [
+                1,
+                1.000000238418579,
+                1
+            ],
+            "translation" : [
+                -1.30385160446167e-08,
+                0.25880008935928345,
+                2.4586915969848633e-07
+            ]
+        },
+        {
+            "children" : [
+                41
+            ],
+            "name" : "RightShoulder",
+            "rotation" : [
+                0.6781948208808899,
+                -0.4857138395309448,
+                0.46351271867752075,
+                0.2988140881061554
+            ],
+            "scale" : [
+                0.9999998211860657,
+                0.9999998211860657,
+                0.9999998211860657
+            ],
+            "translation" : [
+                -0.08827994763851166,
+                0.2810775339603424,
+                0.06495895981788635
+            ]
+        },
+        {
+            "children" : [
+                20,
+                31,
+                42
+            ],
+            "name" : "UpperChest",
+            "rotation" : [
+                0.09408915787935257,
+                -2.6778632218338316e-06,
+                2.5570813022568473e-07,
+                0.995563805103302
+            ],
+            "scale" : [
+                1,
+                1.0000001192092896,
+                0.9999998807907104
+            ],
+            "translation" : [
+                5.821627208080216e-11,
+                0.30527591705322266,
+                1.4457802954837007e-08
+            ]
+        },
+        {
+            "children" : [
+                43
+            ],
+            "name" : "Chest",
+            "rotation" : [
+                0.06234464421868324,
+                -0.04485286399722099,
+                -0.0028046409133821726,
+                0.9970424175262451
+            ],
+            "scale" : [
+                1,
+                0.9999998807907104,
+                1
+            ],
+            "translation" : [
+                1.522004744458627e-11,
+                0.2870490252971649,
+                1.967896956500681e-08
+            ]
+        },
+        {
+            "children" : [
+                44
+            ],
+            "name" : "Spine",
+            "rotation" : [
+                -0.004366202745586634,
+                -6.437847588358636e-08,
+                -1.1777818720304367e-08,
+                0.9999904632568359
+            ],
+            "scale" : [
+                1,
+                1.000000238418579,
+                1.000000238418579
+            ],
+            "translation" : [
+                1.557099067739376e-11,
+                0.32195162773132324,
+                -9.809690837414564e-09
+            ]
+        },
+        {
+            "name" : "LeftToes_end",
+            "rotation" : [
+                -1.9441358745098114e-08,
+                -1.3365934137254953e-07,
+                -3.3136533517108546e-08,
+                1
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999999403953552,
+                1
+            ],
+            "translation" : [
+                5.630863597616553e-08,
+                0.21322478353977203,
+                -2.7939677238464355e-09
+            ]
+        },
+        {
+            "children" : [
+                46
+            ],
+            "name" : "LeftToes",
+            "rotation" : [
+                -0.019816625863313675,
+                0.9522837996482849,
+                -0.2982637286186218,
+                0.06165876239538193
+            ],
+            "scale" : [
+                0.9999998807907104,
+                0.9999998211860657,
+                1
+            ],
+            "translation" : [
+                2.130400389432907e-08,
+                0.3012455105781555,
+                -7.450580596923828e-09
+            ]
+        },
+        {
+            "children" : [
+                47
+            ],
+            "name" : "LeftFoot",
+            "rotation" : [
+                -0.6605456471443176,
+                -0.15921947360038757,
+                -0.15747502446174622,
+                0.7166102528572083
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999998211860657,
+                0.9999998807907104
+            ],
+            "translation" : [
+                1.979060471057892e-08,
+                0.6087971925735474,
+                -3.818422555923462e-08
+            ]
+        },
+        {
+            "children" : [
+                48
+            ],
+            "name" : "LeftLeg",
+            "rotation" : [
+                0.34589260816574097,
+                0.030488573014736176,
+                0.1291443556547165,
+                0.9288437366485596
+            ],
+            "scale" : [
+                0.9999998807907104,
+                1,
+                0.9999998211860657
+            ],
+            "translation" : [
+                1.3504177331924438e-08,
+                0.526174008846283,
+                -9.66247171163559e-09
+            ]
+        },
+        {
+            "children" : [
+                49
+            ],
+            "name" : "LeftUpLeg",
+            "rotation" : [
+                0.996600329875946,
+                0.06889443844556808,
+                -0.0027433151844888926,
+                0.04509713128209114
+            ],
+            "scale" : [
+                0.9999945163726807,
+                0.9999999403953552,
+                0.9999979138374329
+            ],
+            "translation" : [
+                0.2015291154384613,
+                0.05846351385116577,
+                -1.1631419738478144e-06
+            ]
+        },
+        {
+            "name" : "RightToes_end",
+            "rotation" : [
+                2.6621815862881704e-08,
+                -2.944761661183293e-07,
+                -5.4293188611609366e-08,
+                1
+            ],
+            "scale" : [
+                1.0000001192092896,
+                1.0000001192092896,
+                1.0000001192092896
+            ],
+            "translation" : [
+                2.5756889954209328e-08,
+                0.21322453022003174,
+                1.5352270565927029e-09
+            ]
+        },
+        {
+            "children" : [
+                51
+            ],
+            "name" : "RightToes",
+            "rotation" : [
+                -0.028258174657821655,
+                -0.9539381861686707,
+                0.2975830137729645,
+                0.025454718619585037
+            ],
+            "scale" : [
+                0.9999998807907104,
+                0.9999996423721313,
+                0.9999998211860657
+            ],
+            "translation" : [
+                -1.4784745872020721e-08,
+                0.3012455999851227,
+                -2.0489096641540527e-08
+            ]
+        },
+        {
+            "children" : [
+                52
+            ],
+            "name" : "RightFoot",
+            "rotation" : [
+                -0.6176005601882935,
+                0.2186020314693451,
+                0.1719917505979538,
+                0.7356640696525574
+            ],
+            "scale" : [
+                1,
+                1.0000001192092896,
+                1
+            ],
+            "translation" : [
+                -3.818422555923462e-08,
+                0.6088014245033264,
+                -1.862645149230957e-09
+            ]
+        },
+        {
+            "children" : [
+                53
+            ],
+            "name" : "RightLeg",
+            "rotation" : [
+                0.3914288282394409,
+                0.010524001903831959,
+                -0.16669818758964539,
+                0.904922366142273
+            ],
+            "scale" : [
+                1,
+                1.0000001192092896,
+                0.9999998211860657
+            ],
+            "translation" : [
+                -2.9802322387695312e-08,
+                0.526171088218689,
+                1.4901161193847656e-08
+            ]
+        },
+        {
+            "children" : [
+                54
+            ],
+            "name" : "RightUpLeg",
+            "rotation" : [
+                0.9727374911308289,
+                -0.054324571043252945,
+                -0.15229658782482147,
+                0.1662418097257614
+            ],
+            "scale" : [
+                1,
+                1.0000001192092896,
+                0.9999991655349731
+            ],
+            "translation" : [
+                -0.2015291005373001,
+                0.05846370756626129,
+                1.379328637085564e-06
+            ]
+        },
+        {
+            "children" : [
+                45,
+                50,
+                55
+            ],
+            "name" : "Hips",
+            "rotation" : [
+                5.4410316806752235e-05,
+                -0.027773253619670868,
+                0.9996132254600525,
+                0.0014451154274865985
+            ],
+            "scale" : [
+                1.0000001192092896,
+                1.0000003576278687,
+                1.0000618696212769
+            ],
+            "translation" : [
+                0.00046459940494969487,
+                0.3219509422779083,
+                -5.964777471945126e-08
+            ]
+        },
+        {
+            "children" : [
+                56
+            ],
+            "name" : "HipsCtrl",
+            "rotation" : [
+                9.298329678131267e-05,
+                -1.0748256329407013e-07,
+                0.9999989867210388,
+                -0.0014432227471843362
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999999403953552,
+                0.9999999403953552
+            ],
+            "translation" : [
+                -4.991561218048446e-05,
+                1.4820566177368164,
+                0.10399980843067169
+            ]
+        },
+        {
+            "children" : [
+                8,
+                17,
+                57
+            ],
+            "name" : "Root"
+        }
+    ],
+    "animations" : [
+        {
+            "channels" : [
+                {
+                    "sampler" : 0,
+                    "target" : {
+                        "node" : 8,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 1,
+                    "target" : {
+                        "node" : 8,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 2,
+                    "target" : {
+                        "node" : 8,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 3,
+                    "target" : {
+                        "node" : 3,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 4,
+                    "target" : {
+                        "node" : 3,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 5,
+                    "target" : {
+                        "node" : 3,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 6,
+                    "target" : {
+                        "node" : 2,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 7,
+                    "target" : {
+                        "node" : 2,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 8,
+                    "target" : {
+                        "node" : 2,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 9,
+                    "target" : {
+                        "node" : 1,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 10,
+                    "target" : {
+                        "node" : 1,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 11,
+                    "target" : {
+                        "node" : 1,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 12,
+                    "target" : {
+                        "node" : 0,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 13,
+                    "target" : {
+                        "node" : 0,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 14,
+                    "target" : {
+                        "node" : 0,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 15,
+                    "target" : {
+                        "node" : 5,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 16,
+                    "target" : {
+                        "node" : 5,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 17,
+                    "target" : {
+                        "node" : 5,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 18,
+                    "target" : {
+                        "node" : 4,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 19,
+                    "target" : {
+                        "node" : 4,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 20,
+                    "target" : {
+                        "node" : 4,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 21,
+                    "target" : {
+                        "node" : 7,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 22,
+                    "target" : {
+                        "node" : 7,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 23,
+                    "target" : {
+                        "node" : 7,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 24,
+                    "target" : {
+                        "node" : 6,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 25,
+                    "target" : {
+                        "node" : 6,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 26,
+                    "target" : {
+                        "node" : 6,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 27,
+                    "target" : {
+                        "node" : 17,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 28,
+                    "target" : {
+                        "node" : 17,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 29,
+                    "target" : {
+                        "node" : 17,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 30,
+                    "target" : {
+                        "node" : 12,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 31,
+                    "target" : {
+                        "node" : 12,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 32,
+                    "target" : {
+                        "node" : 12,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 33,
+                    "target" : {
+                        "node" : 11,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 34,
+                    "target" : {
+                        "node" : 11,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 35,
+                    "target" : {
+                        "node" : 11,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 36,
+                    "target" : {
+                        "node" : 10,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 37,
+                    "target" : {
+                        "node" : 10,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 38,
+                    "target" : {
+                        "node" : 10,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 39,
+                    "target" : {
+                        "node" : 9,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 40,
+                    "target" : {
+                        "node" : 9,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 41,
+                    "target" : {
+                        "node" : 9,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 42,
+                    "target" : {
+                        "node" : 14,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 43,
+                    "target" : {
+                        "node" : 14,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 44,
+                    "target" : {
+                        "node" : 14,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 45,
+                    "target" : {
+                        "node" : 13,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 46,
+                    "target" : {
+                        "node" : 13,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 47,
+                    "target" : {
+                        "node" : 13,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 48,
+                    "target" : {
+                        "node" : 16,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 49,
+                    "target" : {
+                        "node" : 16,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 50,
+                    "target" : {
+                        "node" : 16,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 51,
+                    "target" : {
+                        "node" : 15,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 52,
+                    "target" : {
+                        "node" : 15,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 53,
+                    "target" : {
+                        "node" : 15,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 54,
+                    "target" : {
+                        "node" : 57,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 55,
+                    "target" : {
+                        "node" : 57,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 56,
+                    "target" : {
+                        "node" : 57,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 57,
+                    "target" : {
+                        "node" : 56,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 58,
+                    "target" : {
+                        "node" : 56,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 59,
+                    "target" : {
+                        "node" : 56,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 60,
+                    "target" : {
+                        "node" : 45,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 61,
+                    "target" : {
+                        "node" : 45,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 62,
+                    "target" : {
+                        "node" : 45,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 63,
+                    "target" : {
+                        "node" : 44,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 64,
+                    "target" : {
+                        "node" : 44,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 65,
+                    "target" : {
+                        "node" : 44,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 66,
+                    "target" : {
+                        "node" : 43,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 67,
+                    "target" : {
+                        "node" : 43,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 68,
+                    "target" : {
+                        "node" : 43,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 69,
+                    "target" : {
+                        "node" : 20,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 70,
+                    "target" : {
+                        "node" : 20,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 71,
+                    "target" : {
+                        "node" : 20,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 72,
+                    "target" : {
+                        "node" : 19,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 73,
+                    "target" : {
+                        "node" : 19,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 74,
+                    "target" : {
+                        "node" : 19,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 75,
+                    "target" : {
+                        "node" : 18,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 76,
+                    "target" : {
+                        "node" : 18,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 77,
+                    "target" : {
+                        "node" : 18,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 78,
+                    "target" : {
+                        "node" : 31,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 79,
+                    "target" : {
+                        "node" : 31,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 80,
+                    "target" : {
+                        "node" : 31,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 81,
+                    "target" : {
+                        "node" : 30,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 82,
+                    "target" : {
+                        "node" : 30,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 83,
+                    "target" : {
+                        "node" : 30,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 84,
+                    "target" : {
+                        "node" : 29,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 85,
+                    "target" : {
+                        "node" : 29,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 86,
+                    "target" : {
+                        "node" : 29,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 87,
+                    "target" : {
+                        "node" : 28,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 88,
+                    "target" : {
+                        "node" : 28,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 89,
+                    "target" : {
+                        "node" : 28,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 90,
+                    "target" : {
+                        "node" : 24,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 91,
+                    "target" : {
+                        "node" : 24,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 92,
+                    "target" : {
+                        "node" : 24,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 93,
+                    "target" : {
+                        "node" : 23,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 94,
+                    "target" : {
+                        "node" : 23,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 95,
+                    "target" : {
+                        "node" : 23,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 96,
+                    "target" : {
+                        "node" : 22,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 97,
+                    "target" : {
+                        "node" : 22,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 98,
+                    "target" : {
+                        "node" : 22,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 99,
+                    "target" : {
+                        "node" : 21,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 100,
+                    "target" : {
+                        "node" : 21,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 101,
+                    "target" : {
+                        "node" : 21,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 102,
+                    "target" : {
+                        "node" : 27,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 103,
+                    "target" : {
+                        "node" : 27,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 104,
+                    "target" : {
+                        "node" : 27,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 105,
+                    "target" : {
+                        "node" : 26,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 106,
+                    "target" : {
+                        "node" : 26,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 107,
+                    "target" : {
+                        "node" : 26,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 108,
+                    "target" : {
+                        "node" : 25,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 109,
+                    "target" : {
+                        "node" : 25,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 110,
+                    "target" : {
+                        "node" : 25,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 111,
+                    "target" : {
+                        "node" : 42,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 112,
+                    "target" : {
+                        "node" : 42,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 113,
+                    "target" : {
+                        "node" : 42,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 114,
+                    "target" : {
+                        "node" : 41,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 115,
+                    "target" : {
+                        "node" : 41,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 116,
+                    "target" : {
+                        "node" : 41,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 117,
+                    "target" : {
+                        "node" : 40,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 118,
+                    "target" : {
+                        "node" : 40,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 119,
+                    "target" : {
+                        "node" : 40,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 120,
+                    "target" : {
+                        "node" : 39,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 121,
+                    "target" : {
+                        "node" : 39,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 122,
+                    "target" : {
+                        "node" : 39,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 123,
+                    "target" : {
+                        "node" : 35,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 124,
+                    "target" : {
+                        "node" : 35,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 125,
+                    "target" : {
+                        "node" : 35,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 126,
+                    "target" : {
+                        "node" : 34,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 127,
+                    "target" : {
+                        "node" : 34,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 128,
+                    "target" : {
+                        "node" : 34,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 129,
+                    "target" : {
+                        "node" : 33,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 130,
+                    "target" : {
+                        "node" : 33,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 131,
+                    "target" : {
+                        "node" : 33,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 132,
+                    "target" : {
+                        "node" : 32,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 133,
+                    "target" : {
+                        "node" : 32,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 134,
+                    "target" : {
+                        "node" : 32,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 135,
+                    "target" : {
+                        "node" : 38,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 136,
+                    "target" : {
+                        "node" : 38,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 137,
+                    "target" : {
+                        "node" : 38,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 138,
+                    "target" : {
+                        "node" : 37,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 139,
+                    "target" : {
+                        "node" : 37,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 140,
+                    "target" : {
+                        "node" : 37,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 141,
+                    "target" : {
+                        "node" : 36,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 142,
+                    "target" : {
+                        "node" : 36,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 143,
+                    "target" : {
+                        "node" : 36,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 144,
+                    "target" : {
+                        "node" : 50,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 145,
+                    "target" : {
+                        "node" : 50,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 146,
+                    "target" : {
+                        "node" : 50,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 147,
+                    "target" : {
+                        "node" : 49,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 148,
+                    "target" : {
+                        "node" : 49,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 149,
+                    "target" : {
+                        "node" : 49,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 150,
+                    "target" : {
+                        "node" : 48,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 151,
+                    "target" : {
+                        "node" : 48,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 152,
+                    "target" : {
+                        "node" : 48,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 153,
+                    "target" : {
+                        "node" : 47,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 154,
+                    "target" : {
+                        "node" : 47,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 155,
+                    "target" : {
+                        "node" : 47,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 156,
+                    "target" : {
+                        "node" : 46,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 157,
+                    "target" : {
+                        "node" : 46,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 158,
+                    "target" : {
+                        "node" : 46,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 159,
+                    "target" : {
+                        "node" : 55,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 160,
+                    "target" : {
+                        "node" : 55,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 161,
+                    "target" : {
+                        "node" : 55,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 162,
+                    "target" : {
+                        "node" : 54,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 163,
+                    "target" : {
+                        "node" : 54,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 164,
+                    "target" : {
+                        "node" : 54,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 165,
+                    "target" : {
+                        "node" : 53,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 166,
+                    "target" : {
+                        "node" : 53,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 167,
+                    "target" : {
+                        "node" : 53,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 168,
+                    "target" : {
+                        "node" : 52,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 169,
+                    "target" : {
+                        "node" : 52,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 170,
+                    "target" : {
+                        "node" : 52,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 171,
+                    "target" : {
+                        "node" : 51,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 172,
+                    "target" : {
+                        "node" : 51,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 173,
+                    "target" : {
+                        "node" : 51,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 174,
+                    "target" : {
+                        "node" : 58,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 175,
+                    "target" : {
+                        "node" : 58,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 176,
+                    "target" : {
+                        "node" : 58,
+                        "path" : "scale"
+                    }
+                }
+            ],
+            "name" : "idle",
+            "samplers" : [
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 1
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 2
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 3
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 4
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 5
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 6
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 7
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 8
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 9
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 10
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 11
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 12
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 13
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 14
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 15
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 16
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 17
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 18
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 19
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 20
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 21
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 22
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 23
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 24
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 25
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 26
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 27
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 28
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 29
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 30
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 31
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 32
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 33
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 34
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 35
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 36
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 37
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 38
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 39
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 40
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 41
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 42
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 43
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 44
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 45
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 46
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 47
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 48
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 49
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 50
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 51
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 52
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 53
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 54
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 55
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 56
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 57
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 58
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 59
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 60
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 61
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 62
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 63
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 64
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 65
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 66
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 67
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 68
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 69
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 70
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 71
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 72
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 73
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 74
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 75
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 76
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 77
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 78
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 79
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 80
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 81
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 82
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 83
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 84
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 85
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 86
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 87
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 88
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 89
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 90
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 91
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 92
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 93
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 94
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 95
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 96
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 97
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 98
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 99
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 100
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 101
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 102
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 103
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 104
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 105
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 106
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 107
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 108
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 109
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 110
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 111
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 112
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 113
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 114
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 115
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 116
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 117
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 118
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 119
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 120
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 121
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 122
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 123
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 124
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 125
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 126
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 127
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 128
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 129
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 130
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 131
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 132
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 133
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 134
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 135
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 136
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 137
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 138
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 139
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 140
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 141
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 142
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 143
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 144
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 145
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 146
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 147
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 148
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 149
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 150
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 151
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 152
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 153
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 154
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 155
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 156
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 157
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 158
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 159
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 160
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 161
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 162
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 163
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 164
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 165
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 166
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 167
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 168
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 169
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 170
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 171
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 172
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 173
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 174
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 175
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 176
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 177
+                }
+            ]
+        }
+    ],
+    "accessors" : [
+        {
+            "bufferView" : 0,
+            "componentType" : 5126,
+            "count" : 33,
+            "max" : [
+                1.1
+            ],
+            "min" : [
+                0.03333333333333333
+            ],
+            "type" : "SCALAR"
+        },
+        {
+            "bufferView" : 1,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 2,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 3,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 4,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 5,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 6,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 7,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 8,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 9,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 10,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 11,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 12,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 13,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 14,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 15,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 16,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 17,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 18,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 19,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 20,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 21,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 22,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 23,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 24,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 25,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 26,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 27,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 28,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 29,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 30,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 31,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 32,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 33,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 34,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 35,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 36,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 37,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 38,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 39,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 40,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 41,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 42,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 43,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 44,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 45,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 46,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 47,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 48,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 49,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 50,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 51,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 52,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 53,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 54,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 55,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 56,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 57,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 58,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 59,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 60,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 61,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 62,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 63,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 64,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 65,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 66,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 67,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 68,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 69,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 70,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 71,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 72,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 73,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 74,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 75,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 76,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 77,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 78,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 79,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 80,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 81,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 82,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 83,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 84,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 85,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 86,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 87,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 88,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 89,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 90,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 91,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 92,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 93,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 94,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 95,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 96,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 97,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 98,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 99,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 100,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 101,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 102,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 103,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 104,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 105,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 106,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 107,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 108,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 109,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 110,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 111,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 112,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 113,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 114,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 115,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 116,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 117,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 118,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 119,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 120,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 121,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 122,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 123,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 124,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 125,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 126,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 127,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 128,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 129,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 130,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 131,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 132,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 133,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 134,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 135,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 136,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 137,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 138,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 139,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 140,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 141,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 142,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 143,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 144,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 145,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 146,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 147,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 148,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 149,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 150,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 151,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 152,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 153,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 154,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 155,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 156,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 157,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 158,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 159,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 160,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 161,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 162,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 163,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 164,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 165,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 166,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 167,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 168,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 169,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 170,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 171,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 172,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 173,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 174,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 175,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 176,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 177,
+            "componentType" : 5126,
+            "count" : 33,
+            "type" : "VEC3"
+        }
+    ],
+    "bufferViews" : [
+        {
+            "buffer" : 0,
+            "byteLength" : 132,
+            "byteOffset" : 0
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 132
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 528
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 1056
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 1452
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 1848
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 2376
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 2772
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 3168
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 3696
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 4092
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 4488
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 5016
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 5412
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 5808
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 6336
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 6732
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 7128
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 7656
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 8052
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 8448
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 8976
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 9372
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 9768
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 10296
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 10692
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 11088
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 11616
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 12012
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 12408
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 12936
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 13332
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 13728
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 14256
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 14652
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 15048
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 15576
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 15972
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 16368
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 16896
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 17292
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 17688
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 18216
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 18612
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 19008
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 19536
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 19932
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 20328
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 20856
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 21252
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 21648
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 22176
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 22572
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 22968
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 23496
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 23892
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 24288
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 24816
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 25212
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 25608
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 26136
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 26532
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 26928
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 27456
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 27852
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 28248
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 28776
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 29172
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 29568
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 30096
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 30492
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 30888
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 31416
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 31812
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 32208
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 32736
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 33132
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 33528
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 34056
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 34452
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 34848
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 35376
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 35772
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 36168
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 36696
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 37092
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 37488
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 38016
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 38412
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 38808
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 39336
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 39732
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 40128
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 40656
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 41052
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 41448
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 41976
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 42372
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 42768
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 43296
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 43692
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 44088
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 44616
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 45012
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 45408
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 45936
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 46332
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 46728
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 47256
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 47652
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 48048
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 48576
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 48972
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 49368
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 49896
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 50292
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 50688
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 51216
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 51612
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 52008
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 52536
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 52932
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 53328
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 53856
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 54252
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 54648
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 55176
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 55572
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 55968
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 56496
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 56892
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 57288
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 57816
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 58212
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 58608
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 59136
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 59532
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 59928
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 60456
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 60852
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 61248
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 61776
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 62172
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 62568
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 63096
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 63492
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 63888
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 64416
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 64812
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 65208
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 65736
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 66132
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 66528
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 67056
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 67452
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 67848
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 68376
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 68772
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 69168
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 69696
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 70092
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 70488
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 71016
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 71412
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 71808
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 72336
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 72732
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 73128
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 73656
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 74052
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 74448
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 74976
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 75372
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 75768
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 76296
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 76692
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 528,
+            "byteOffset" : 77088
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 396,
+            "byteOffset" : 77616
+        }
+    ],
+    "buffers" : [
+        {
+            "byteLength" : 78012,
+            "uri" : "data:application/octet-stream;base64,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"
+        }
+    ]
+}
diff --git a/assets/models/character_medium/run.gltf b/assets/models/character_medium/run.gltf
new file mode 100644
index 0000000000000..acbced2da725e
--- /dev/null
+++ b/assets/models/character_medium/run.gltf
@@ -0,0 +1,3723 @@
+{
+    "asset" : {
+        "generator" : "Khronos glTF Blender I/O v1.2.75",
+        "version" : "2.0"
+    },
+    "scene" : 0,
+    "scenes" : [
+        {
+            "name" : "Scene",
+            "nodes" : [
+                40
+            ]
+        }
+    ],
+    "nodes" : [
+        {
+            "name" : "Head_end",
+            "rotation" : [
+                2.5494955480098724e-08,
+                1.3771639828519255e-08,
+                -1.1013601142195739e-10,
+                1
+            ],
+            "translation" : [
+                -1.994109322112081e-10,
+                1.004410982131958,
+                4.721497415260956e-09
+            ]
+        },
+        {
+            "children" : [
+                0
+            ],
+            "name" : "Head",
+            "rotation" : [
+                -0.23040032386779785,
+                -0.002951267873868346,
+                -0.012192667461931705,
+                0.9730151295661926
+            ],
+            "scale" : [
+                1,
+                1,
+                0.9999997615814209
+            ],
+            "translation" : [
+                -4.3153569606602105e-10,
+                0.2780091464519501,
+                3.472086973488331e-08
+            ]
+        },
+        {
+            "children" : [
+                1
+            ],
+            "name" : "Neck",
+            "rotation" : [
+                0.0766155794262886,
+                7.1184160788106965e-09,
+                4.883343951433972e-09,
+                0.9970607161521912
+            ],
+            "scale" : [
+                0.9999999403953552,
+                1.0000001192092896,
+                0.9999999403953552
+            ],
+            "translation" : [
+                7.67893304498557e-09,
+                0.27086466550827026,
+                -1.1714315206745596e-07
+            ]
+        },
+        {
+            "name" : "LeftHandIndex3_end",
+            "rotation" : [
+                4.633330377146194e-07,
+                2.1979215603096236e-07,
+                -7.88830334386148e-07,
+                1
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999999403953552,
+                0.9999998807907104
+            ],
+            "translation" : [
+                -1.6763806343078613e-08,
+                0.13049860298633575,
+                8.940696716308594e-08
+            ]
+        },
+        {
+            "children" : [
+                3
+            ],
+            "name" : "LeftHandIndex3",
+            "rotation" : [
+                0.4109351933002472,
+                -0.027860397472977638,
+                0.012506891041994095,
+                0.9111529588699341
+            ],
+            "translation" : [
+                1.6763806343078613e-07,
+                0.10213017463684082,
+                -1.341104507446289e-07
+            ]
+        },
+        {
+            "children" : [
+                4
+            ],
+            "name" : "LeftHandIndex2",
+            "rotation" : [
+                0.7160413265228271,
+                0.04687080532312393,
+                -0.0056250980123877525,
+                0.6964598894119263
+            ],
+            "translation" : [
+                -7.450580596923828e-08,
+                0.15551283955574036,
+                0
+            ]
+        },
+        {
+            "children" : [
+                5
+            ],
+            "name" : "LeftHandIndex1",
+            "rotation" : [
+                0.016248861327767372,
+                -0.0775756686925888,
+                4.178479503025301e-05,
+                0.9968540668487549
+            ],
+            "translation" : [
+                -4.840876854927956e-08,
+                0.09553951025009155,
+                3.1583947901481224e-08
+            ]
+        },
+        {
+            "name" : "LeftHandThumb2_end",
+            "rotation" : [
+                -9.462236789659073e-07,
+                -2.877786528188153e-06,
+                7.35744833946228e-08,
+                1
+            ],
+            "scale" : [
+                1,
+                1,
+                1.0000001192092896
+            ],
+            "translation" : [
+                1.7881393432617188e-07,
+                0.13152462244033813,
+                -7.450580596923828e-08
+            ]
+        },
+        {
+            "children" : [
+                7
+            ],
+            "name" : "LeftHandThumb2",
+            "rotation" : [
+                0.3956751823425293,
+                -0.031022101640701294,
+                0.04630616679787636,
+                0.91669762134552
+            ],
+            "scale" : [
+                1,
+                0.9999999403953552,
+                0.9999999403953552
+            ],
+            "translation" : [
+                5.960464477539063e-08,
+                0.10601934790611267,
+                -1.7695128917694092e-08
+            ]
+        },
+        {
+            "children" : [
+                8
+            ],
+            "name" : "LeftHandThumb1",
+            "rotation" : [
+                -0.20212016999721527,
+                0.7017301917076111,
+                0.3565598726272583,
+                0.5827412009239197
+            ],
+            "scale" : [
+                1,
+                1.0000001192092896,
+                0.9999998807907104
+            ],
+            "translation" : [
+                -0.09357056021690369,
+                0.0682658925652504,
+                0.012919588014483452
+            ]
+        },
+        {
+            "children" : [
+                6,
+                9
+            ],
+            "name" : "LeftHand",
+            "rotation" : [
+                -0.01508407574146986,
+                0.7243565917015076,
+                -0.03158021345734596,
+                0.6885366439819336
+            ],
+            "scale" : [
+                0.9999998211860657,
+                0.9999997615814209,
+                0.9999999403953552
+            ],
+            "translation" : [
+                1.4901161193847656e-08,
+                0.5272283554077148,
+                3.3527612686157227e-08
+            ]
+        },
+        {
+            "children" : [
+                10
+            ],
+            "name" : "LeftForeArm",
+            "rotation" : [
+                0.7658034563064575,
+                -0.16652725636959076,
+                -0.18745088577270508,
+                0.592179000377655
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999999403953552,
+                1
+            ],
+            "translation" : [
+                -1.1641532182693481e-07,
+                0.4707745909690857,
+                1.0477378964424133e-08
+            ]
+        },
+        {
+            "children" : [
+                11
+            ],
+            "name" : "LeftArm",
+            "rotation" : [
+                -0.19635333120822906,
+                0.5418559312820435,
+                -0.3986077606678009,
+                0.7134069800376892
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999998807907104,
+                1
+            ],
+            "translation" : [
+                1.0058283805847168e-07,
+                0.2588006854057312,
+                -1.7136335372924805e-07
+            ]
+        },
+        {
+            "children" : [
+                12
+            ],
+            "name" : "LeftShoulder",
+            "rotation" : [
+                -0.5868825912475586,
+                -0.41065335273742676,
+                -0.5482945442199707,
+                0.43163153529167175
+            ],
+            "scale" : [
+                1,
+                0.9999999403953552,
+                1.0000001192092896
+            ],
+            "translation" : [
+                0.08827971667051315,
+                0.281081885099411,
+                0.06496098637580872
+            ]
+        },
+        {
+            "name" : "RightHandIndex3_end",
+            "rotation" : [
+                3.725290298461914e-09,
+                7.671769708395004e-08,
+                -1.1606609007230873e-07,
+                1
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999998807907104,
+                1
+            ],
+            "translation" : [
+                1.7345882952213287e-08,
+                0.13049860298633575,
+                -1.4156103134155273e-07
+            ]
+        },
+        {
+            "children" : [
+                14
+            ],
+            "name" : "RightHandIndex3",
+            "rotation" : [
+                -0.16971231997013092,
+                -0.030103571712970734,
+                -0.005131654441356659,
+                0.9850203990936279
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999999403953552,
+                0.9999998807907104
+            ],
+            "translation" : [
+                4.563480615615845e-08,
+                0.10213017463684082,
+                1.4901161193847656e-08
+            ]
+        },
+        {
+            "children" : [
+                15
+            ],
+            "name" : "RightHandIndex2",
+            "rotation" : [
+                -0.8111863732337952,
+                0.03926300257444382,
+                0.006371081341058016,
+                0.5834334492683411
+            ],
+            "scale" : [
+                0.9999998807907104,
+                1.0000001192092896,
+                1.0000001192092896
+            ],
+            "translation" : [
+                5.960464477539063e-08,
+                0.15551263093948364,
+                1.2293457984924316e-07
+            ]
+        },
+        {
+            "children" : [
+                16
+            ],
+            "name" : "RightHandIndex1",
+            "rotation" : [
+                -0.016248295083642006,
+                -0.0775795578956604,
+                -4.3082847696496174e-05,
+                0.996853768825531
+            ],
+            "scale" : [
+                0.9999998807907104,
+                1.0000001192092896,
+                1
+            ],
+            "translation" : [
+                -1.854177078541852e-08,
+                0.09553966671228409,
+                -4.259116792582063e-08
+            ]
+        },
+        {
+            "name" : "RightHandThumb2_end",
+            "rotation" : [
+                2.0023435354232788e-07,
+                -1.862645149230957e-08,
+                -1.685693860054016e-07,
+                1
+            ],
+            "translation" : [
+                -3.725290298461914e-09,
+                0.13152477145195007,
+                -7.450580596923828e-08
+            ]
+        },
+        {
+            "children" : [
+                18
+            ],
+            "name" : "RightHandThumb2",
+            "rotation" : [
+                -0.3972201645374298,
+                0.007769328076392412,
+                0.17114537954330444,
+                0.9015902876853943
+            ],
+            "scale" : [
+                0.9999999403953552,
+                1,
+                0.9999998807907104
+            ],
+            "translation" : [
+                1.862645149230957e-08,
+                0.10601919889450073,
+                4.0978193283081055e-08
+            ]
+        },
+        {
+            "children" : [
+                19
+            ],
+            "name" : "RightHandThumb1",
+            "rotation" : [
+                0.2317005693912506,
+                -0.801653265953064,
+                0.34581395983695984,
+                0.42904505133628845
+            ],
+            "scale" : [
+                1,
+                1.0000004768371582,
+                1.000000238418579
+            ],
+            "translation" : [
+                -0.09030157327651978,
+                0.0682658851146698,
+                -0.027712950482964516
+            ]
+        },
+        {
+            "children" : [
+                17,
+                20
+            ],
+            "name" : "RightHand",
+            "rotation" : [
+                -0.010815228335559368,
+                0.10929599404335022,
+                -0.03328502178192139,
+                0.993393063545227
+            ],
+            "scale" : [
+                1,
+                0.9999999403953552,
+                0.9999997615814209
+            ],
+            "translation" : [
+                1.1920928955078125e-07,
+                0.5272283554077148,
+                1.862645149230957e-09
+            ]
+        },
+        {
+            "children" : [
+                21
+            ],
+            "name" : "RightForeArm",
+            "rotation" : [
+                -0.11443673074245453,
+                -0.0923856720328331,
+                0.1078580766916275,
+                0.9832272529602051
+            ],
+            "translation" : [
+                -2.3393176284969286e-09,
+                0.4707752466201782,
+                -1.2031331664275058e-07
+            ]
+        },
+        {
+            "children" : [
+                22
+            ],
+            "name" : "RightArm",
+            "rotation" : [
+                -0.0028538149781525135,
+                -0.9066807627677917,
+                -0.40139201283454895,
+                0.12963904440402985
+            ],
+            "scale" : [
+                1.000000238418579,
+                0.9999999403953552,
+                1
+            ],
+            "translation" : [
+                -2.323558305761253e-07,
+                0.2588006258010864,
+                -3.265833470322832e-08
+            ]
+        },
+        {
+            "children" : [
+                23
+            ],
+            "name" : "RightShoulder",
+            "rotation" : [
+                0.6583796739578247,
+                -0.5076103806495667,
+                0.45999422669410706,
+                0.3118866980075836
+            ],
+            "scale" : [
+                0.9999998211860657,
+                0.9999997615814209,
+                0.9999999403953552
+            ],
+            "translation" : [
+                -0.08827970921993256,
+                0.28108203411102295,
+                0.0649610310792923
+            ]
+        },
+        {
+            "children" : [
+                2,
+                13,
+                24
+            ],
+            "name" : "UpperChest",
+            "rotation" : [
+                0.04916594177484512,
+                8.814799445922006e-10,
+                -3.835628259452051e-09,
+                0.9987906813621521
+            ],
+            "scale" : [
+                1,
+                1.0000001192092896,
+                1
+            ],
+            "translation" : [
+                8.04667221743216e-10,
+                0.3052769601345062,
+                3.383320290595293e-09
+            ]
+        },
+        {
+            "children" : [
+                25
+            ],
+            "name" : "Chest",
+            "rotation" : [
+                0.011894592083990574,
+                1.5284546961424894e-08,
+                1.568121099637665e-08,
+                0.9999292492866516
+            ],
+            "scale" : [
+                1,
+                0.9999998807907104,
+                0.9999999403953552
+            ],
+            "translation" : [
+                -1.5654960661137807e-09,
+                0.287048876285553,
+                -1.0986695997416973e-09
+            ]
+        },
+        {
+            "children" : [
+                26
+            ],
+            "name" : "Spine",
+            "rotation" : [
+                0.09707079827785492,
+                1.7373693594890938e-09,
+                -1.2611044652999226e-08,
+                0.9952775835990906
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999998211860657,
+                0.9999998807907104
+            ],
+            "translation" : [
+                -1.6391404900062412e-09,
+                0.32195183634757996,
+                6.742975067197676e-09
+            ]
+        },
+        {
+            "name" : "LeftToes_end",
+            "rotation" : [
+                1.2862439291438932e-07,
+                1.3934914022684097e-07,
+                -1.6298147276216923e-09,
+                1
+            ],
+            "scale" : [
+                1,
+                0.9999999403953552,
+                0.9999999403953552
+            ],
+            "translation" : [
+                1.30385160446167e-08,
+                0.21323642134666443,
+                2.2584572434425354e-08
+            ]
+        },
+        {
+            "children" : [
+                28
+            ],
+            "name" : "LeftToes",
+            "rotation" : [
+                -0.019819648936390877,
+                0.9522866606712341,
+                -0.2982541620731354,
+                0.06165793910622597
+            ],
+            "scale" : [
+                1.0000001192092896,
+                1.0000003576278687,
+                1
+            ],
+            "translation" : [
+                -2.2351741790771484e-08,
+                0.30125460028648376,
+                4.0978193283081055e-08
+            ]
+        },
+        {
+            "children" : [
+                29
+            ],
+            "name" : "LeftFoot",
+            "rotation" : [
+                -0.23854529857635498,
+                -0.11003730446100235,
+                -0.17040802538394928,
+                0.9497100710868835
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999999403953552,
+                0.9999998807907104
+            ],
+            "translation" : [
+                0,
+                0.60881108045578,
+                5.960464477539063e-08
+            ]
+        },
+        {
+            "children" : [
+                30
+            ],
+            "name" : "LeftLeg",
+            "rotation" : [
+                0.5292485952377319,
+                0.027083680033683777,
+                0.19758859276771545,
+                0.8246945738792419
+            ],
+            "scale" : [
+                0.9999999403953552,
+                0.9999998211860657,
+                1
+            ],
+            "translation" : [
+                3.725290298461914e-08,
+                0.5261747241020203,
+                -1.862645149230957e-08
+            ]
+        },
+        {
+            "children" : [
+                31
+            ],
+            "name" : "LeftUpLeg",
+            "rotation" : [
+                -0.9857112169265747,
+                -0.021219033747911453,
+                -0.09155075997114182,
+                0.13979153335094452
+            ],
+            "scale" : [
+                1.0000001192092896,
+                1.0000001192092896,
+                1.000002145767212
+            ],
+            "translation" : [
+                0.201528400182724,
+                0.058463357388973236,
+                8.132411011274598e-08
+            ]
+        },
+        {
+            "name" : "RightToes_end",
+            "rotation" : [
+                -1.6996636986732483e-08,
+                -3.4016557037830353e-07,
+                6.076879799365997e-08,
+                1
+            ],
+            "scale" : [
+                1,
+                0.9999998807907104,
+                1
+            ],
+            "translation" : [
+                -1.7695128917694092e-08,
+                0.21323654055595398,
+                -2.8172507882118225e-08
+            ]
+        },
+        {
+            "children" : [
+                33
+            ],
+            "name" : "RightToes",
+            "rotation" : [
+                -0.02826262079179287,
+                -0.9539409875869751,
+                0.29757365584373474,
+                0.025451287627220154
+            ],
+            "scale" : [
+                1,
+                1.0000001192092896,
+                1.000000238418579
+            ],
+            "translation" : [
+                -6.05359673500061e-09,
+                0.3012545704841614,
+                1.3504177331924438e-08
+            ]
+        },
+        {
+            "children" : [
+                34
+            ],
+            "name" : "RightFoot",
+            "rotation" : [
+                -0.6210404634475708,
+                0.12048467248678207,
+                0.1538510024547577,
+                0.7590271234512329
+            ],
+            "scale" : [
+                0.9999998211860657,
+                1.0000001192092896,
+                1.0000001192092896
+            ],
+            "translation" : [
+                -1.862645149230957e-09,
+                0.6088125109672546,
+                -4.284083843231201e-08
+            ]
+        },
+        {
+            "children" : [
+                35
+            ],
+            "name" : "RightLeg",
+            "rotation" : [
+                0.359414666891098,
+                0.010718868114054203,
+                -0.15306243300437927,
+                0.9204772114753723
+            ],
+            "scale" : [
+                1,
+                1,
+                1.0000001192092896
+            ],
+            "translation" : [
+                -1.862645149230957e-08,
+                0.5261743068695068,
+                -1.4901161193847656e-08
+            ]
+        },
+        {
+            "children" : [
+                36
+            ],
+            "name" : "RightUpLeg",
+            "rotation" : [
+                0.9223171472549438,
+                -0.08511368185281754,
+                -0.10383972525596619,
+                0.3623589873313904
+            ],
+            "scale" : [
+                0.9999999403953552,
+                1.0000001192092896,
+                1.0000001192092896
+            ],
+            "translation" : [
+                -0.2015283703804016,
+                0.05846335366368294,
+                8.637989168391869e-08
+            ]
+        },
+        {
+            "children" : [
+                27,
+                32,
+                37
+            ],
+            "name" : "Hips",
+            "rotation" : [
+                9.251380106434226e-05,
+                3.83329012976219e-09,
+                0.9999990463256836,
+                0.0014432212337851524
+            ],
+            "scale" : [
+                1.0000041723251343,
+                1,
+                0.9999998807907104
+            ],
+            "translation" : [
+                0.00046460292651318014,
+                0.32195088267326355,
+                -4.289531574386274e-08
+            ]
+        },
+        {
+            "children" : [
+                38
+            ],
+            "name" : "HipsCtrl",
+            "rotation" : [
+                -9.100934403249994e-05,
+                -9.890962928693625e-07,
+                -0.9999022483825684,
+                0.013988462276756763
+            ],
+            "scale" : [
+                1,
+                1.0000001192092896,
+                1
+            ],
+            "translation" : [
+                -0.005456702318042517,
+                1.4758756160736084,
+                0.024301037192344666
+            ]
+        },
+        {
+            "children" : [
+                39
+            ],
+            "name" : "Root"
+        }
+    ],
+    "animations" : [
+        {
+            "channels" : [
+                {
+                    "sampler" : 0,
+                    "target" : {
+                        "node" : 39,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 1,
+                    "target" : {
+                        "node" : 39,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 2,
+                    "target" : {
+                        "node" : 39,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 3,
+                    "target" : {
+                        "node" : 38,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 4,
+                    "target" : {
+                        "node" : 38,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 5,
+                    "target" : {
+                        "node" : 38,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 6,
+                    "target" : {
+                        "node" : 27,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 7,
+                    "target" : {
+                        "node" : 27,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 8,
+                    "target" : {
+                        "node" : 27,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 9,
+                    "target" : {
+                        "node" : 26,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 10,
+                    "target" : {
+                        "node" : 26,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 11,
+                    "target" : {
+                        "node" : 26,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 12,
+                    "target" : {
+                        "node" : 25,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 13,
+                    "target" : {
+                        "node" : 25,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 14,
+                    "target" : {
+                        "node" : 25,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 15,
+                    "target" : {
+                        "node" : 2,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 16,
+                    "target" : {
+                        "node" : 2,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 17,
+                    "target" : {
+                        "node" : 2,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 18,
+                    "target" : {
+                        "node" : 1,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 19,
+                    "target" : {
+                        "node" : 1,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 20,
+                    "target" : {
+                        "node" : 1,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 21,
+                    "target" : {
+                        "node" : 0,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 22,
+                    "target" : {
+                        "node" : 0,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 23,
+                    "target" : {
+                        "node" : 0,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 24,
+                    "target" : {
+                        "node" : 13,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 25,
+                    "target" : {
+                        "node" : 13,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 26,
+                    "target" : {
+                        "node" : 13,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 27,
+                    "target" : {
+                        "node" : 12,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 28,
+                    "target" : {
+                        "node" : 12,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 29,
+                    "target" : {
+                        "node" : 12,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 30,
+                    "target" : {
+                        "node" : 11,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 31,
+                    "target" : {
+                        "node" : 11,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 32,
+                    "target" : {
+                        "node" : 11,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 33,
+                    "target" : {
+                        "node" : 10,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 34,
+                    "target" : {
+                        "node" : 10,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 35,
+                    "target" : {
+                        "node" : 10,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 36,
+                    "target" : {
+                        "node" : 6,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 37,
+                    "target" : {
+                        "node" : 6,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 38,
+                    "target" : {
+                        "node" : 6,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 39,
+                    "target" : {
+                        "node" : 5,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 40,
+                    "target" : {
+                        "node" : 5,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 41,
+                    "target" : {
+                        "node" : 5,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 42,
+                    "target" : {
+                        "node" : 4,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 43,
+                    "target" : {
+                        "node" : 4,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 44,
+                    "target" : {
+                        "node" : 4,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 45,
+                    "target" : {
+                        "node" : 3,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 46,
+                    "target" : {
+                        "node" : 3,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 47,
+                    "target" : {
+                        "node" : 3,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 48,
+                    "target" : {
+                        "node" : 9,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 49,
+                    "target" : {
+                        "node" : 9,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 50,
+                    "target" : {
+                        "node" : 9,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 51,
+                    "target" : {
+                        "node" : 8,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 52,
+                    "target" : {
+                        "node" : 8,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 53,
+                    "target" : {
+                        "node" : 8,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 54,
+                    "target" : {
+                        "node" : 7,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 55,
+                    "target" : {
+                        "node" : 7,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 56,
+                    "target" : {
+                        "node" : 7,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 57,
+                    "target" : {
+                        "node" : 24,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 58,
+                    "target" : {
+                        "node" : 24,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 59,
+                    "target" : {
+                        "node" : 24,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 60,
+                    "target" : {
+                        "node" : 23,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 61,
+                    "target" : {
+                        "node" : 23,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 62,
+                    "target" : {
+                        "node" : 23,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 63,
+                    "target" : {
+                        "node" : 22,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 64,
+                    "target" : {
+                        "node" : 22,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 65,
+                    "target" : {
+                        "node" : 22,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 66,
+                    "target" : {
+                        "node" : 21,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 67,
+                    "target" : {
+                        "node" : 21,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 68,
+                    "target" : {
+                        "node" : 21,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 69,
+                    "target" : {
+                        "node" : 17,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 70,
+                    "target" : {
+                        "node" : 17,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 71,
+                    "target" : {
+                        "node" : 17,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 72,
+                    "target" : {
+                        "node" : 16,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 73,
+                    "target" : {
+                        "node" : 16,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 74,
+                    "target" : {
+                        "node" : 16,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 75,
+                    "target" : {
+                        "node" : 15,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 76,
+                    "target" : {
+                        "node" : 15,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 77,
+                    "target" : {
+                        "node" : 15,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 78,
+                    "target" : {
+                        "node" : 14,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 79,
+                    "target" : {
+                        "node" : 14,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 80,
+                    "target" : {
+                        "node" : 14,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 81,
+                    "target" : {
+                        "node" : 20,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 82,
+                    "target" : {
+                        "node" : 20,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 83,
+                    "target" : {
+                        "node" : 20,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 84,
+                    "target" : {
+                        "node" : 19,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 85,
+                    "target" : {
+                        "node" : 19,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 86,
+                    "target" : {
+                        "node" : 19,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 87,
+                    "target" : {
+                        "node" : 18,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 88,
+                    "target" : {
+                        "node" : 18,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 89,
+                    "target" : {
+                        "node" : 18,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 90,
+                    "target" : {
+                        "node" : 32,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 91,
+                    "target" : {
+                        "node" : 32,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 92,
+                    "target" : {
+                        "node" : 32,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 93,
+                    "target" : {
+                        "node" : 31,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 94,
+                    "target" : {
+                        "node" : 31,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 95,
+                    "target" : {
+                        "node" : 31,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 96,
+                    "target" : {
+                        "node" : 30,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 97,
+                    "target" : {
+                        "node" : 30,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 98,
+                    "target" : {
+                        "node" : 30,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 99,
+                    "target" : {
+                        "node" : 29,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 100,
+                    "target" : {
+                        "node" : 29,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 101,
+                    "target" : {
+                        "node" : 29,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 102,
+                    "target" : {
+                        "node" : 28,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 103,
+                    "target" : {
+                        "node" : 28,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 104,
+                    "target" : {
+                        "node" : 28,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 105,
+                    "target" : {
+                        "node" : 37,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 106,
+                    "target" : {
+                        "node" : 37,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 107,
+                    "target" : {
+                        "node" : 37,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 108,
+                    "target" : {
+                        "node" : 36,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 109,
+                    "target" : {
+                        "node" : 36,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 110,
+                    "target" : {
+                        "node" : 36,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 111,
+                    "target" : {
+                        "node" : 35,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 112,
+                    "target" : {
+                        "node" : 35,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 113,
+                    "target" : {
+                        "node" : 35,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 114,
+                    "target" : {
+                        "node" : 34,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 115,
+                    "target" : {
+                        "node" : 34,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 116,
+                    "target" : {
+                        "node" : 34,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 117,
+                    "target" : {
+                        "node" : 33,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 118,
+                    "target" : {
+                        "node" : 33,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 119,
+                    "target" : {
+                        "node" : 33,
+                        "path" : "scale"
+                    }
+                },
+                {
+                    "sampler" : 120,
+                    "target" : {
+                        "node" : 40,
+                        "path" : "translation"
+                    }
+                },
+                {
+                    "sampler" : 121,
+                    "target" : {
+                        "node" : 40,
+                        "path" : "rotation"
+                    }
+                },
+                {
+                    "sampler" : 122,
+                    "target" : {
+                        "node" : 40,
+                        "path" : "scale"
+                    }
+                }
+            ],
+            "name" : "run",
+            "samplers" : [
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 1
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 2
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 3
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 4
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 5
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 6
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 7
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 8
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 9
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 10
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 11
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 12
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 13
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 14
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 15
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 16
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 17
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 18
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 19
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 20
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 21
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 22
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 23
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 24
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 25
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 26
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 27
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 28
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 29
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 30
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 31
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 32
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 33
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 34
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 35
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 36
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 37
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 38
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 39
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 40
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 41
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 42
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 43
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 44
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 45
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 46
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 47
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 48
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 49
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 50
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 51
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 52
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 53
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 54
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 55
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 56
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 57
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 58
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 59
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 60
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 61
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 62
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 63
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 64
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 65
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 66
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 67
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 68
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 69
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 70
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 71
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 72
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 73
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 74
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 75
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 76
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 77
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 78
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 79
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 80
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 81
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 82
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 83
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 84
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 85
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 86
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 87
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 88
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 89
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 90
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 91
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 92
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 93
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 94
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 95
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 96
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 97
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 98
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 99
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 100
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 101
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 102
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 103
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 104
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 105
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 106
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 107
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 108
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 109
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 110
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 111
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 112
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 113
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 114
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 115
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 116
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 117
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 118
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 119
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 120
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 121
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 122
+                },
+                {
+                    "input" : 0,
+                    "interpolation" : "LINEAR",
+                    "output" : 123
+                }
+            ]
+        }
+    ],
+    "accessors" : [
+        {
+            "bufferView" : 0,
+            "componentType" : 5126,
+            "count" : 17,
+            "max" : [
+                0.7083333333333334
+            ],
+            "min" : [
+                0.041666666666666664
+            ],
+            "type" : "SCALAR"
+        },
+        {
+            "bufferView" : 1,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 2,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 3,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 4,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 5,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 6,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 7,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 8,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 9,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 10,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 11,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 12,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 13,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 14,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 15,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 16,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 17,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 18,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 19,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 20,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 21,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 22,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 23,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 24,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 25,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 26,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 27,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 28,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 29,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 30,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 31,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 32,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 33,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 34,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 35,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 36,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 37,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 38,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 39,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 40,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 41,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 42,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 43,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 44,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 45,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 46,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 47,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 48,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 49,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 50,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 51,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 52,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 53,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 54,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 55,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 56,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 57,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 58,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 59,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 60,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 61,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 62,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 63,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 64,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 65,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 66,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 67,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 68,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 69,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 70,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 71,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 72,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 73,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 74,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 75,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 76,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 77,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 78,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 79,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 80,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 81,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 82,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 83,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 84,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 85,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 86,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 87,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 88,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 89,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 90,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 91,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 92,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 93,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 94,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 95,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 96,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 97,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 98,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 99,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 100,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 101,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 102,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 103,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 104,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 105,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 106,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 107,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 108,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 109,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 110,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 111,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 112,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 113,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 114,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 115,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 116,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 117,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 118,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 119,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 120,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 121,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        },
+        {
+            "bufferView" : 122,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC4"
+        },
+        {
+            "bufferView" : 123,
+            "componentType" : 5126,
+            "count" : 17,
+            "type" : "VEC3"
+        }
+    ],
+    "bufferViews" : [
+        {
+            "buffer" : 0,
+            "byteLength" : 68,
+            "byteOffset" : 0
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 68
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 272
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 544
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 748
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 952
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 1224
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 1428
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 1632
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 1904
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 2108
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 2312
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 2584
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 2788
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 2992
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 3264
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 3468
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 3672
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 3944
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 4148
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 4352
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 4624
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 4828
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 5032
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 5304
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 5508
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 5712
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 5984
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 6188
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 6392
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 6664
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 6868
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 7072
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 7344
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 7548
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 7752
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 8024
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 8228
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 8432
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 8704
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 8908
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 9112
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 9384
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 9588
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 9792
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 10064
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 10268
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 10472
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 10744
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 10948
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 11152
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 11424
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 11628
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 11832
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 12104
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 12308
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 12512
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 12784
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 12988
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 13192
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 13464
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 13668
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 13872
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 14144
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 14348
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 14552
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 14824
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 15028
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 15232
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 15504
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 15708
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 15912
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 16184
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 16388
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 16592
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 16864
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 17068
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 17272
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 17544
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 17748
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 17952
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 18224
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 18428
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 18632
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 18904
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 19108
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 19312
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 19584
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 19788
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 19992
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 20264
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 20468
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 20672
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 20944
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 21148
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 21352
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 21624
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 21828
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 22032
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 22304
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 22508
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 22712
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 22984
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 23188
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 23392
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 23664
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 23868
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 24072
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 24344
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 24548
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 24752
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 25024
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 25228
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 25432
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 25704
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 25908
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 26112
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 26384
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 26588
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 26792
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 27064
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 27268
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 272,
+            "byteOffset" : 27472
+        },
+        {
+            "buffer" : 0,
+            "byteLength" : 204,
+            "byteOffset" : 27744
+        }
+    ],
+    "buffers" : [
+        {
+            "byteLength" : 27948,
+            "uri" : "data:application/octet-stream;base64,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"
+        }
+    ]
+}
diff --git a/examples/animations/run_animation.rs b/examples/animations/run_animation.rs
new file mode 100644
index 0000000000000..5990d9ef5d8b2
--- /dev/null
+++ b/examples/animations/run_animation.rs
@@ -0,0 +1,95 @@
+use bevy::animation::Animator;
+use bevy::prelude::*;
+
+fn main() {
+    App::build()
+        .add_plugins(DefaultPlugins)
+        .add_startup_system(setup)
+        .add_system(anim_set)
+        .add_system(anim_blending)
+        .run();
+}
+
+fn setup(
+    commands: &mut Commands,
+    asset_server: Res<AssetServer>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    commands
+        // plane
+        .spawn(PbrBundle {
+            mesh: meshes.add(Mesh::from(shape::Plane { size: 20.0 })),
+            transform: Transform::from_translation(Vec3::new(0.0, -1.0, 0.0)),
+            material: materials.add(Color::rgb(0.1, 0.05, 0.0).into()),
+            ..Default::default()
+        })
+        // light
+        .spawn(LightBundle {
+            transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
+            ..Default::default()
+        })
+        // camera
+        .spawn(Camera3dBundle {
+            transform: Transform::from_matrix(Mat4::face_toward(
+                Vec3::new(-3.0, 5.0, 8.0),
+                Vec3::new(0.0, 0.0, 0.0),
+                Vec3::new(0.0, 1.0, 0.0),
+            )),
+            ..Default::default()
+        })
+        // character
+        .spawn_scene(asset_server.load("models/character_medium/character_medium.gltf"));
+}
+
+fn anim_set(asset_server: Res<AssetServer>, mut animators_query: Query<(&mut Animator,)>) {
+    // Load animations and set them to the animator
+    for (mut animator,) in animators_query.iter_mut() {
+        if animator.clips().len() == 0 {
+            animator.add_layer(
+                asset_server.load("models/character_medium/idle.gltf#Anim0"),
+                1.0,
+            );
+            animator.add_layer(
+                asset_server.load("models/character_medium/run.gltf#Anim0"),
+                1.0,
+            );
+        }
+    }
+}
+
+#[derive(Default, Debug)]
+struct PingPong {
+    pong: bool,
+}
+
+fn anim_blending(
+    mut ping_pong: Local<PingPong>,
+    time: Res<Time>,
+    mut animators_query: Query<(&mut Animator,)>,
+) {
+    // Perform a simple ping pong blending between the run and idle animation
+    for (mut animator,) in animators_query.iter_mut() {
+        let dw = if ping_pong.pong {
+            time.delta_seconds / 5.0
+        } else {
+            -time.delta_seconds / 5.0
+        };
+
+        let mut w = animator.layers[0].weight;
+        w = (w + dw).min(1.0).max(0.0);
+
+        if ping_pong.pong {
+            if w >= (1.0 - 1e-2) {
+                ping_pong.pong = false;
+            }
+        } else {
+            if w <= 1e-2 {
+                ping_pong.pong = true;
+            }
+        }
+
+        animator.layers[0].weight = w; // Idle animation layer
+        animator.layers[1].weight = 1.0 - w; // Run animation layer
+    }
+}

From c14f9dd2e041dfadfb88896dae1d4f4ded24ffa2 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Thu, 10 Dec 2020 14:57:51 -0300
Subject: [PATCH 047/153] coments and experimental features

---
 crates/bevy_animation/src/custom.rs       | 30 --------
 crates/bevy_animation/src/experimental.rs | 92 +++++++++++++++++++++++
 crates/bevy_animation/src/hierarchy.rs    |  2 +-
 3 files changed, 93 insertions(+), 31 deletions(-)
 create mode 100644 crates/bevy_animation/src/experimental.rs

diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 3f060ef7bebd9..5ec96ea818037 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -378,36 +378,6 @@ impl<'a> Iterator for LayerIterator<'a> {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-pub enum FetchState<T> {
-    None,
-    Missing,
-    Found(T),
-}
-
-impl<T> FetchState<T> {
-    pub fn fetch_mut<F: Fn() -> Option<T>>(&mut self, fetch_fn: F) -> Option<&mut T> {
-        match self {
-            FetchState::None => {
-                if let Some(t) = fetch_fn() {
-                    *self = FetchState::Found(t);
-                    if let FetchState::Found(t) = self {
-                        Some(t)
-                    } else {
-                        unreachable!()
-                    }
-                } else {
-                    *self = FetchState::Missing;
-                    None
-                }
-            }
-            FetchState::Missing => None,
-            FetchState::Found(t) => Some(t),
-        }
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
 /// State info for the system `animator_binding_system`
 #[derive(Default)]
 pub(crate) struct BindingState {
diff --git a/crates/bevy_animation/src/experimental.rs b/crates/bevy_animation/src/experimental.rs
new file mode 100644
index 0000000000000..22fa81c362117
--- /dev/null
+++ b/crates/bevy_animation/src/experimental.rs
@@ -0,0 +1,92 @@
+use std::num::NonZeroU16;
+
+// pub struct EntityMap<'a>(&'a [u16]);
+
+// impl<'a> EntityMap<'a> {
+//     pub fn get_entity(index: EntityIndex) {
+
+//     }
+// }
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub enum FetchState<T> {
+    None,
+    Missing,
+    Found(T),
+}
+
+impl<T> FetchState<T> {
+    pub fn fetch_mut<F: Fn() -> Option<T>>(&mut self, fetch_fn: F) -> Option<&mut T> {
+        match self {
+            FetchState::None => {
+                if let Some(t) = fetch_fn() {
+                    *self = FetchState::Found(t);
+                    if let FetchState::Found(t) = self {
+                        Some(t)
+                    } else {
+                        unreachable!()
+                    }
+                } else {
+                    *self = FetchState::Missing;
+                    None
+                }
+            }
+            FetchState::Missing => None,
+            FetchState::Found(t) => Some(t),
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#[derive(Default)]
+pub struct PropTicket(u16, u16);
+
+// Fast cached lookup table for properties names
+struct PropertiesStash {
+    table: HashMap<String, u16, FnvBuildHasher>,
+    ver: NonZeroU16,
+    elements: Vec<CurvesUntyped>,
+}
+
+impl Default for PropertiesStash {
+    fn default() -> Self {
+        Self {
+            table: HashMap::default(),
+            ver: NonZeroU16::new(1).unwrap(),
+            elements: vec![],
+        }
+    }
+}
+
+impl PropertiesStash {
+    pub fn entry(&mut self, name: String) -> PropEntry {
+        //
+    }
+
+    pub fn get<T: 'static>(&self, name: &str, ticket: &mut PropTicket) -> Option<&Curves<T>> {
+        if ticket.1 != self.ver.get() {
+            // Token expired, find the new ticket
+            if let Some(index) = self.table.get(name) {
+                *ticket = PropTicket(*index, self.ver.get());
+            } else {
+                // Not found, set ticket invalid and return none
+                *ticket = PropTicket(u16::MAX, self.ver.get());
+                return None;
+            }
+        }
+
+        self.elements
+            .get(ticket.0 as usize)
+            .map(|curve_untyped| {
+                let curves = curve_untyped.downcast_ref::<T>();
+                if curves.is_none() {
+                    // Wrong type, return the invalid ticket
+                    *ticket = PropTicket(u16::MAX, self.ver.get());
+                }
+                curves
+            })
+            .flatten()
+    }
+}
diff --git a/crates/bevy_animation/src/hierarchy.rs b/crates/bevy_animation/src/hierarchy.rs
index 01f33e269f8cd..9517ff3548c76 100644
--- a/crates/bevy_animation/src/hierarchy.rs
+++ b/crates/bevy_animation/src/hierarchy.rs
@@ -6,6 +6,7 @@ use private::*;
 use smallvec::{smallvec, SmallVec};
 
 // TODO: Create a simplified version without the children ?!
+// TODO: Should I just use usize? and get done with it?
 
 /// Provides a way of describing a hierarchy or named entities
 /// and means for finding then in the world
@@ -18,7 +19,6 @@ pub struct Hierarchy<I: Index = u16> {
     entities: Vec<(I, Name)>,
     // ? NOTE: SmallVec<[u16; 10]> occupy the same 32 bytes as the SmallVec<[u16; 8]>, but the latter
     // ? should be only take 24 bytes using the "union" feature
-    // TODO: Use instead a const to figure out this value based on `I`
     children: Vec<SmallVec<[I; 10]>>,
 }
 

From 6723bfe9b915a94f3c165c73a72723f900fcbc37 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sat, 19 Dec 2020 10:47:40 -0300
Subject: [PATCH 048/153] fix skinned shader

---
 crates/bevy_animation/src/forward_skinned.vert |  8 +-------
 crates/bevy_animation/src/skinned_mesh.rs      | 15 ++++-----------
 2 files changed, 5 insertions(+), 18 deletions(-)

diff --git a/crates/bevy_animation/src/forward_skinned.vert b/crates/bevy_animation/src/forward_skinned.vert
index 4d1e93c502643..8c4d88f22cfa6 100644
--- a/crates/bevy_animation/src/forward_skinned.vert
+++ b/crates/bevy_animation/src/forward_skinned.vert
@@ -14,11 +14,7 @@ layout(set = 0, binding = 0) uniform Camera {
     mat4 ViewProj;
 };
 
-layout(set = 2, binding = 0) uniform Transform {
-    mat4 Model;
-};
-
-layout(set = 3, binding = 1) buffer SkinInstance_joint_matrices {
+layout(set = 2, binding = 0) buffer SkinInstance_joint_matrices {
     mat4[] Joints;
 };
 
@@ -28,8 +24,6 @@ void main() {
         + Vertex_Weight.z * Joints[Vertex_Join.z]
         + Vertex_Weight.w * Joints[Vertex_Join.w];
 
-    Mat = Model * Mat;
-
     v_Normal = (Mat * vec4(Vertex_Normal, 1.0)).xyz;
     v_Normal = mat3(Mat) * Vertex_Normal;
     v_Position = (Mat * vec4(Vertex_Position, 1.0)).xyz;
diff --git a/crates/bevy_animation/src/skinned_mesh.rs b/crates/bevy_animation/src/skinned_mesh.rs
index c9c603554eaef..917577293eab4 100644
--- a/crates/bevy_animation/src/skinned_mesh.rs
+++ b/crates/bevy_animation/src/skinned_mesh.rs
@@ -15,6 +15,9 @@ use bevy_render::shader::{Shader, ShaderStage};
 use bevy_transform::prelude::*;
 use smallvec::SmallVec;
 
+// TODO: We could use a computer shader to skin the mesh with morph targets (performance improvement)
+// TODO: Morph targets
+
 // NOTE: generated using python `import secrets; secrets.token_hex(8)`
 pub const FORWARD_SKINNED_PIPELINE_HANDLE: HandleUntyped =
     HandleUntyped::weak_from_u64(PipelineDescriptor::TYPE_UUID, 0xedf5a66b71d07478u64);
@@ -205,15 +208,6 @@ pub(crate) fn skinning_update(
                 }
             }
 
-            // Update skin uniforms
-            let root_inverse_matrix = transforms_query.get(skin_bind.root).map_or_else(
-                |_| Mat4::identity(),
-                |global_transform| {
-                    // TODO: build the inverse matrix directly from the Isometry should be faster
-                    global_transform.compute_matrix().inverse()
-                },
-            );
-
             let skin_instance = skin_instances
                 .get_mut(skin_instance_handle)
                 .expect("missing skin instance");
@@ -231,8 +225,7 @@ pub(crate) fn skinning_update(
                 .for_each(|(joint_matrix, (joint_entity, joint_inverse_matrix))| {
                     if let Some(entity) = joint_entity {
                         if let Ok(global_transform) = transforms_query.get(*entity) {
-                            *joint_matrix = (root_inverse_matrix
-                                * global_transform.compute_matrix()
+                            *joint_matrix = (global_transform.compute_matrix()
                                 * (*joint_inverse_matrix))
                                 .to_cols_array();
                         }

From 2aabf86c4483bcb84a385941b9e60b70916d1198 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 20 Dec 2020 19:02:25 -0300
Subject: [PATCH 049/153] tests and fixes

---
 crates/bevy_animation/src/blending.rs |   4 +-
 crates/bevy_animation/src/custom.rs   | 754 ++++++++++++++++++--------
 crates/bevy_animation/src/lib.rs      |  10 +-
 3 files changed, 538 insertions(+), 230 deletions(-)

diff --git a/crates/bevy_animation/src/blending.rs b/crates/bevy_animation/src/blending.rs
index 329650e7fe7c3..7dc43cc23b904 100644
--- a/crates/bevy_animation/src/blending.rs
+++ b/crates/bevy_animation/src/blending.rs
@@ -9,8 +9,8 @@ use crate::lerping::Lerp;
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 struct Ptr(*const u8);
 
-// SAFETY: Store pointers to each attribute to be updated, a clip can't have two pointers
-// with the same value. Each clip per Animator will be updated sequentially
+// SAFETY: The underlying pointer will never will be dereferenced,
+// it's only use as an numerical value globally unique any attribute
 unsafe impl Send for Ptr {}
 unsafe impl Sync for Ptr {}
 
diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 54124ac4c6007..14a546d2aff8f 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -14,6 +14,7 @@ use std::marker::PhantomData;
 
 use crate::blending::{AnimatorBlending, Blend};
 use crate::curve::Curve;
+use crate::help::Empty;
 use crate::hierarchy::Hierarchy;
 use crate::lerping::Lerp;
 
@@ -48,13 +49,9 @@ impl<T> Curves<T> {
 pub struct CurvesUntyped {
     /// Cached calculated curves duration
     duration: f32,
-    untyped: Box<dyn Any + 'static>,
+    untyped: Box<dyn Any + Send + Sync + 'static>,
 }
 
-// SAFETY: CurvesUntyped will only hold on to Curves<T> which also implement Send and Sync
-unsafe impl Send for CurvesUntyped {}
-unsafe impl Sync for CurvesUntyped {}
-
 impl CurvesUntyped {
     fn new<T: Send + Sync + 'static>(curves: Curves<T>) -> Self {
         CurvesUntyped {
@@ -327,6 +324,12 @@ impl Animator {
 
     // TODO: cleanup, clears hierarchy entities and binds
 
+    #[inline(always)]
+    pub fn entities(&self) -> &[Option<Entity>] {
+        &self.entities[..]
+    }
+
+    #[inline(always)]
     pub fn clips(&self) -> &[Handle<Clip>] {
         &self.clips[..]
     }
@@ -396,13 +399,17 @@ pub(crate) fn animator_update_system(
     mut animators_query: Query<(Entity, &mut Animator, Option<&AnimatorBlending>)>,
     children_query: Query<&Children>,
     name_query: Query<(&Parent, &Name)>,
-    // TODO: or one or the other changed!
-    parent_or_name_changed_query: Query<(Option<&Parent>, &Name), (Changed<Parent>, Changed<Name>)>,
+    parent_or_name_changed_query: Query<
+        (Option<&Parent>, &Name),
+        Or<(Changed<Parent>, Changed<Name>)>,
+    >,
+    entity_deleted_query: Query<Empty>,
+    parent_or_name_removed_query: Query<Empty, Or<(Without<Parent>, Without<Name>)>>,
 ) {
     let __span = tracing::info_span!("animator_update_system");
     let __guard = __span.enter();
 
-    // ? NOTE: Changing a clip on fly is supported, but very expensive so use with caution
+    // ? NOTE: Changing a clip on fly is supported, but is expensive so use with caution
     // TODO: Put a warning somewhere in the docs on how expensive is changing a clip on the fly
     // Query all clips that changed and remove their binds from the animator
     state.clips_modified.clear();
@@ -443,21 +450,41 @@ pub(crate) fn animator_update_system(
                 continue;
             }
 
+            let mut remove_entity = false;
             let entity = animator.entities[entity_index];
 
-            // ? NOTE: Use a changed events for both parent and name because name
-            // ? comparison isn't fast, as result it won't notice changes before the
-            // ? POST_UPDATE stage
-            if let Some((entity_parent, entity_name)) = entity
-                .map(|entity| parent_or_name_changed_query.get(entity).ok())
-                .flatten()
-            {
-                let parent = animator.entities[*parent_index as usize];
-                if entity_parent.map(|p| p.0) != parent || name != entity_name {
-                    animator.entities[entity_index] = None;
-                    animator.missing_entities = true;
+            if let Some(entity) = entity {
+                if entity_deleted_query.get(entity).is_err() {
+                    // Entity deleted
+                    remove_entity = true;
+                } else if parent_or_name_removed_query.get(entity).is_ok() {
+                    // Parent or Name component where removed from entity
+                    remove_entity = true;
+                } else if let Ok((entity_parent, entity_name)) =
+                    parent_or_name_changed_query.get(entity)
+                {
+                    // Parent or Name changed
+                    // ? NOTE: Use a changed events for both parent and name because name
+                    // ? comparison isn't fast, as result it won't notice changes before the
+                    // ? POST_UPDATE stage
+
+                    let parent = animator.entities[*parent_index as usize];
+                    if entity_parent.map(|p| p.0) != parent || name != entity_name {
+                        remove_entity = true;
+                    }
                 }
             }
+
+            // Remove entity
+            if remove_entity {
+                let animator_entities = &mut animator.entities;
+                animator
+                    .hierarchy
+                    .depth_first(entity_index as u16, &mut |index, _| {
+                        animator_entities[index as usize] = None;
+                    });
+                animator.missing_entities = true;
+            }
         }
 
         // TODO: Figure out how expensive this might be with a couple of entities missing
@@ -486,7 +513,9 @@ pub(crate) fn animator_update_system(
 
             // Update missing entities state
             animator.missing_entities = missing;
-            println!("missing entities ...");
+
+            // TODO: Better warning messages
+            //warn!("missing entities");
         }
 
         // Make run for the binds
@@ -570,10 +599,27 @@ pub(crate) fn animator_update_system(
 // TODO: This should be auto derived using the "Animated" trait that just returns
 // a system able to animate the said component. Use "AnimatedAsset" for asset handles!
 
+// pub trait AnimatedComponent: Component + Sized {
+//     fn animator_update_system(
+//         clips: Res<Assets<Clip>>,
+//         animators_query: Query<(&mut Animator, &mut AnimatorBlending)>,
+//         component_query: Query<&mut Self>,
+//     );
+// }
+
+// pub trait AnimatedAsset: bevy_asset::Asset + Sized {
+//     fn animator_update_system(
+//         clips: Res<Assets<Clip>>,
+//         animators_query: Query<(&mut Animator, &mut AnimatorBlending)>,
+//         assets: ResMut<Assets<Self>>,
+//         component_query: Query<&mut Handle<Self>>,
+//     );
+// }
+
 pub(crate) fn animator_transform_update_system(
     clips: Res<Assets<Clip>>,
     mut animators_query: Query<(&mut Animator, &mut AnimatorBlending)>,
-    transform_query: Query<(&mut Transform,)>,
+    transform_query: Query<&mut Transform>,
 ) {
     let __span = tracing::info_span!("animator_transform_update_system");
     let __guard = __span.enter();
@@ -583,7 +629,6 @@ pub(crate) fn animator_transform_update_system(
     for (mut animator, mut animator_blend) in animators_query.iter_mut() {
         let mut blend_group = animator_blend.begin_blending();
 
-        // ~15us
         components.clear();
 
         // ? NOTE: Lazy get each component is worse than just fetching everything at once
@@ -592,12 +637,11 @@ pub(crate) fn animator_transform_update_system(
         // currently has the mutability over the Transform type, so no race conditions
         // are possible
         unsafe {
-            for entity in &animator.entities {
+            for entity in animator.entities() {
                 components.push(
                     entity
                         .map(|entity| transform_query.get_unsafe(entity).ok())
-                        .flatten()
-                        .map(|(transform,)| transform),
+                        .flatten(),
                 );
             }
         }
@@ -615,7 +659,6 @@ pub(crate) fn animator_transform_update_system(
                 let keyframes = &mut layer.keyframes;
                 keyframes.resize(clip.len(), 0);
 
-                // ~23us
                 if let Some(curves) = clip
                     .get("Transform.translation")
                     .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
@@ -624,16 +667,13 @@ pub(crate) fn animator_transform_update_system(
                     for (entity_index, (curve_index, curve)) in curves.iter() {
                         let entity_index = entities_map[entity_index as usize];
                         if let Some(ref mut component) = components[entity_index as usize] {
-                            // TODO: I'm not noticing any discernible performance change from using just `sample` so there's probably something wrong
                             let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
                             keyframes[*curve_index] = k;
-                            // let v = curve.sample(time);
                             component.translation.blend(&mut blend_group, v, w);
                         }
                     }
                 }
 
-                // ~23us
                 if let Some(curves) = clip
                     .get("Transform.rotation")
                     .map(|curve_untyped| curve_untyped.downcast_ref::<Quat>())
@@ -644,13 +684,11 @@ pub(crate) fn animator_transform_update_system(
                         if let Some(ref mut component) = components[entity_index as usize] {
                             let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
                             keyframes[*curve_index] = k;
-                            // let v = curve.sample(time);
                             component.rotation.blend(&mut blend_group, v, w);
                         }
                     }
                 }
 
-                // ~23us
                 if let Some(curves) = clip
                     .get("Transform.scale")
                     .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
@@ -661,7 +699,6 @@ pub(crate) fn animator_transform_update_system(
                         if let Some(ref mut component) = components[entity_index as usize] {
                             let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
                             keyframes[*curve_index] = k;
-                            //let v = curve.sample(time);
                             component.scale.blend(&mut blend_group, v, w);
                         }
                     }
@@ -675,194 +712,465 @@ pub(crate) fn animator_transform_update_system(
 
 // TODO: Port tests from the generic unsafe
 
-// #[cfg(test)]
-// #[allow(dead_code)]
-// mod tests {
-//     use super::*;
-//     use crate::curve::Curve;
-//     use bevy_ecs::{ArchetypeComponent, TypeAccess};
-
-//     struct AnimatorTestBench {
-//         app: bevy_app::App,
-//         entities: Vec<Entity>,
-//         schedule: bevy_ecs::Schedule,
-//     }
-
-//     impl AnimatorTestBench {
-//         fn new() -> Self {
-//             let mut app_builder = bevy_app::App::build();
-//             app_builder
-//                 .add_plugin(bevy_type_registry::TypeRegistryPlugin::default())
-//                 .add_plugin(bevy_core::CorePlugin::default())
-//                 .add_plugin(bevy_app::ScheduleRunnerPlugin::default())
-//                 .add_plugin(bevy_asset::AssetPlugin)
-//                 .add_plugin(bevy_transform::TransformPlugin)
-//                 .add_plugin(crate::AnimationPlugin);
-
-//             let mut world = World::new();
-//             let mut world_builder = world.build();
-//             let base = (
-//                 GlobalTransform::default(),
-//                 Transform::from_translation(Vec3::new(0.0, 1.0, 0.0)),
-//             );
-
-//             // Create animator and assign some clips
-//             let mut animator = Animator::default();
-//             {
-//                 let mut clip_a = Clip::default();
-//                 clip_a.add_animated_prop(
-//                     "@Transform.translation",
-//                     Curve::from_linear(0.0, 1.0, Vec3::unit_x(), -Vec3::unit_x()),
-//                 );
-//                 let rot = Curve::from_constant(Quat::identity());
-//                 clip_a.add_animated_prop("@Transform.rotation", rot.clone());
-//                 clip_a.add_animated_prop("/Node1@Transform.rotation", rot.clone());
-//                 clip_a.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
-
-//                 let mut clip_b = Clip::default();
-//                 clip_b.add_animated_prop(
-//                     "@Transform.translation",
-//                     Curve::from_constant(Vec3::zero()),
-//                 );
-//                 let rot = Curve::from_linear(
-//                     0.0,
-//                     1.0,
-//                     Quat::from_axis_angle(Vec3::unit_z(), 0.1),
-//                     Quat::from_axis_angle(Vec3::unit_z(), -0.1),
-//                 );
-//                 clip_b.add_animated_prop("@Transform.rotation", rot.clone());
-//                 clip_b.add_animated_prop("/Node1@Transform.rotation", rot.clone());
-//                 clip_b.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
-
-//                 let mut clips = app_builder
-//                     .resources_mut()
-//                     .get_mut::<Assets<Clip>>()
-//                     .unwrap();
-//                 let clip_a = clips.add(clip_a);
-//                 let clip_b = clips.add(clip_b);
-
-//                 animator.add_layer(clip_a, 0.5);
-//                 animator.add_layer(clip_b, 0.5);
-//             }
-
-//             let mut entities = vec![];
-//             entities.push(
-//                 world_builder
-//                     .spawn(base.clone())
-//                     .with(Name::from_str("Root"))
-//                     .with(animator)
-//                     .current_entity
-//                     .unwrap(),
-//             );
-//             world_builder.with_children(|world_builder| {
-//                 entities.push(
-//                     world_builder
-//                         .spawn(base.clone())
-//                         .with(Name::from_str("Node1"))
-//                         .current_entity()
-//                         .unwrap(),
-//                 );
-
-//                 world_builder.with_children(|world_builder| {
-//                     entities.push(
-//                         world_builder
-//                             .spawn(base.clone())
-//                             .with(Name::from_str("Node2"))
-//                             .current_entity()
-//                             .unwrap(),
-//                     );
-
-//                     world_builder.with_children(|world_builder| {
-//                         entities.push(
-//                             world_builder
-//                                 .spawn(base.clone())
-//                                 .with(Name::from_str("Node3"))
-//                                 .current_entity()
-//                                 .unwrap(),
-//                         );
-//                     });
-//                 });
-//             });
-
-//             app_builder.set_world(world);
-
-//             let mut schedule = bevy_ecs::Schedule::default();
-//             schedule.add_stage("update");
-//             schedule.add_stage_after("update", "post_update");
-//             schedule.add_system_to_stage("update", animator_update_system);
-//             schedule.add_system_to_stage("update", animator_transform_update_system);
-//             schedule.add_system_to_stage("post_update", parent_update_system);
-//             //schedule.add_system_to_stage("update", transform_propagate_system);
-
-//             schedule.initialize(&mut app_builder.app.world, &mut app_builder.app.resources);
-//             schedule.run(&mut app_builder.app.world, &mut app_builder.app.resources);
-
-//             Self {
-//                 app: app_builder.app,
-//                 entities,
-//                 schedule,
-//             }
-//         }
-
-//         fn run(&mut self) {
-//             self.schedule
-//                 .run(&mut self.app.world, &mut self.app.resources);
-//         }
-//     }
-
-//     #[test]
-//     #[cfg(feature = "extra-profiling-tests")]
-//     fn test_bench_update() {
-//         // ? NOTE: Mimics a basic system update behavior good for pref since criterion will pollute the
-//         // ? annotations with many expensive instructions
-//         let mut test_bench = AnimatorTestBench::new();
-//         test_bench.run();
-//         test_bench.run();
-
-//         // let mut schedule = bevy_ecs::Schedule::default();
-//         // schedule.add_stage("update");
-//         // schedule.add_system_to_stage("update", animator_transform_update_system);
-//         // schedule.initialize(&mut test_bench.app.world, &mut test_bench.app.resources);
-
-//         // let mut transform_system: Box<dyn System<Input = (), Output = ()>> =
-//         //     Box::new(animator_transform_update_system.system());
-
-//         // transform_system.initialize(&mut test_bench.app.world, &mut test_bench.app.resources);
-
-//         // fn animator_transform_update_system(
-//         //     clips: Res<Assets<Clip>>,
-//         //     mut animators_query: Query<(&Animator, &mut KeyframeCache, &mut AnimatorBlending)>,
-//         //     transform_query: Query<(&mut Transform,)>,
-//         // );
-
-//         let type_access = <TypeAccess<ArchetypeComponent>>::new(vec![], vec![]);
-//         for _ in 0..100_000 {
-//             // // Time tick
-//             // {
-//             //     let mut time = test_bench.app.resources.get_mut::<Time>().unwrap();
-//             //     time.delta_seconds += 0.016;
-//             //     time.delta_seconds_f64 += 0.016;
-//             // }
-
-//             //schedule.run(&mut test_bench.app.world, &mut test_bench.app.resources);
-
-//             //transform_system.run((), &mut test_bench.app.world, &mut test_bench.app.resources);
-
-//             // Fetching
-//             let clips = &*test_bench.app.resources.get::<Assets<Clip>>().unwrap();
-//             let clips =
-//                 unsafe { Res::new(std::ptr::NonNull::new(clips as *const _ as *mut _).unwrap()) };
-//             let animators_query = unsafe {
-//                 <Query<(&Animator, &mut KeyframeCache, &mut AnimatorBlending)>>::new(
-//                     &test_bench.app.world,
-//                     &type_access,
-//                 )
-//             };
-//             let transform_query =
-//                 unsafe { <Query<(&mut Transform,)>>::new(&test_bench.app.world, &type_access) };
-
-//             // Running
-//             animator_transform_update_system(clips, animators_query, transform_query);
-//         }
-//     }
-// }
+#[cfg(test)]
+#[allow(dead_code)]
+mod tests {
+    use super::*;
+    use crate::curve::Curve;
+    use bevy_asset::AddAsset;
+    use bevy_pbr::prelude::StandardMaterial;
+    use bevy_render::prelude::Mesh;
+
+    struct AnimatorTestBench {
+        app: bevy_app::App,
+        entities: Vec<Entity>,
+    }
+
+    impl AnimatorTestBench {
+        fn new() -> Self {
+            let mut app_builder = bevy_app::App::build();
+            app_builder
+                .add_plugin(bevy_reflect::ReflectPlugin::default())
+                .add_plugin(bevy_core::CorePlugin::default())
+                .add_plugin(bevy_app::ScheduleRunnerPlugin::default())
+                .add_plugin(bevy_asset::AssetPlugin::default())
+                .add_asset::<Mesh>()
+                .add_asset::<StandardMaterial>()
+                .add_plugin(bevy_transform::TransformPlugin::default())
+                .add_plugin(crate::AnimationPlugin::default());
+
+            let mut world = World::new();
+            let mut world_builder = world.build();
+            let base = (
+                GlobalTransform::default(),
+                Transform::from_translation(Vec3::new(0.0, 1.0, 0.0)),
+            );
+
+            // Create animator and assign some clips
+            let mut animator = Animator::default();
+            {
+                let mut clip_a = Clip::default();
+                clip_a.add_animated_prop(
+                    "@Transform.translation",
+                    Curve::from_linear(0.0, 1.0, Vec3::unit_x(), -Vec3::unit_x()),
+                );
+                let rot = Curve::from_constant(Quat::identity());
+                clip_a.add_animated_prop("@Transform.rotation", rot.clone());
+                clip_a.add_animated_prop("/Node1@Transform.rotation", rot.clone());
+                clip_a.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
+
+                let mut clip_b = Clip::default();
+                clip_b.add_animated_prop(
+                    "@Transform.translation",
+                    Curve::from_constant(Vec3::zero()),
+                );
+                let rot = Curve::from_linear(
+                    0.0,
+                    1.0,
+                    Quat::from_axis_angle(Vec3::unit_z(), 0.1),
+                    Quat::from_axis_angle(Vec3::unit_z(), -0.1),
+                );
+                clip_b.add_animated_prop("@Transform.rotation", rot.clone());
+                clip_b.add_animated_prop("/Node1@Transform.rotation", rot.clone());
+                clip_b.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
+
+                let mut clips = app_builder
+                    .resources_mut()
+                    .get_mut::<Assets<Clip>>()
+                    .unwrap();
+                let clip_a = clips.add(clip_a);
+                let clip_b = clips.add(clip_b);
+
+                animator.add_layer(clip_a, 0.5);
+                animator.add_layer(clip_b, 0.5);
+            }
+
+            let mut entities = vec![];
+            entities.push(
+                world_builder
+                    .spawn(base.clone())
+                    .with(Name::from_str("Root"))
+                    .with(animator)
+                    .current_entity
+                    .unwrap(),
+            );
+            world_builder.with_children(|world_builder| {
+                entities.push(
+                    world_builder
+                        .spawn(base.clone())
+                        .with(Name::from_str("Node1"))
+                        .current_entity()
+                        .unwrap(),
+                );
+
+                world_builder.with_children(|world_builder| {
+                    entities.push(
+                        world_builder
+                            .spawn(base.clone())
+                            .with(Name::from_str("Node2"))
+                            .current_entity()
+                            .unwrap(),
+                    );
+
+                    world_builder.with_children(|world_builder| {
+                        entities.push(
+                            world_builder
+                                .spawn(base.clone())
+                                .with(Name::from_str("Node3"))
+                                .current_entity()
+                                .unwrap(),
+                        );
+                    });
+                });
+            });
+
+            app_builder.set_world(world);
+            app_builder.app.update();
+
+            Self {
+                app: app_builder.app,
+                entities,
+            }
+        }
+
+        fn run(&mut self) {
+            self.app.update();
+        }
+
+        fn animator(&mut self) -> Mut<Animator> {
+            self.app
+                .world
+                .get_mut::<Animator>(self.entities[0])
+                .unwrap()
+        }
+    }
+
+    #[test]
+    fn entity_deleted() {
+        // Tests for hierarch change deletion and creation of some entity that is been animated
+        let mut test_bench = AnimatorTestBench::new();
+
+        test_bench
+            .animator()
+            .entities()
+            .iter()
+            .enumerate()
+            .for_each(|(index, entity)| assert!(entity.is_some(), "missing entity {}", index,));
+
+        // delete "Node1"
+        test_bench
+            .app
+            .world
+            .despawn(test_bench.entities[1])
+            .unwrap();
+
+        // Tick
+        test_bench.run();
+
+        assert!(
+            test_bench.animator().entities()[0].is_some(),
+            "root entity missing"
+        );
+        assert_eq!(
+            &test_bench.animator().entities()[1..],
+            &[None, None][..],
+            "entities still binded"
+        );
+
+        // Re-add "Node1"
+        test_bench.entities[1] = test_bench
+            .app
+            .world
+            .build()
+            .spawn((
+                GlobalTransform::default(),
+                Transform::from_translation(Vec3::new(0.0, 1.0, 0.0)),
+                Name::from_str("Node1"),
+                Parent(test_bench.entities[0]),
+            ))
+            .current_entity
+            .unwrap();
+
+        *test_bench
+            .app
+            .world
+            .get_mut::<Parent>(test_bench.entities[2])
+            .unwrap() = Parent(test_bench.entities[1]);
+
+        // Tick
+        // ! FIXME: May take one frame to bind the missing properties because
+        // ! the `parent_update_system` must run in order to update the `Children` component
+        test_bench.run();
+        test_bench.run();
+
+        test_bench
+            .animator()
+            .entities()
+            .iter()
+            .enumerate()
+            .for_each(|(index, entity)| assert!(entity.is_some(), "missing entity {}", index,));
+    }
+
+    #[test]
+    fn entity_parent_changed() {
+        // Tests for hierarch change deletion and creation of some entity that is been animated
+        let mut test_bench = AnimatorTestBench::new();
+
+        test_bench
+            .animator()
+            .entities()
+            .iter()
+            .enumerate()
+            .for_each(|(index, entity)| assert!(entity.is_some(), "missing entity {}", index,));
+
+        // Change parent of node "Node1"
+        let new_parent = test_bench
+            .app
+            .world
+            .build()
+            .spawn(())
+            .current_entity
+            .unwrap();
+
+        *test_bench
+            .app
+            .world
+            .get_mut::<Parent>(test_bench.entities[1])
+            .unwrap() = Parent(new_parent);
+
+        // Tick
+        test_bench.run();
+
+        assert!(
+            test_bench.animator().entities()[0].is_some(),
+            "root entity missing"
+        );
+        assert_eq!(
+            &test_bench.animator().entities()[1..],
+            &[None, None][..],
+            "entities still binded"
+        );
+
+        // Re-parent "Node1"
+        *test_bench
+            .app
+            .world
+            .get_mut::<Parent>(test_bench.entities[1])
+            .unwrap() = Parent(test_bench.entities[0]);
+
+        // Tick
+        // ! FIXME: Takes one frame to bind the missing properties because
+        // ! the `parent_update_system` must run in order to update the `Children` component
+        test_bench.run();
+        test_bench.run();
+
+        test_bench
+            .animator()
+            .entities()
+            .iter()
+            .enumerate()
+            .for_each(|(index, entity)| assert!(entity.is_some(), "missing entity {}", index,));
+    }
+
+    #[test]
+    fn entity_parent_component_removed() {
+        // Tests for hierarch change deletion and creation of some entity that is been animated
+        let mut test_bench = AnimatorTestBench::new();
+
+        test_bench
+            .animator()
+            .entities()
+            .iter()
+            .enumerate()
+            .for_each(|(index, entity)| assert!(entity.is_some(), "missing entity {}", index,));
+
+        test_bench
+            .app
+            .world
+            .remove_one::<Parent>(test_bench.entities[1])
+            .unwrap();
+
+        // Tick
+        test_bench.run();
+
+        assert!(
+            test_bench.animator().entities()[0].is_some(),
+            "root entity missing"
+        );
+        assert_eq!(
+            &test_bench.animator().entities()[1..],
+            &[None, None][..],
+            "entities still binded"
+        );
+
+        // Re-parent "Node1"
+        test_bench
+            .app
+            .world
+            .insert_one(test_bench.entities[1], Parent(test_bench.entities[0]))
+            .unwrap();
+
+        // Tick
+        // ! FIXME: Takes one frame to bind the missing properties because
+        // ! the `parent_update_system` must run in order to update the `Children` component
+        test_bench.run();
+        test_bench.run();
+
+        test_bench
+            .animator()
+            .entities()
+            .iter()
+            .enumerate()
+            .for_each(|(index, entity)| assert!(entity.is_some(), "missing entity {}", index,));
+    }
+
+    #[test]
+    fn entity_renamed() {
+        // Tests for hierarch change deletion and creation of some entity that is been animated
+        let mut test_bench = AnimatorTestBench::new();
+
+        test_bench
+            .animator()
+            .entities()
+            .iter()
+            .enumerate()
+            .for_each(|(index, entity)| assert!(entity.is_some(), "missing entity {}", index,));
+
+        *test_bench
+            .app
+            .world
+            .get_mut::<Name>(test_bench.entities[1])
+            .unwrap() = Name::from_str("Spine1");
+
+        // Tick
+        test_bench.run();
+
+        assert!(
+            test_bench.animator().entities()[0].is_some(),
+            "root entity missing"
+        );
+        assert_eq!(
+            &test_bench.animator().entities()[1..],
+            &[None, None][..],
+            "entities still binded"
+        );
+
+        *test_bench
+            .app
+            .world
+            .get_mut::<Name>(test_bench.entities[1])
+            .unwrap() = Name::from_str("Node1");
+
+        // Tick
+        // ! FIXME: Takes one frame to bind the missing properties because
+        // ! the `parent_update_system` must run in order to update the `Children` component
+        test_bench.run();
+        test_bench.run();
+
+        test_bench
+            .animator()
+            .entities()
+            .iter()
+            .enumerate()
+            .for_each(|(index, entity)| assert!(entity.is_some(), "missing entity {}", index,));
+    }
+
+    #[test]
+    fn entity_name_component_removed() {
+        // Tests for hierarch change deletion and creation of some entity that is been animated
+        let mut test_bench = AnimatorTestBench::new();
+
+        test_bench
+            .animator()
+            .entities()
+            .iter()
+            .enumerate()
+            .for_each(|(index, entity)| assert!(entity.is_some(), "missing entity {}", index,));
+
+        test_bench
+            .app
+            .world
+            .remove_one::<Name>(test_bench.entities[1])
+            .unwrap();
+
+        // Tick
+        test_bench.run();
+
+        assert!(
+            test_bench.animator().entities()[0].is_some(),
+            "root entity missing"
+        );
+        assert_eq!(
+            &test_bench.animator().entities()[1..],
+            &[None, None][..],
+            "entities still binded"
+        );
+
+        test_bench
+            .app
+            .world
+            .insert_one(test_bench.entities[1], Name::from_str("Node1"))
+            .unwrap();
+
+        // Tick
+        // ! FIXME: Takes one frame to bind the missing properties because
+        // ! the `parent_update_system` must run in order to update the `Children` component
+        test_bench.run();
+        test_bench.run();
+
+        test_bench
+            .animator()
+            .entities()
+            .iter()
+            .enumerate()
+            .for_each(|(index, entity)| assert!(entity.is_some(), "missing entity {}", index,));
+    }
+
+    #[test]
+    fn clip_changed() {
+        // Tests for hierarch change deletion and creation of some entity that is been animated
+        let mut test_bench = AnimatorTestBench::new();
+
+        test_bench
+            .animator()
+            .entities()
+            .iter()
+            .enumerate()
+            .for_each(|(index, entity)| assert!(entity.is_some(), "missing entity {}", index,));
+
+        test_bench.run();
+
+        // Modify clip
+        {
+            let clip_a_handle = test_bench.animator().clips()[0].clone();
+            let mut clips = test_bench.app.resources.get_mut::<Assets<Clip>>().unwrap();
+            let clip_a = clips.get_mut(clip_a_handle).unwrap();
+            clip_a.add_animated_prop(
+                "/Node3/@Transform.translation",
+                Curve::from_linear(0.0, 1.0, Vec3::unit_z(), -Vec3::unit_z()),
+            );
+        }
+
+        test_bench.run();
+
+        assert_eq!(test_bench.animator().entities().len(), 4);
+
+        // Spawn entity
+        test_bench.app.world.build().spawn((
+            GlobalTransform::default(),
+            Transform::from_translation(Vec3::new(0.0, 1.0, 0.0)),
+            Name::from_str("Node3"),
+            Parent(test_bench.entities[0]),
+        ));
+
+        test_bench.run();
+        test_bench.run();
+
+        test_bench
+            .animator()
+            .entities()
+            .iter()
+            .enumerate()
+            .for_each(|(index, entity)| assert!(entity.is_some(), "missing entity {}", index,));
+    }
+}
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 8a959bcbd1632..ccd0c015688f3 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1,8 +1,9 @@
 use bevy_app::prelude::*;
-use bevy_asset::AddAsset;
+use bevy_asset::{AddAsset, Assets};
 use bevy_reflect::RegisterTypeBuilder;
 
 mod custom;
+mod help;
 mod hierarchy;
 mod skinned_mesh;
 
@@ -38,11 +39,10 @@ impl Plugin for AnimationPlugin {
         app.add_stage_after(stage::UPDATE, stage::ANIMATE);
 
         // Generic animation
-        app.add_asset::<prelude::Clip>()
+        app.add_asset::<Clip>()
             //.add_asset_loader(ClipLoader)
-            .register_type::<prelude::Animator>()
-            // .add_system_to_stage(stage::ANIMATE, animator_binding_system)
-            // .add_system_to_stage(stage::ANIMATE, animator_update_system);
+            .register_type::<Animator>()
+            .add_system_to_stage(stage::ANIMATE, Assets::<Clip>::asset_event_system) // ? NOTE: Fix asset event handle
             .add_system_to_stage(stage::ANIMATE, animator_update_system)
             .add_system_to_stage(stage::ANIMATE, animator_transform_update_system);
 

From 9a5fd37712fbc4ca1d3f3ff27b8bf523f8e07989 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 20 Dec 2020 19:03:49 -0300
Subject: [PATCH 050/153] forget to add help::Empty component

---
 crates/bevy_animation/src/help.rs | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 crates/bevy_animation/src/help.rs

diff --git a/crates/bevy_animation/src/help.rs b/crates/bevy_animation/src/help.rs
new file mode 100644
index 0000000000000..8142c0f4728c5
--- /dev/null
+++ b/crates/bevy_animation/src/help.rs
@@ -0,0 +1,31 @@
+use bevy_ecs::{Fetch, QueryAccess, ReadOnlyFetch, WorldQuery};
+
+/// Especial component type that every entity has, used
+/// to build queries where the components doesn't matter.
+#[derive(Debug, Copy, Clone)]
+pub struct Empty;
+
+impl WorldQuery for Empty {
+    type Fetch = EmptyFetch;
+}
+
+pub struct EmptyFetch;
+
+impl<'a> Fetch<'a> for EmptyFetch {
+    type Item = Empty;
+    const DANGLING: Self = EmptyFetch;
+
+    fn access() -> QueryAccess {
+        QueryAccess::None
+    }
+
+    unsafe fn get(_archetype: &'a bevy_ecs::Archetype, _offset: usize) -> Option<Self> {
+        Some(EmptyFetch)
+    }
+
+    unsafe fn fetch(&self, _n: usize) -> Self::Item {
+        Empty
+    }
+}
+
+unsafe impl ReadOnlyFetch for EmptyFetch {}

From 28bb39d7988b25e364cd68c3cb572a83223eb148 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 20 Dec 2020 20:04:00 -0300
Subject: [PATCH 051/153] dont care isn't needed

---
 crates/bevy_animation/src/custom.rs |  5 ++---
 crates/bevy_animation/src/help.rs   | 31 -----------------------------
 crates/bevy_animation/src/lib.rs    |  1 -
 crates/bevy_core/Cargo.toml         |  3 +++
 crates/bevy_core/src/name.rs        | 15 +++-----------
 5 files changed, 8 insertions(+), 47 deletions(-)
 delete mode 100644 crates/bevy_animation/src/help.rs

diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 14a546d2aff8f..cd875f95053a3 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -14,7 +14,6 @@ use std::marker::PhantomData;
 
 use crate::blending::{AnimatorBlending, Blend};
 use crate::curve::Curve;
-use crate::help::Empty;
 use crate::hierarchy::Hierarchy;
 use crate::lerping::Lerp;
 
@@ -403,8 +402,8 @@ pub(crate) fn animator_update_system(
         (Option<&Parent>, &Name),
         Or<(Changed<Parent>, Changed<Name>)>,
     >,
-    entity_deleted_query: Query<Empty>,
-    parent_or_name_removed_query: Query<Empty, Or<(Without<Parent>, Without<Name>)>>,
+    entity_deleted_query: Query<Entity>,
+    parent_or_name_removed_query: Query<Entity, Or<(Without<Parent>, Without<Name>)>>,
 ) {
     let __span = tracing::info_span!("animator_update_system");
     let __guard = __span.enter();
diff --git a/crates/bevy_animation/src/help.rs b/crates/bevy_animation/src/help.rs
deleted file mode 100644
index 8142c0f4728c5..0000000000000
--- a/crates/bevy_animation/src/help.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-use bevy_ecs::{Fetch, QueryAccess, ReadOnlyFetch, WorldQuery};
-
-/// Especial component type that every entity has, used
-/// to build queries where the components doesn't matter.
-#[derive(Debug, Copy, Clone)]
-pub struct Empty;
-
-impl WorldQuery for Empty {
-    type Fetch = EmptyFetch;
-}
-
-pub struct EmptyFetch;
-
-impl<'a> Fetch<'a> for EmptyFetch {
-    type Item = Empty;
-    const DANGLING: Self = EmptyFetch;
-
-    fn access() -> QueryAccess {
-        QueryAccess::None
-    }
-
-    unsafe fn get(_archetype: &'a bevy_ecs::Archetype, _offset: usize) -> Option<Self> {
-        Some(EmptyFetch)
-    }
-
-    unsafe fn fetch(&self, _n: usize) -> Self::Item {
-        Empty
-    }
-}
-
-unsafe impl ReadOnlyFetch for EmptyFetch {}
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index ccd0c015688f3..e578b3de8b467 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -3,7 +3,6 @@ use bevy_asset::{AddAsset, Assets};
 use bevy_reflect::RegisterTypeBuilder;
 
 mod custom;
-mod help;
 mod hierarchy;
 mod skinned_mesh;
 
diff --git a/crates/bevy_core/Cargo.toml b/crates/bevy_core/Cargo.toml
index 2e419c07a4d8b..10096a2f05848 100644
--- a/crates/bevy_core/Cargo.toml
+++ b/crates/bevy_core/Cargo.toml
@@ -21,3 +21,6 @@ bevy_math = { path = "../bevy_math", version = "0.3.0" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.3.0", features = ["bevy"] }
 bevy_tasks = { path = "../bevy_tasks", version = "0.3.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+
+# other
+ahash = "0.6.2"
diff --git a/crates/bevy_core/src/name.rs b/crates/bevy_core/src/name.rs
index e056a5a781227..019d20efaa69a 100644
--- a/crates/bevy_core/src/name.rs
+++ b/crates/bevy_core/src/name.rs
@@ -1,16 +1,8 @@
 use bevy_reflect::{Reflect, ReflectComponent};
-use std::ops::Deref;
-
-// NOTE: This is used by the animation system to find the right entity to animate
-
-use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
+use std::ops::Deref;
 
-/// Component containing the name used to identify a entity. Keep in mind that
-/// multiple entities may have the same name.
-///
-/// **NOTE** Once created you can't change it's contents because this `Name`
-/// component also stores the string hash to drastically improve performance comparison
+/// Component used to identify a entity. Stores a hash for faster comparisons
 #[derive(Debug, Clone, Reflect)]
 #[reflect(Component)]
 pub struct Name {
@@ -53,8 +45,7 @@ impl Name {
     }
 
     fn update_hash(&mut self) {
-        // TODO: Try with Fnv and AHash (I'm going to need a test suit for that, but my money is on ahash)
-        let mut hasher = DefaultHasher::default();
+        let mut hasher = ahash::AHasher::default();
         self.name.hash(&mut hasher);
         self.hash = hasher.finish();
     }

From 05558410ae1cb3166b14e2cb6faed5223b6ff429 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Mon, 21 Dec 2020 11:57:35 -0300
Subject: [PATCH 052/153] notes + empty derive crate

---
 .../bevy_animation_derive/Cargo.toml             | 16 ++++++++++++++++
 .../bevy_animation_derive/src/lib.rs             |  1 +
 crates/bevy_animation/src/custom.rs              |  2 ++
 crates/bevy_animation/src/experimental.rs        |  1 +
 4 files changed, 20 insertions(+)
 create mode 100644 crates/bevy_animation/bevy_animation_derive/Cargo.toml
 create mode 100644 crates/bevy_animation/bevy_animation_derive/src/lib.rs

diff --git a/crates/bevy_animation/bevy_animation_derive/Cargo.toml b/crates/bevy_animation/bevy_animation_derive/Cargo.toml
new file mode 100644
index 0000000000000..b59734a00d9ea
--- /dev/null
+++ b/crates/bevy_animation/bevy_animation_derive/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "bevy_animation_derive"
+version = "0.3.0"
+authors = ["Felipe Jorge <felipe.jorge.pereira@gmail.com>"]
+edition = "2018"
+description = "Derive implementations for bevy_animation"
+license = "MIT"
+keywords = ["bevy"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = "1.0"
+proc-macro2 = "1.0"
+quote = "1.0"
\ No newline at end of file
diff --git a/crates/bevy_animation/bevy_animation_derive/src/lib.rs b/crates/bevy_animation/bevy_animation_derive/src/lib.rs
new file mode 100644
index 0000000000000..8b137891791fe
--- /dev/null
+++ b/crates/bevy_animation/bevy_animation_derive/src/lib.rs
@@ -0,0 +1 @@
+
diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index cd875f95053a3..c946ffa677008 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -625,6 +625,8 @@ pub(crate) fn animator_transform_update_system(
 
     let mut components = vec![];
 
+    // ! FIXME: Animator blending and keyframe indexing are stopping the system to run in parallel
+
     for (mut animator, mut animator_blend) in animators_query.iter_mut() {
         let mut blend_group = animator_blend.begin_blending();
 
diff --git a/crates/bevy_animation/src/experimental.rs b/crates/bevy_animation/src/experimental.rs
index 22fa81c362117..0ebb00d94e191 100644
--- a/crates/bevy_animation/src/experimental.rs
+++ b/crates/bevy_animation/src/experimental.rs
@@ -10,6 +10,7 @@ use std::num::NonZeroU16;
 
 ///////////////////////////////////////////////////////////////////////////////
 
+// Maybe useful for when animating assets or sparse components tree
 pub enum FetchState<T> {
     None,
     Missing,

From ea9303631278602cf37b6835c9e9680995d5fb1e Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Mon, 21 Dec 2020 22:37:58 -0300
Subject: [PATCH 053/153] animatior update systems runs in parallel, app
 functions and animated traits

---
 crates/bevy_animation/src/app.rs    |  22 ++++
 crates/bevy_animation/src/custom.rs | 174 +++++++---------------------
 crates/bevy_animation/src/impls.rs  | 104 +++++++++++++++++
 crates/bevy_animation/src/lib.rs    |  11 +-
 4 files changed, 178 insertions(+), 133 deletions(-)
 create mode 100644 crates/bevy_animation/src/app.rs
 create mode 100644 crates/bevy_animation/src/impls.rs

diff --git a/crates/bevy_animation/src/app.rs b/crates/bevy_animation/src/app.rs
new file mode 100644
index 0000000000000..a0886681cd9bf
--- /dev/null
+++ b/crates/bevy_animation/src/app.rs
@@ -0,0 +1,22 @@
+use bevy_app::AppBuilder;
+
+use crate::custom::{AnimatedAsset, AnimatedComponent};
+use crate::stage;
+
+pub trait AddAnimated {
+    fn register_animated_component<T: AnimatedComponent>(&mut self) -> &mut Self;
+
+    fn register_animated_asset<T: AnimatedAsset>(&mut self) -> &mut Self;
+}
+
+impl AddAnimated for AppBuilder {
+    #[inline(always)]
+    fn register_animated_component<T: AnimatedComponent>(&mut self) -> &mut Self {
+        self.add_system_to_stage(stage::ANIMATE, T::animator_update_system)
+    }
+
+    #[inline(always)]
+    fn register_animated_asset<T: AnimatedAsset>(&mut self) -> &mut Self {
+        self.add_system_to_stage(stage::ANIMATE, T::animator_update_system)
+    }
+}
diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index c946ffa677008..955697e4ad926 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -3,16 +3,16 @@ use bevy_app::prelude::{EventReader, Events};
 use bevy_asset::{AssetEvent, Assets, Handle /*HandleUntyped*/};
 use bevy_core::prelude::*;
 use bevy_ecs::prelude::*;
-use bevy_math::prelude::*;
 use bevy_reflect::{Reflect, ReflectComponent, TypeUuid};
 use bevy_transform::prelude::*;
 use fnv::FnvBuildHasher;
 use smallvec::{smallvec, SmallVec};
-use std::any::Any;
-use std::collections::{HashMap, HashSet};
-use std::marker::PhantomData;
+use std::{
+    any::Any,
+    collections::{HashMap, HashSet},
+};
 
-use crate::blending::{AnimatorBlending, Blend};
+use crate::blending::AnimatorBlending;
 use crate::curve::Curve;
 use crate::hierarchy::Hierarchy;
 use crate::lerping::Lerp;
@@ -257,6 +257,18 @@ impl Default for Layer {
     }
 }
 
+impl Layer {
+    #[inline(always)]
+    pub fn keyframes_mut(&mut self) -> &mut [usize] {
+        &mut self.keyframes[..]
+    }
+
+    #[inline(always)]
+    pub unsafe fn keyframes_unsafe(&self) -> &mut [usize] {
+        std::slice::from_raw_parts_mut(self.keyframes.as_ptr() as *mut _, self.keyframes.len())
+    }
+}
+
 #[derive(Default, Debug)]
 struct Bind {
     entity_indexes: Vec<u16>,
@@ -333,40 +345,32 @@ impl Animator {
         &self.clips[..]
     }
 
-    pub fn animate<'a>(&'a mut self) -> LayerIterator<'a> {
+    pub fn animate<'a>(&'a self) -> LayerIterator<'a> {
         LayerIterator {
             index: 0,
             animator: self,
-            marker: PhantomData,
         }
     }
 }
 
 pub struct LayerIterator<'a> {
     index: usize,
-    animator: *mut Animator,
-    marker: PhantomData<&'a ()>,
+    animator: &'a Animator,
 }
 
 impl<'a> Iterator for LayerIterator<'a> {
-    type Item = (usize, &'a mut Layer, &'a Handle<Clip>, &'a [u16]);
+    type Item = (usize, &'a Layer, &'a Handle<Clip>, &'a [u16]);
 
     fn next(&mut self) -> Option<Self::Item> {
         loop {
-            // SAFETY: `self.maker` makes ensure to hold a mutable borrow to the
-            // base `Animator`, with that in mind we can safely mutable iterate over
-            // each valid layer while returning some other immutable data related
-            // to that said layer
-            let animator = unsafe { &mut *(self.animator) };
-
             // Get next layer or stop the iterator
-            let layer = animator.layers.get_mut(self.index)?;
+            let layer = self.animator.layers.get(self.index)?;
             let index = self.index;
             self.index += 1;
 
             let clip_index = layer.clip as usize;
-            if let Some(clip_handle) = animator.clips.get(clip_index) {
-                if let Some(Some(bind)) = animator.bind_clips.get(clip_index) {
+            if let Some(clip_handle) = self.animator.clips.get(clip_index) {
+                if let Some(Some(bind)) = self.animator.bind_clips.get(clip_index) {
                     return Some((index, layer, clip_handle, &bind.entity_indexes[..]));
                 }
 
@@ -572,6 +576,9 @@ pub(crate) fn animator_update_system(
                     // Update time
                     let mut time = layer.time + delta_time * layer.time_scale;
 
+                    // Ensure keyframes capacity
+                    layer.keyframes.resize(clip.len(), 0);
+
                     // Warp mode
                     if clip.warp {
                         // Warp Around
@@ -598,120 +605,26 @@ pub(crate) fn animator_update_system(
 // TODO: This should be auto derived using the "Animated" trait that just returns
 // a system able to animate the said component. Use "AnimatedAsset" for asset handles!
 
-// pub trait AnimatedComponent: Component + Sized {
-//     fn animator_update_system(
-//         clips: Res<Assets<Clip>>,
-//         animators_query: Query<(&mut Animator, &mut AnimatorBlending)>,
-//         component_query: Query<&mut Self>,
-//     );
-// }
-
-// pub trait AnimatedAsset: bevy_asset::Asset + Sized {
-//     fn animator_update_system(
-//         clips: Res<Assets<Clip>>,
-//         animators_query: Query<(&mut Animator, &mut AnimatorBlending)>,
-//         assets: ResMut<Assets<Self>>,
-//         component_query: Query<&mut Handle<Self>>,
-//     );
-// }
-
-pub(crate) fn animator_transform_update_system(
-    clips: Res<Assets<Clip>>,
-    mut animators_query: Query<(&mut Animator, &mut AnimatorBlending)>,
-    transform_query: Query<&mut Transform>,
-) {
-    let __span = tracing::info_span!("animator_transform_update_system");
-    let __guard = __span.enter();
-
-    let mut components = vec![];
-
-    // ! FIXME: Animator blending and keyframe indexing are stopping the system to run in parallel
-
-    for (mut animator, mut animator_blend) in animators_query.iter_mut() {
-        let mut blend_group = animator_blend.begin_blending();
-
-        components.clear();
-
-        // ? NOTE: Lazy get each component is worse than just fetching everything at once
-        // Pre-fetch all transforms to avoid calling get_mut multiple times
-        // SAFETY: each component will be updated one at the time and this function
-        // currently has the mutability over the Transform type, so no race conditions
-        // are possible
-        unsafe {
-            for entity in animator.entities() {
-                components.push(
-                    entity
-                        .map(|entity| transform_query.get_unsafe(entity).ok())
-                        .flatten(),
-                );
-            }
-        }
-
-        for (_, layer, clip_handle, entities_map) in animator.animate() {
-            let w = layer.weight;
-            if w < 1.0e-8 {
-                continue;
-            }
-
-            if let Some(clip) = clips.get(clip_handle) {
-                let time = layer.time;
+// ! FIXME: Theres no way of free memory used by the `Local<AnimatorBlending>` in each system
 
-                // Get keyframes and ensure capacity
-                let keyframes = &mut layer.keyframes;
-                keyframes.resize(clip.len(), 0);
-
-                if let Some(curves) = clip
-                    .get("Transform.translation")
-                    .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
-                    .flatten()
-                {
-                    for (entity_index, (curve_index, curve)) in curves.iter() {
-                        let entity_index = entities_map[entity_index as usize];
-                        if let Some(ref mut component) = components[entity_index as usize] {
-                            let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
-                            keyframes[*curve_index] = k;
-                            component.translation.blend(&mut blend_group, v, w);
-                        }
-                    }
-                }
-
-                if let Some(curves) = clip
-                    .get("Transform.rotation")
-                    .map(|curve_untyped| curve_untyped.downcast_ref::<Quat>())
-                    .flatten()
-                {
-                    for (entity_index, (curve_index, curve)) in curves.iter() {
-                        let entity_index = entities_map[entity_index as usize];
-                        if let Some(ref mut component) = components[entity_index as usize] {
-                            let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
-                            keyframes[*curve_index] = k;
-                            component.rotation.blend(&mut blend_group, v, w);
-                        }
-                    }
-                }
-
-                if let Some(curves) = clip
-                    .get("Transform.scale")
-                    .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
-                    .flatten()
-                {
-                    for (entity_index, (curve_index, curve)) in curves.iter() {
-                        let entity_index = entities_map[entity_index as usize];
-                        if let Some(ref mut component) = components[entity_index as usize] {
-                            let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
-                            keyframes[*curve_index] = k;
-                            component.scale.blend(&mut blend_group, v, w);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    std::mem::drop(__guard);
+pub trait AnimatedComponent: Component + Sized {
+    fn animator_update_system(
+        clips: Res<Assets<Clip>>,
+        animator_blending: Local<AnimatorBlending>,
+        animators_query: Query<&Animator>,
+        component_query: Query<&mut Self>,
+    );
 }
 
-// TODO: Port tests from the generic unsafe
+pub trait AnimatedAsset: bevy_asset::Asset + Sized {
+    fn animator_update_system(
+        clips: Res<Assets<Clip>>,
+        animator_blending: Local<AnimatorBlending>,
+        animators_query: Query<&Animator>,
+        assets: ResMut<Assets<Self>>,
+        component_query: Query<&mut Handle<Self>>,
+    );
+}
 
 #[cfg(test)]
 #[allow(dead_code)]
@@ -719,6 +632,7 @@ mod tests {
     use super::*;
     use crate::curve::Curve;
     use bevy_asset::AddAsset;
+    use bevy_math::prelude::{Quat, Vec3};
     use bevy_pbr::prelude::StandardMaterial;
     use bevy_render::prelude::Mesh;
 
diff --git a/crates/bevy_animation/src/impls.rs b/crates/bevy_animation/src/impls.rs
new file mode 100644
index 0000000000000..ea19d36bb6108
--- /dev/null
+++ b/crates/bevy_animation/src/impls.rs
@@ -0,0 +1,104 @@
+use bevy_asset::Assets;
+use bevy_ecs::prelude::*;
+use bevy_math::prelude::*;
+use bevy_transform::prelude::*;
+
+use crate::blending::{AnimatorBlending, Blend};
+use crate::custom::*;
+
+impl AnimatedComponent for Transform {
+    fn animator_update_system(
+        clips: Res<Assets<Clip>>,
+        mut animator_blending: Local<AnimatorBlending>,
+        animators_query: Query<&Animator>,
+        component_query: Query<&mut Self>,
+    ) {
+        let __span = tracing::info_span!("animator_transform_update_system");
+        let __guard = __span.enter();
+
+        let mut components = vec![];
+
+        for animator in animators_query.iter() {
+            let mut blend_group = animator_blending.begin_blending();
+
+            components.clear();
+
+            // ? NOTE: Lazy get each component is worse than just fetching everything at once
+            // Pre-fetch all transforms to avoid calling get_mut multiple times
+            // SAFETY: each component will be updated one at the time and this function
+            // currently has the mutability over the Transform type, so no race conditions
+            // are possible
+            unsafe {
+                for entity in animator.entities() {
+                    components.push(
+                        entity
+                            .map(|entity| component_query.get_unsafe(entity).ok())
+                            .flatten(),
+                    );
+                }
+            }
+
+            for (_, layer, clip_handle, entities_map) in animator.animate() {
+                let w = layer.weight;
+                if w < 1.0e-8 {
+                    continue;
+                }
+
+                if let Some(clip) = clips.get(clip_handle) {
+                    let time = layer.time;
+
+                    // SAFETY: Never a different thread will modify or access the same index as this one
+                    // ! FIXME: Multiple threads will modifying the same cache line, not sure if this will cause any issue
+                    let keyframes = unsafe { layer.keyframes_unsafe() };
+
+                    if let Some(curves) = clip
+                        .get("Transform.translation")
+                        .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
+                        .flatten()
+                    {
+                        for (entity_index, (curve_index, curve)) in curves.iter() {
+                            let entity_index = entities_map[entity_index as usize];
+                            if let Some(ref mut component) = components[entity_index as usize] {
+                                let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
+                                keyframes[*curve_index] = k;
+                                component.translation.blend(&mut blend_group, v, w);
+                            }
+                        }
+                    }
+
+                    if let Some(curves) = clip
+                        .get("Transform.rotation")
+                        .map(|curve_untyped| curve_untyped.downcast_ref::<Quat>())
+                        .flatten()
+                    {
+                        for (entity_index, (curve_index, curve)) in curves.iter() {
+                            let entity_index = entities_map[entity_index as usize];
+                            if let Some(ref mut component) = components[entity_index as usize] {
+                                let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
+                                keyframes[*curve_index] = k;
+                                component.rotation.blend(&mut blend_group, v, w);
+                            }
+                        }
+                    }
+
+                    if let Some(curves) = clip
+                        .get("Transform.scale")
+                        .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
+                        .flatten()
+                    {
+                        for (entity_index, (curve_index, curve)) in curves.iter() {
+                            let entity_index = entities_map[entity_index as usize];
+                            if let Some(ref mut component) = components[entity_index as usize] {
+                                let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
+                                keyframes[*curve_index] = k;
+                                component.scale.blend(&mut blend_group, v, w);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        std::mem::drop(__guard);
+    }
+}
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index e578b3de8b467..2033fc6018c43 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -2,23 +2,27 @@ use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Assets};
 use bevy_reflect::RegisterTypeBuilder;
 
+mod app;
 mod custom;
 mod hierarchy;
+mod impls;
 mod skinned_mesh;
 
 pub mod blending;
 pub mod curve;
 pub mod lerping;
 
+pub use crate::app::*;
 pub use crate::custom::*;
 pub use crate::hierarchy::Hierarchy;
 pub use crate::skinned_mesh::*;
 
 pub mod prelude {
+    pub use crate::app::AddAnimated;
     pub use crate::blending::AnimatorBlending;
     pub use crate::curve::{Curve, CurveUntyped};
-    pub use crate::custom::Animator;
     pub use crate::custom::Clip;
+    pub use crate::custom::{AnimatedAsset, AnimatedComponent, Animator};
     pub use crate::hierarchy::Hierarchy;
     pub use crate::lerping::Lerp;
     pub use crate::skinned_mesh::{SkinAsset, SkinComponent, SkinDebugger};
@@ -42,8 +46,9 @@ impl Plugin for AnimationPlugin {
             //.add_asset_loader(ClipLoader)
             .register_type::<Animator>()
             .add_system_to_stage(stage::ANIMATE, Assets::<Clip>::asset_event_system) // ? NOTE: Fix asset event handle
-            .add_system_to_stage(stage::ANIMATE, animator_update_system)
-            .add_system_to_stage(stage::ANIMATE, animator_transform_update_system);
+            .add_system_to_stage(stage::ANIMATE, animator_update_system);
+
+        app.register_animated_component::<bevy_transform::prelude::Transform>();
 
         // Skinning
         app.add_asset::<SkinAsset>()

From a77f40a8f20ef90115949c49eb162ba10e8cead5 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Tue, 22 Dec 2020 03:06:46 -0300
Subject: [PATCH 054/153] keyframe now respects cache line boundary (that was a
 bit hard)

---
 crates/bevy_animation/src/curve.rs        |  22 +--
 crates/bevy_animation/src/custom.rs       | 156 ++++++++++++++++++----
 crates/bevy_animation/src/experimental.rs |  14 +-
 crates/bevy_animation/src/impls.rs        |   6 +-
 crates/bevy_animation/src/lib.rs          |   1 +
 5 files changed, 155 insertions(+), 44 deletions(-)

diff --git a/crates/bevy_animation/src/curve.rs b/crates/bevy_animation/src/curve.rs
index 287d0d5ed4a58..a76d63d2b41c1 100644
--- a/crates/bevy_animation/src/curve.rs
+++ b/crates/bevy_animation/src/curve.rs
@@ -74,6 +74,8 @@ impl<T> Curve<T> {
             "samples and values must have the same length"
         );
 
+        assert!(values.len() <= u16::MAX as usize, "too many keyframes");
+
         assert!(samples.len() > 0, "empty curve");
 
         // Make sure the
@@ -143,16 +145,18 @@ where
             self.samples.len() - 1
         };
 
-        self.sample_indexed(index, time).1
+        self.sample_indexed(index as u16, time).1
     }
 
     /// Samples the curve starting from some keyframe index, this make the common case `O(1)`
-    pub fn sample_indexed(&self, mut index: usize, time: f32) -> (usize, T) {
+    ///
+    /// **NOTE** Each keyframe is indexed by a `u16` to reduce memory usage when using the keyframe caching
+    pub fn sample_indexed(&self, mut index: u16, time: f32) -> (u16, T) {
         // Adjust for the current keyframe index
-        let last_index = self.samples.len() - 1;
+        let last_index = (self.samples.len() - 1) as u16;
 
         index = index.max(0).min(last_index);
-        if self.samples[index] < time {
+        if self.samples[index as usize] < time {
             // Forward search
             loop {
                 if index == last_index {
@@ -160,7 +164,7 @@ where
                 }
                 index += 1;
 
-                if self.samples[index] >= time {
+                if self.samples[index as usize] >= time {
                     break;
                 }
             }
@@ -172,7 +176,7 @@ where
                 }
 
                 let i = index - 1;
-                if self.samples[i] <= time {
+                if self.samples[i as usize] <= time {
                     break;
                 }
 
@@ -182,10 +186,10 @@ where
 
         // Lerp the value
         let i = index - 1;
-        let previous_time = self.samples[i];
-        let t = (time - previous_time) / (self.samples[index] - previous_time);
+        let previous_time = self.samples[i as usize];
+        let t = (time - previous_time) / (self.samples[index as usize] - previous_time);
         debug_assert!(t >= 0.0 && t <= 1.0, "t = {} but should be normalized", t); // Checks if it's required to normalize t
-        let value = T::lerp(&self.values[i], &self.values[index], t);
+        let value = T::lerp(&self.values[i as usize], &self.values[index as usize], t);
 
         (index, value)
     }
diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 955697e4ad926..ed47630a9384c 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -1,6 +1,6 @@
 use anyhow::Result;
 use bevy_app::prelude::{EventReader, Events};
-use bevy_asset::{AssetEvent, Assets, Handle /*HandleUntyped*/};
+use bevy_asset::{Asset, AssetEvent, Assets, Handle};
 use bevy_core::prelude::*;
 use bevy_ecs::prelude::*;
 use bevy_reflect::{Reflect, ReflectComponent, TypeUuid};
@@ -17,10 +17,31 @@ use crate::curve::Curve;
 use crate::hierarchy::Hierarchy;
 use crate::lerping::Lerp;
 
+// Starting from Intel's Sandy Bridge, spatial prefetcher is now pulling pairs of 64-byte cache
+// lines at a time, so we have to align to 128 bytes rather than 64.
+//
+// Sources:
+// - https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-optimization-manual.pdf
+// - https://github.com/facebook/folly/blob/1b5288e6eea6df074758f877c849b6e73bbb9fbb/folly/lang/Align.h#L107
+//
+// ARM's big.LITTLE architecture has asymmetric cores and "big" cores have 128 byte cache line size
+// Sources:
+// - https://www.mono-project.com/news/2016/09/12/arm64-icache/
+//
+#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
+const CACHE_SIZE: usize = 128;
+#[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
+const CACHE_SIZE: usize = 64;
+
+/// Defines the number of keyframes that fits inside a cache line;
+const KEYFRAMES_PER_CACHE: usize = CACHE_SIZE / std::mem::size_of::<u16>();
+
+///////////////////////////////////////////////////////////////////////////////
+
 #[derive(Debug)]
 pub struct Curves<T> {
-    property_index: usize,
     entity_indexes: SmallVec<[u16; 8]>,
+    /// Pair of curve and it's index
     curves: Vec<(usize, Curve<T>)>,
 }
 
@@ -75,7 +96,7 @@ impl CurvesUntyped {
     }
 }
 
-// TODO: impl Serialize, Deserialize
+// TODO: impl Serialize, Deserialize using bevy reflect for that
 #[derive(Debug, TypeUuid)]
 #[uuid = "79e2ea58-8bf7-43af-8219-5898edb02f80"]
 pub struct Clip {
@@ -89,9 +110,13 @@ pub struct Clip {
     duration: f32,
     hierarchy: Hierarchy,
     // ? NOTE: AHash performed worse than FnvHasher
-    properties: HashMap<String, CurvesUntyped, FnvBuildHasher>,
+    /// Each curve and keyframe cache index mapped by property name  
+    properties: HashMap<String, (usize, CurvesUntyped), FnvBuildHasher>,
     /// Number of animated properties
     len: usize,
+    /// Number of cache lines currently been used to organize the keyframe
+    /// caching into buckets to be accessed by many different threads at the same time
+    cache: usize,
 }
 
 // fn clip_default_warp() -> bool {
@@ -106,6 +131,7 @@ impl Default for Clip {
             hierarchy: Hierarchy::default(),
             properties: HashMap::default(),
             len: 0,
+            cache: 0,
         }
     }
 }
@@ -115,8 +141,11 @@ impl Clip {
     /// where the left side `@` defines a path to the entity to animate,
     /// while the right side the path to a property to animate starting from the component.
     ///
-    /// **NOTE** This is a expensive function
-    pub fn add_animated_prop<T>(&mut self, property_path: &str, mut curve: Curve<T>)
+    /// **NOTE** This is a expensive function;
+    ///
+    /// **NOTE** You can safely ignore the return value as it's only used for assertions during tests;
+    /// The return value is the assigned curve index in cache line bucket.
+    pub fn add_animated_prop<T>(&mut self, property_path: &str, mut curve: Curve<T>) -> usize
     where
         T: Lerp + Clone + Send + Sync + 'static,
     {
@@ -128,7 +157,7 @@ impl Clip {
         let (entity_index, _) = self.hierarchy.get_or_insert_entity(path.0);
         let target_name = path.1.split_at(1).1;
 
-        if let Some(curves_untyped) = self.properties.get_mut(target_name) {
+        if let Some((cache_index, curves_untyped)) = self.properties.get_mut(target_name) {
             let curves = curves_untyped
                 .downcast_mut::<T>()
                 .expect("properties can't have the same name and different curve types");
@@ -139,8 +168,11 @@ impl Clip {
                 .iter()
                 .position(|index| *index == entity_index)
             {
+                let (curve_index, curve_untyped) = &mut curves.curves[i];
+                let curve_index = *curve_index;
+
                 // Found a property equal to the one been inserted, next replace the curve
-                std::mem::swap(&mut curves.curves[i].1, &mut curve);
+                std::mem::swap(curve_untyped, &mut curve);
 
                 // Update curve duration in two stages
                 let duration = curves.calculate_duration();
@@ -152,36 +184,50 @@ impl Clip {
                 // Drop the curves untyped (which as a mut borrow) and update the total duration
                 std::mem::drop(curves_untyped);
                 self.duration = self.calculate_duration();
+
+                return curve_index;
             } else {
-                let curve_index = self.len;
+                *cache_index += 1;
+                if (*cache_index % KEYFRAMES_PER_CACHE) == 0 {
+                    // No more spaces left in the current cache line
+                    *cache_index = self.cache * KEYFRAMES_PER_CACHE;
+                    self.cache += 1;
+                }
+
                 self.len += 1;
 
                 // Append newly added curve
                 let duration = curve.duration();
 
-                curves.curves.push((curve_index, curve));
+                curves.curves.push((*cache_index, curve));
                 curves.entity_indexes.push(entity_index);
                 std::mem::drop(curves);
 
                 self.len += 1;
                 self.duration = self.duration.max(duration);
                 curves_untyped.duration = curves_untyped.duration.max(duration);
+
+                return *cache_index;
             }
-            return;
         }
 
-        self.duration = self.duration.max(curve.duration());
-        let property_index = self.properties.len();
-        let curve_index = self.len;
+        let cache_index = self.cache * KEYFRAMES_PER_CACHE;
+        self.cache += 1;
         self.len += 1;
+
+        self.duration = self.duration.max(curve.duration());
         self.properties.insert(
             target_name.to_string(),
-            CurvesUntyped::new(Curves {
-                property_index,
-                curves: vec![(curve_index, curve)],
-                entity_indexes: smallvec![entity_index],
-            }),
+            (
+                cache_index,
+                CurvesUntyped::new(Curves {
+                    curves: vec![(cache_index, curve)],
+                    entity_indexes: smallvec![entity_index],
+                }),
+            ),
         );
+
+        cache_index
     }
 
     /// Number of animated properties in this clip
@@ -190,6 +236,12 @@ impl Clip {
         self.len
     }
 
+    /// Size of the keyframe index array
+    #[inline(always)]
+    fn keyframes_len(&self) -> usize {
+        self.cache * KEYFRAMES_PER_CACHE
+    }
+
     // /// Returns the property curve property path.
     // ///
     // /// The clip stores a property path in a specific way to improve search performance
@@ -212,7 +264,7 @@ impl Clip {
     fn calculate_duration(&self) -> f32 {
         self.properties
             .iter()
-            .map(|(_, c)| c.duration)
+            .map(|(_, (_, c))| c.duration)
             .fold(0.0f32, |acc, x| acc.max(x))
     }
 
@@ -230,7 +282,9 @@ impl Clip {
     /// Get the curves an given property
     #[inline(always)]
     pub fn get(&self, property_name: &str) -> Option<&CurvesUntyped> {
-        self.properties.get(property_name)
+        self.properties
+            .get(property_name)
+            .map(|(_, curve_untyped)| curve_untyped)
     }
 }
 
@@ -242,7 +296,7 @@ pub struct Layer {
     pub clip: usize,
     pub time: f32,
     pub time_scale: f32,
-    keyframes: Vec<usize>,
+    keyframes: Vec<u16>,
 }
 
 impl Default for Layer {
@@ -259,12 +313,17 @@ impl Default for Layer {
 
 impl Layer {
     #[inline(always)]
-    pub fn keyframes_mut(&mut self) -> &mut [usize] {
+    pub fn keyframes(&self) -> &[u16] {
+        &self.keyframes[..]
+    }
+
+    #[inline(always)]
+    pub fn keyframes_mut(&mut self) -> &mut [u16] {
         &mut self.keyframes[..]
     }
 
     #[inline(always)]
-    pub unsafe fn keyframes_unsafe(&self) -> &mut [usize] {
+    pub unsafe fn keyframes_unsafe(&self) -> &mut [u16] {
         std::slice::from_raw_parts_mut(self.keyframes.as_ptr() as *mut _, self.keyframes.len())
     }
 }
@@ -577,7 +636,7 @@ pub(crate) fn animator_update_system(
                     let mut time = layer.time + delta_time * layer.time_scale;
 
                     // Ensure keyframes capacity
-                    layer.keyframes.resize(clip.len(), 0);
+                    layer.keyframes.resize(clip.keyframes_len(), 0);
 
                     // Warp mode
                     if clip.warp {
@@ -602,9 +661,6 @@ pub(crate) fn animator_update_system(
     std::mem::drop(__guard);
 }
 
-// TODO: This should be auto derived using the "Animated" trait that just returns
-// a system able to animate the said component. Use "AnimatedAsset" for asset handles!
-
 // ! FIXME: Theres no way of free memory used by the `Local<AnimatorBlending>` in each system
 
 pub trait AnimatedComponent: Component + Sized {
@@ -616,7 +672,7 @@ pub trait AnimatedComponent: Component + Sized {
     );
 }
 
-pub trait AnimatedAsset: bevy_asset::Asset + Sized {
+pub trait AnimatedAsset: Asset + Sized {
     fn animator_update_system(
         clips: Res<Assets<Clip>>,
         animator_blending: Local<AnimatorBlending>,
@@ -1088,4 +1144,46 @@ mod tests {
             .enumerate()
             .for_each(|(index, entity)| assert!(entity.is_some(), "missing entity {}", index,));
     }
+
+    #[test]
+    fn clip_property_index_are_grouped_into_cache_line_buckets() {
+        let curve = Curve::from_constant(0.0);
+        let mut clip = Clip::default();
+        assert_eq!(clip.add_animated_prop("a@T.t", curve.clone()), 0);
+        assert_eq!(clip.add_animated_prop("b@T.t", curve.clone()), 1);
+        assert_eq!(
+            clip.add_animated_prop("a@T.r", curve.clone()),
+            KEYFRAMES_PER_CACHE
+        );
+        assert_eq!(clip.add_animated_prop("c@T.t", curve.clone()), 2);
+        assert_eq!(
+            clip.add_animated_prop("b@T.r", curve.clone()),
+            KEYFRAMES_PER_CACHE + 1
+        );
+        assert_eq!(
+            clip.add_animated_prop("c@T.r", curve.clone()),
+            KEYFRAMES_PER_CACHE + 2
+        );
+        assert_eq!(clip.add_animated_prop("d@T.t", curve.clone()), 3);
+
+        for i in 4..KEYFRAMES_PER_CACHE {
+            assert_eq!(
+                clip.add_animated_prop(&format!("node_{}@T.t", i), curve.clone()),
+                i
+            );
+        }
+
+        assert_eq!(
+            clip.add_animated_prop("za@T.t", curve.clone()),
+            KEYFRAMES_PER_CACHE * 2
+        );
+        assert_eq!(
+            clip.add_animated_prop("za@T.r", curve.clone()),
+            KEYFRAMES_PER_CACHE + 3
+        );
+        assert_eq!(
+            clip.add_animated_prop("zb@T.t", curve.clone()),
+            KEYFRAMES_PER_CACHE * 2 + 1
+        );
+    }
 }
diff --git a/crates/bevy_animation/src/experimental.rs b/crates/bevy_animation/src/experimental.rs
index 0ebb00d94e191..a710bc09d94cf 100644
--- a/crates/bevy_animation/src/experimental.rs
+++ b/crates/bevy_animation/src/experimental.rs
@@ -1,4 +1,9 @@
-use std::num::NonZeroU16;
+#![allow(dead_code)]
+
+use fnv::FnvBuildHasher;
+use std::{collections::HashMap, num::NonZeroU16};
+
+use crate::custom::{Curves, CurvesUntyped};
 
 // pub struct EntityMap<'a>(&'a [u16]);
 
@@ -62,9 +67,10 @@ impl Default for PropertiesStash {
 }
 
 impl PropertiesStash {
-    pub fn entry(&mut self, name: String) -> PropEntry {
-        //
-    }
+    // pub fn entry(&mut self, name: String) -> PropEntry {
+    //     //
+    //     todo!()
+    // }
 
     pub fn get<T: 'static>(&self, name: &str, ticket: &mut PropTicket) -> Option<&Curves<T>> {
         if ticket.1 != self.ver.get() {
diff --git a/crates/bevy_animation/src/impls.rs b/crates/bevy_animation/src/impls.rs
index ea19d36bb6108..f9d69bbee449a 100644
--- a/crates/bevy_animation/src/impls.rs
+++ b/crates/bevy_animation/src/impls.rs
@@ -47,8 +47,10 @@ impl AnimatedComponent for Transform {
                 if let Some(clip) = clips.get(clip_handle) {
                     let time = layer.time;
 
-                    // SAFETY: Never a different thread will modify or access the same index as this one
-                    // ! FIXME: Multiple threads will modifying the same cache line, not sure if this will cause any issue
+                    // SAFETY: Never a different thread will modify or access the same index as this one;
+                    // Plus as a nice and crazy feature each property is grouped by name into their own cache line
+                    // buckets, this way no cache line will be accessed by the same thread unless the same property
+                    // is accessed by two different systems, which is possible but weird and will hit the performance a bit
                     let keyframes = unsafe { layer.keyframes_unsafe() };
 
                     if let Some(curves) = clip
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 2033fc6018c43..ae0c26c9719ac 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -4,6 +4,7 @@ use bevy_reflect::RegisterTypeBuilder;
 
 mod app;
 mod custom;
+mod experimental;
 mod hierarchy;
 mod impls;
 mod skinned_mesh;

From 4120c33d5fba18508abd82a11f16510e5d1aac84 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Tue, 22 Dec 2020 10:06:34 -0300
Subject: [PATCH 055/153] force keyframes to be aligned into cache lines

---
 crates/bevy_animation/src/custom.rs | 75 +++++++++++++++++++++--------
 1 file changed, 55 insertions(+), 20 deletions(-)

diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index ed47630a9384c..ab0b9aa2a29b7 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -116,7 +116,7 @@ pub struct Clip {
     len: usize,
     /// Number of cache lines currently been used to organize the keyframe
     /// caching into buckets to be accessed by many different threads at the same time
-    cache: usize,
+    keyframes_cache_buckets: usize,
 }
 
 // fn clip_default_warp() -> bool {
@@ -131,7 +131,7 @@ impl Default for Clip {
             hierarchy: Hierarchy::default(),
             properties: HashMap::default(),
             len: 0,
-            cache: 0,
+            keyframes_cache_buckets: 0,
         }
     }
 }
@@ -190,8 +190,8 @@ impl Clip {
                 *cache_index += 1;
                 if (*cache_index % KEYFRAMES_PER_CACHE) == 0 {
                     // No more spaces left in the current cache line
-                    *cache_index = self.cache * KEYFRAMES_PER_CACHE;
-                    self.cache += 1;
+                    *cache_index = self.keyframes_cache_buckets * KEYFRAMES_PER_CACHE;
+                    self.keyframes_cache_buckets += 1;
                 }
 
                 self.len += 1;
@@ -211,8 +211,8 @@ impl Clip {
             }
         }
 
-        let cache_index = self.cache * KEYFRAMES_PER_CACHE;
-        self.cache += 1;
+        let cache_index = self.keyframes_cache_buckets * KEYFRAMES_PER_CACHE;
+        self.keyframes_cache_buckets += 1;
         self.len += 1;
 
         self.duration = self.duration.max(curve.duration());
@@ -236,12 +236,6 @@ impl Clip {
         self.len
     }
 
-    /// Size of the keyframe index array
-    #[inline(always)]
-    fn keyframes_len(&self) -> usize {
-        self.cache * KEYFRAMES_PER_CACHE
-    }
-
     // /// Returns the property curve property path.
     // ///
     // /// The clip stores a property path in a specific way to improve search performance
@@ -290,13 +284,28 @@ impl Clip {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[derive(Debug, Clone, Reflect)]
+#[cfg_attr(any(target_arch = "x86_64", target_arch = "aarch64"), repr(align(128)))]
+#[cfg_attr(
+    not(any(target_arch = "x86_64", target_arch = "aarch64")),
+    repr(align(64))
+)]
+#[derive(Debug, Clone)]
+struct KeyframeBucket([u16; KEYFRAMES_PER_CACHE]);
+
+impl Default for KeyframeBucket {
+    fn default() -> Self {
+        Self([0; KEYFRAMES_PER_CACHE])
+    }
+}
+
+#[derive(Clone, Reflect)]
 pub struct Layer {
     pub weight: f32,
     pub clip: usize,
     pub time: f32,
     pub time_scale: f32,
-    keyframes: Vec<u16>,
+    #[reflect(ignore)]
+    keyframes_buckets: Vec<KeyframeBucket>,
 }
 
 impl Default for Layer {
@@ -306,25 +315,46 @@ impl Default for Layer {
             clip: 0,
             time: 0.0,
             time_scale: 1.0,
-            keyframes: vec![],
+            keyframes_buckets: vec![],
         }
     }
 }
 
+impl std::fmt::Debug for Layer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Layer")
+            .field("weight", &self.weight)
+            .field("clip", &self.clip)
+            .field("time", &self.time)
+            .field("time_scale", &self.time_scale)
+            .finish()
+    }
+}
+
 impl Layer {
     #[inline(always)]
     pub fn keyframes(&self) -> &[u16] {
-        &self.keyframes[..]
+        // SAFETY: Keyframes vec still needs to be flatten
+        unsafe {
+            std::slice::from_raw_parts(
+                self.keyframes_buckets.as_ptr() as *const _,
+                self.keyframes_buckets.len() * KEYFRAMES_PER_CACHE,
+            )
+        }
     }
 
     #[inline(always)]
     pub fn keyframes_mut(&mut self) -> &mut [u16] {
-        &mut self.keyframes[..]
+        // SAFETY: Have mutability over self, but the keyframes vec still needs to be flatten
+        unsafe { self.keyframes_unsafe() }
     }
 
     #[inline(always)]
     pub unsafe fn keyframes_unsafe(&self) -> &mut [u16] {
-        std::slice::from_raw_parts_mut(self.keyframes.as_ptr() as *mut _, self.keyframes.len())
+        std::slice::from_raw_parts_mut(
+            self.keyframes_buckets.as_ptr() as *mut _,
+            self.keyframes_buckets.len() * KEYFRAMES_PER_CACHE,
+        )
     }
 }
 
@@ -636,7 +666,9 @@ pub(crate) fn animator_update_system(
                     let mut time = layer.time + delta_time * layer.time_scale;
 
                     // Ensure keyframes capacity
-                    layer.keyframes.resize(clip.keyframes_len(), 0);
+                    layer
+                        .keyframes_buckets
+                        .resize_with(clip.keyframes_cache_buckets, KeyframeBucket::default);
 
                     // Warp mode
                     if clip.warp {
@@ -644,7 +676,10 @@ pub(crate) fn animator_update_system(
                         if time > clip.duration() {
                             time = (time / clip.duration()).fract() * clip.duration();
                             // Reset keyframes indexes (speedup sampling)
-                            layer.keyframes.iter_mut().for_each(|k| *k = 0);
+                            layer
+                                .keyframes_buckets
+                                .iter_mut()
+                                .for_each(|k| *k = KeyframeBucket::default());
                         }
                     } else {
                         // Hold

From 681d0098735ecb37ffbb6f727bd574fb419762a7 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Tue, 22 Dec 2020 20:15:13 -0300
Subject: [PATCH 056/153] impls for some types, derive and other stuff

---
 crates/bevy_animation/Cargo.toml              |   2 +
 .../bevy_animation_derive/Cargo.toml          |   1 +
 .../src/animated_asset.rs                     | 150 ++++++++++++++
 .../src/animated_component.rs                 | 129 ++++++++++++
 .../bevy_animation_derive/src/lib.rs          |  34 ++++
 .../bevy_animation_derive/src/modules.rs      |  60 ++++++
 crates/bevy_animation/src/blending.rs         |  28 +++
 crates/bevy_animation/src/experimental.rs     |  61 +++++-
 crates/bevy_animation/src/impls.rs            | 189 +++++++++++++++++-
 crates/bevy_animation/src/lerping.rs          |  24 +++
 crates/bevy_animation/src/lib.rs              |   6 +-
 11 files changed, 669 insertions(+), 15 deletions(-)
 create mode 100644 crates/bevy_animation/bevy_animation_derive/src/animated_asset.rs
 create mode 100644 crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
 create mode 100644 crates/bevy_animation/bevy_animation_derive/src/modules.rs

diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index 98b2b482bbd91..bc9a59bb53d54 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -18,6 +18,8 @@ bevy_tasks = { path = "../bevy_tasks", version = "0.3.0" }
 bevy_transform = { path = "../bevy_transform", version = "0.3.0" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.3.0", features = ["bevy"] }
 
+bevy_animation_derive = { path = "../bevy_animation/bevy_animation_derive", version = "0.3.0" }
+
 # other
 serde = { version = "1.0", features = ["derive"] }
 smallvec = { version = "1.4", features = ["serde"] }
diff --git a/crates/bevy_animation/bevy_animation_derive/Cargo.toml b/crates/bevy_animation/bevy_animation_derive/Cargo.toml
index b59734a00d9ea..77c72d164f8ab 100644
--- a/crates/bevy_animation/bevy_animation_derive/Cargo.toml
+++ b/crates/bevy_animation/bevy_animation_derive/Cargo.toml
@@ -11,6 +11,7 @@ keywords = ["bevy"]
 proc-macro = true
 
 [dependencies]
+find-crate = "0.6"
 syn = "1.0"
 proc-macro2 = "1.0"
 quote = "1.0"
\ No newline at end of file
diff --git a/crates/bevy_animation/bevy_animation_derive/src/animated_asset.rs b/crates/bevy_animation/bevy_animation_derive/src/animated_asset.rs
new file mode 100644
index 0000000000000..c4770e2dc378f
--- /dev/null
+++ b/crates/bevy_animation/bevy_animation_derive/src/animated_asset.rs
@@ -0,0 +1,150 @@
+use crate::modules::{get_modules, get_path};
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse::ParseStream, parse_macro_input, Data, DataStruct, DeriveInput, Field, Fields};
+
+pub fn derive_animated_asset(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+
+    let fields = match &ast.data {
+        Data::Struct(DataStruct {
+            fields: Fields::Named(fields),
+            ..
+        }) => &fields.named,
+        _ => panic!("Expected a struct with named fields."),
+    };
+
+    // Filter fields
+    let fields = fields
+        .iter()
+        .filter(|field| {
+            field
+                .attrs
+                .iter()
+                .find(|a| *a.path.get_ident().as_ref().unwrap() == "animated")
+                .map_or_else(
+                    || true,
+                    |a| {
+                        syn::custom_keyword!(ignore);
+                        a.parse_args_with(|input: ParseStream| {
+                            if input.parse::<Option<ignore>>()?.is_some() {
+                                Ok(false)
+                            } else {
+                                Ok(true)
+                            }
+                        })
+                        .expect("Invalid 'animated' attribute format.")
+                    },
+                )
+        })
+        .collect::<Vec<&Field>>();
+
+    let modules = get_modules(&ast.attrs);
+    let bevy_animation = get_path(&modules.bevy_animation);
+    let bevy_ecs = get_path(&modules.bevy_ecs);
+    let bevy_asset = get_path(&modules.bevy_asset);
+
+    let struct_name = &ast.ident;
+    let properties = fields
+        .iter()
+        .map(|field| format!("Handle<{}>.{}", struct_name, field.ident.as_ref().unwrap()));
+    let field_types = fields.iter().map(|field| &field.ty);
+    let fields = fields.iter().map(|field| field.ident.as_ref().unwrap());
+    let handle_name = format!("Handle<{}>", struct_name);
+
+    let generics = ast.generics;
+    let (impl_generics, ty_generics, _where_clause) = generics.split_for_impl();
+
+    TokenStream::from(quote! {
+        impl #impl_generics #bevy_animation::AnimatedAsset for #struct_name #ty_generics {
+            fn animator_update_system(
+                clips: #bevy_ecs::Res<#bevy_asset::Assets<#bevy_animation::Clip>>,
+                mut animator_blending: #bevy_ecs::Local<#bevy_animation::AnimatorBlending>,
+                animators_query: #bevy_ecs::Query<& #bevy_animation::Animator>,
+                mut assets: #bevy_ecs::ResMut<#bevy_asset::Assets<Self>>,
+                component_query: #bevy_ecs::Query<&mut Handle<Self>>,
+            ) {
+                // let __span = tracing::info_span!("animator_transform_update_system");
+                // let __guard = __span.enter();
+
+                let mut components = vec![];
+
+                for animator in animators_query.iter() {
+                    let mut blend_group = animator_blending.begin_blending();
+
+                    components.clear();
+
+                    // ? NOTE: Lazy get each component is worse than just fetching everything at once
+                    // Pre-fetch all transforms to avoid calling get_mut multiple times
+                    // SAFETY: each component will be updated one at the time and this function
+                    // currently has the mutability over the Transform type, so no race conditions
+                    // are possible
+                    unsafe {
+                        for entity in animator.entities() {
+                            components.push(
+                                entity
+                                    .map(|entity| component_query.get_unsafe(entity).ok())
+                                    .flatten(),
+                            );
+                        }
+                    }
+
+                    for (_, layer, clip_handle, entities_map) in animator.animate() {
+                        let w = layer.weight;
+                        if w < 1.0e-8 {
+                            continue;
+                        }
+
+                        if let Some(clip) = clips.get(clip_handle) {
+                            let time = layer.time;
+
+                            // SAFETY: Never a different thread will modify or access the same index as this one;
+                            // Plus as a nice and crazy feature each property is grouped by name into their own cache line
+                            // buckets, this way no cache line will be accessed by the same thread unless the same property
+                            // is accessed by two different systems, which is possible but weird and will hit the performance a bit
+                            let keyframes = unsafe { layer.keyframes_unsafe() };
+
+                            if let Some(curves) = clip
+                                .get(#handle_name)
+                                .map(|curve_untyped| curve_untyped.downcast_ref::<Handle<Self>>())
+                                .flatten()
+                            {
+                                for (entity_index, (curve_index, curve)) in curves.iter() {
+                                    let entity_index = entities_map[entity_index as usize];
+                                    if let Some(ref mut component) = components[entity_index as usize] {
+                                        let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
+                                        keyframes[*curve_index] = k;
+                                        component.blend(&mut blend_group, v, w);
+                                    }
+                                }
+                            }
+
+                            #(
+                                if let Some(curves) = clip
+                                    .get(#properties)
+                                    .map(|curve_untyped| curve_untyped.downcast_ref::<#field_types>())
+                                    .flatten()
+                                {
+                                    for (entity_index, (curve_index, curve)) in curves.iter() {
+                                        let entity_index = entities_map[entity_index as usize];
+
+                                        if let Some(ref component) = components[entity_index as usize] {
+                                            if let Some(asset) = assets.get_mut(&**component) {
+                                                let (k, v) =
+                                                    curve.sample_indexed(keyframes[*curve_index], time);
+                                                keyframes[*curve_index] = k;
+                                                asset.#fields.blend(&mut blend_group, v, w);
+                                            }
+                                        }
+                                    }
+                                }
+                            )*
+                        }
+                    }
+                }
+
+                // std::mem::drop(__guard);
+            }
+        }
+    })
+}
diff --git a/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs b/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
new file mode 100644
index 0000000000000..86506e78030be
--- /dev/null
+++ b/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
@@ -0,0 +1,129 @@
+use crate::modules::{get_modules, get_path};
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse::ParseStream, parse_macro_input, Data, DataStruct, DeriveInput, Field, Fields};
+
+pub fn derive_animated_component(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+
+    let fields = match &ast.data {
+        Data::Struct(DataStruct {
+            fields: Fields::Named(fields),
+            ..
+        }) => &fields.named,
+        _ => panic!("Expected a struct with named fields."),
+    };
+
+    // Filter fields
+    let fields = fields
+        .iter()
+        .filter(|field| {
+            field
+                .attrs
+                .iter()
+                .find(|a| *a.path.get_ident().as_ref().unwrap() == "animated")
+                .map_or_else(
+                    || true,
+                    |a| {
+                        syn::custom_keyword!(ignore);
+                        a.parse_args_with(|input: ParseStream| {
+                            if input.parse::<Option<ignore>>()?.is_some() {
+                                Ok(false)
+                            } else {
+                                Ok(true)
+                            }
+                        })
+                        .expect("Invalid 'animated' attribute format.")
+                    },
+                )
+        })
+        .collect::<Vec<&Field>>();
+
+    let modules = get_modules(&ast.attrs);
+    let bevy_animation = get_path(&modules.bevy_animation);
+    let bevy_ecs = get_path(&modules.bevy_ecs);
+    let bevy_asset = get_path(&modules.bevy_asset);
+
+    let struct_name = &ast.ident;
+    let properties = fields
+        .iter()
+        .map(|field| format!("{}.{}", struct_name, field.ident.as_ref().unwrap()));
+    let field_types = fields.iter().map(|field| &field.ty);
+    let fields = fields.iter().map(|field| field.ident.as_ref().unwrap());
+
+    let generics = ast.generics;
+    let (impl_generics, ty_generics, _where_clause) = generics.split_for_impl();
+
+    TokenStream::from(quote! {
+        impl #impl_generics #bevy_animation::AnimatedComponent for #struct_name #ty_generics {
+            fn animator_update_system(
+                clips: #bevy_ecs::Res<#bevy_asset::Assets<#bevy_animation::Clip>>,
+                mut animator_blending: #bevy_ecs::Local<#bevy_animation::AnimatorBlending>,
+                animators_query: #bevy_ecs::Query<& #bevy_animation::Animator>,
+                component_query: #bevy_ecs::Query<&mut Self>,
+            ) {
+                // let __span = tracing::info_span!("animator_transform_update_system");
+                // let __guard = __span.enter();
+
+                let mut components = vec![];
+
+                for animator in animators_query.iter() {
+                    let mut blend_group = animator_blending.begin_blending();
+
+                    components.clear();
+
+                    // ? NOTE: Lazy get each component is worse than just fetching everything at once
+                    // Pre-fetch all transforms to avoid calling get_mut multiple times
+                    // SAFETY: each component will be updated one at the time and this function
+                    // currently has the mutability over the Transform type, so no race conditions
+                    // are possible
+                    unsafe {
+                        for entity in animator.entities() {
+                            components.push(
+                                entity
+                                    .map(|entity| component_query.get_unsafe(entity).ok())
+                                    .flatten(),
+                            );
+                        }
+                    }
+
+                    for (_, layer, clip_handle, entities_map) in animator.animate() {
+                        let w = layer.weight;
+                        if w < 1.0e-8 {
+                            continue;
+                        }
+
+                        if let Some(clip) = clips.get(clip_handle) {
+                            let time = layer.time;
+
+                            // SAFETY: Never a different thread will modify or access the same index as this one;
+                            // Plus as a nice and crazy feature each property is grouped by name into their own cache line
+                            // buckets, this way no cache line will be accessed by the same thread unless the same property
+                            // is accessed by two different systems, which is possible but weird and will hit the performance a bit
+                            let keyframes = unsafe { layer.keyframes_unsafe() };
+
+                            #(
+                                if let Some(curves) = clip
+                                    .get(#properties)
+                                    .map(|curve_untyped| curve_untyped.downcast_ref::<#field_types>())
+                                    .flatten()
+                                {
+                                    for (entity_index, (curve_index, curve)) in curves.iter() {
+                                        let entity_index = entities_map[entity_index as usize];
+                                        if let Some(ref mut component) = components[entity_index as usize] {
+                                            let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
+                                            keyframes[*curve_index] = k;
+                                            component.#fields.blend(&mut blend_group, v, w);
+                                        }
+                                    }
+                                }
+                            )*
+                        }
+                    }
+                }
+
+                // std::mem::drop(__guard);
+            }
+        }
+    })
+}
diff --git a/crates/bevy_animation/bevy_animation_derive/src/lib.rs b/crates/bevy_animation/bevy_animation_derive/src/lib.rs
index 8b137891791fe..9e38120aa5962 100644
--- a/crates/bevy_animation/bevy_animation_derive/src/lib.rs
+++ b/crates/bevy_animation/bevy_animation_derive/src/lib.rs
@@ -1 +1,35 @@
+extern crate proc_macro;
 
+mod animated_asset;
+mod animated_component;
+mod modules;
+
+use proc_macro::TokenStream;
+
+#[proc_macro_derive(AnimatedComponent)]
+pub fn derive_animated_component(input: TokenStream) -> TokenStream {
+    animated_component::derive_animated_component(input)
+}
+
+/// Used to implement the `AnimatedComponent` for an struct defined externally;
+/// Only useful inside the bevy_animation crate.
+#[doc(hidden)]
+#[proc_macro]
+pub fn animated_component(input: TokenStream) -> TokenStream {
+    animated_component::derive_animated_component(input)
+}
+
+#[proc_macro_derive(AnimatedAsset)]
+pub fn derive_animated_asset(input: TokenStream) -> TokenStream {
+    animated_asset::derive_animated_asset(input)
+}
+
+/// Used to implement the `AnimatedAsset` for an struct defined externally;
+/// Only useful inside the bevy_animation crate.
+#[doc(hidden)]
+#[proc_macro]
+pub fn animated_asset(input: TokenStream) -> TokenStream {
+    animated_asset::derive_animated_asset(input)
+}
+
+// TODO: LerpValue and Blend
diff --git a/crates/bevy_animation/bevy_animation_derive/src/modules.rs b/crates/bevy_animation/bevy_animation_derive/src/modules.rs
new file mode 100644
index 0000000000000..f2116ff6bb6ab
--- /dev/null
+++ b/crates/bevy_animation/bevy_animation_derive/src/modules.rs
@@ -0,0 +1,60 @@
+use find_crate::Manifest;
+use proc_macro::TokenStream;
+use syn::{Attribute, Path};
+
+#[derive(Debug)]
+pub struct Modules {
+    pub bevy_asset: String,
+    pub bevy_ecs: String,
+    pub bevy_animation: String,
+}
+
+impl Modules {
+    pub fn meta(name: &str) -> Modules {
+        Modules {
+            bevy_asset: format!("{}::asset", name),
+            bevy_ecs: format!("{}::ecs", name),
+            bevy_animation: format!("{}::animation", name),
+        }
+    }
+
+    pub fn external() -> Modules {
+        Modules {
+            bevy_asset: "bevy_asset".to_string(),
+            bevy_ecs: "bevy_ecs".to_string(),
+            bevy_animation: "bevy_animation".to_string(),
+        }
+    }
+}
+
+fn get_meta() -> Option<Modules> {
+    let manifest = Manifest::new().unwrap();
+    if let Some(package) = manifest.find(|name| name == "bevy") {
+        Some(Modules::meta(&package.name))
+    } else if let Some(package) = manifest.find(|name| name == "bevy_internal") {
+        Some(Modules::meta(&package.name))
+    } else {
+        None
+    }
+}
+
+//const AS_CRATE_ATTRIBUTE_NAME: &str = "as_crate";
+
+pub fn get_modules(_attributes: &[Attribute]) -> Modules {
+    let modules = get_meta().unwrap_or_else(Modules::external);
+
+    // for attribute in attributes.iter() {
+    //     if *attribute.path.get_ident().as_ref().unwrap() == AS_CRATE_ATTRIBUTE_NAME {
+    //         let value = attribute.tokens.to_string();
+    //         if value[1..value.len() - 1] == modules.bevy_render {
+    //             modules.bevy_render = "crate".to_string();
+    //         }
+    //     }
+    // }
+
+    modules
+}
+
+pub fn get_path(path_str: &str) -> Path {
+    syn::parse(path_str.parse::<TokenStream>().unwrap()).unwrap()
+}
diff --git a/crates/bevy_animation/src/blending.rs b/crates/bevy_animation/src/blending.rs
index 7dc43cc23b904..8a0cf6e3fee9b 100644
--- a/crates/bevy_animation/src/blending.rs
+++ b/crates/bevy_animation/src/blending.rs
@@ -112,3 +112,31 @@ impl Blend for HandleUntyped {
         blend_group.blend_contest(self, value, weight);
     }
 }
+
+impl<T: Blend> Blend for Option<T> {
+    fn blend(&mut self, blend_group: &mut AnimatorBlendGroup, value: Self, weight: f32) {
+        let ptr = Ptr(self as *const _ as *const u8);
+
+        match (self.is_some(), value.is_some()) {
+            (true, true) => {
+                // Blend by lerp but also add the entry for the conext blending
+                self.as_mut()
+                    .unwrap()
+                    .blend(blend_group, value.unwrap(), weight);
+
+                // Make sure to also add an entry for contest blent to work
+                let w = blend_group.blending.blend_memory.entry(ptr).or_insert(0.0);
+                if weight > *w {
+                    *w = weight;
+                }
+            }
+            (false, true) | (true, false) | (false, false) => {
+                // Blend by context but also add an entry for the next blend_lerp if needed
+                blend_group.blending.blend.insert(ptr);
+                blend_group.blend_contest(self, value, weight);
+            }
+        }
+    }
+}
+
+// TODO: std::ops::Range
diff --git a/crates/bevy_animation/src/experimental.rs b/crates/bevy_animation/src/experimental.rs
index a710bc09d94cf..deef7cb790974 100644
--- a/crates/bevy_animation/src/experimental.rs
+++ b/crates/bevy_animation/src/experimental.rs
@@ -1,5 +1,6 @@
 #![allow(dead_code)]
 
+use bevy_ecs::prelude::*;
 use fnv::FnvBuildHasher;
 use std::{collections::HashMap, num::NonZeroU16};
 
@@ -15,26 +16,66 @@ use crate::custom::{Curves, CurvesUntyped};
 
 ///////////////////////////////////////////////////////////////////////////////
 
-// Maybe useful for when animating assets or sparse components tree
 pub enum FetchState<T> {
-    None,
+    Pending,
     Missing,
     Found(T),
 }
 
-impl<T> FetchState<T> {
-    pub fn fetch_mut<F: Fn() -> Option<T>>(&mut self, fetch_fn: F) -> Option<&mut T> {
-        match self {
-            FetchState::None => {
-                if let Some(t) = fetch_fn() {
-                    *self = FetchState::Found(t);
-                    if let FetchState::Found(t) = self {
+pub struct FetchComponentsMut<'a, T: Component> {
+    query: Query<'a, &'a mut T>,
+    cache: Vec<FetchState<Mut<'a, T>>>,
+}
+
+impl<'a, T: Component> FetchComponentsMut<'a, T> {
+    pub fn new(query: Query<'a, &'a mut T>) -> Self {
+        Self {
+            query,
+            cache: vec![],
+        }
+    }
+
+    pub fn begin<'b>(
+        &'b mut self,
+        entities: &'b [Option<Entity>],
+    ) -> FetchComponentsMutGroup<'a, 'b, T> {
+        self.cache.clear();
+        self.cache
+            .resize_with(entities.len(), || FetchState::Pending);
+
+        FetchComponentsMutGroup {
+            entities,
+            fetch: self,
+        }
+    }
+}
+
+pub struct FetchComponentsMutGroup<'a, 'b, T: Component> {
+    entities: &'b [Option<Entity>],
+    fetch: &'b mut FetchComponentsMut<'a, T>,
+}
+
+impl<'a, 'b, T: Component> FetchComponentsMutGroup<'a, 'b, T> {
+    pub fn get_mut<'c: 'a + 'b>(&'c mut self, entity_index: usize) -> Option<&'c mut Mut<'c, T>> {
+        let state = &mut self.fetch.cache[entity_index];
+        match state {
+            FetchState::Pending => {
+                // Try fetch once only
+                // SAFETY: Only one component will be fetched at the time
+                if let Some(t) = self.entities[entity_index]
+                    .map(|entity| unsafe { self.fetch.query.get_unsafe(entity).ok() })
+                    .flatten()
+                {
+                    *state = FetchState::Found(t);
+
+                    // TODO: Figure out a nicer way of getting t
+                    if let FetchState::Found(t) = state {
                         Some(t)
                     } else {
                         unreachable!()
                     }
                 } else {
-                    *self = FetchState::Missing;
+                    *state = FetchState::Missing;
                     None
                 }
             }
diff --git a/crates/bevy_animation/src/impls.rs b/crates/bevy_animation/src/impls.rs
index f9d69bbee449a..fdce41613896d 100644
--- a/crates/bevy_animation/src/impls.rs
+++ b/crates/bevy_animation/src/impls.rs
@@ -1,11 +1,20 @@
-use bevy_asset::Assets;
+use crate as bevy_animation;
+use crate::{
+    blending::{AnimatorBlending, Blend},
+    custom::*,
+};
+use bevy_animation_derive::*;
+use bevy_asset::{Assets, Handle};
 use bevy_ecs::prelude::*;
 use bevy_math::prelude::*;
+use bevy_pbr::prelude::{Light, StandardMaterial};
+use bevy_render::{
+    camera::{OrthographicProjection, PerspectiveProjection},
+    mesh::Mesh,
+    prelude::{Color, Texture, Visible},
+};
 use bevy_transform::prelude::*;
 
-use crate::blending::{AnimatorBlending, Blend};
-use crate::custom::*;
-
 impl AnimatedComponent for Transform {
     fn animator_update_system(
         clips: Res<Assets<Clip>>,
@@ -104,3 +113,175 @@ impl AnimatedComponent for Transform {
         std::mem::drop(__guard);
     }
 }
+
+impl AnimatedAsset for StandardMaterial {
+    fn animator_update_system(
+        clips: Res<Assets<Clip>>,
+        mut animator_blending: Local<AnimatorBlending>,
+        animators_query: Query<&Animator>,
+        mut assets: ResMut<Assets<Self>>,
+        component_query: Query<&mut Handle<Self>>,
+    ) {
+        let __span = tracing::info_span!("animator_standard_material_update_system");
+        let __guard = __span.enter();
+
+        let mut components = vec![];
+
+        for animator in animators_query.iter() {
+            let mut blend_group = animator_blending.begin_blending();
+
+            for (_, layer, clip_handle, entities_map) in animator.animate() {
+                let w = layer.weight;
+                if w < 1.0e-8 {
+                    continue;
+                }
+
+                components.clear();
+
+                // TODO: Test performance with lazy component fetch
+                // SAFETY: each component will be updated one at the time and this function
+                // currently has the mutability over the Transform type, so no race conditions
+                // are possible
+                unsafe {
+                    for entity in animator.entities() {
+                        components.push(
+                            entity
+                                .map(|entity| component_query.get_unsafe(entity).ok())
+                                .flatten(),
+                        );
+                    }
+                }
+
+                if let Some(clip) = clips.get(clip_handle) {
+                    let time = layer.time;
+
+                    // SAFETY: Never a different thread will modify or access the same index as this one;
+                    // Plus as a nice and crazy feature each property is grouped by name into their own cache line
+                    // buckets, this way no cache line will be accessed by the same thread unless the same property
+                    // is accessed by two different systems, which is possible but weird and will hit the performance a bit
+                    let keyframes = unsafe { layer.keyframes_unsafe() };
+
+                    // Replace the material handle
+                    if let Some(curves) = clip
+                        .get("Handle<StandardMaterial>")
+                        .map(|curve_untyped| {
+                            curve_untyped.downcast_ref::<Handle<StandardMaterial>>()
+                        })
+                        .flatten()
+                    {
+                        for (entity_index, (curve_index, curve)) in curves.iter() {
+                            let entity_index = entities_map[entity_index as usize];
+
+                            if let Some(ref mut component) = components[entity_index as usize] {
+                                let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
+                                keyframes[*curve_index] = k;
+                                component.blend(&mut blend_group, v, w);
+                            }
+                        }
+                    }
+
+                    // Change asset properties
+
+                    if let Some(curves) = clip
+                        .get("Handle<StandardMaterial>.albedo")
+                        .map(|curve_untyped| curve_untyped.downcast_ref::<Color>())
+                        .flatten()
+                    {
+                        for (entity_index, (curve_index, curve)) in curves.iter() {
+                            let entity_index = entities_map[entity_index as usize];
+
+                            if let Some(ref component) = components[entity_index as usize] {
+                                if let Some(asset) = assets.get_mut(&**component) {
+                                    let (k, v) =
+                                        curve.sample_indexed(keyframes[*curve_index], time);
+                                    keyframes[*curve_index] = k;
+                                    asset.albedo.blend(&mut blend_group, v, w);
+                                }
+                            }
+                        }
+                    }
+
+                    if let Some(curves) = clip
+                        .get("Handle<StandardMaterial>.albedo_texture")
+                        .map(|curve_untyped| {
+                            curve_untyped.downcast_ref::<Option<Handle<Texture>>>()
+                        })
+                        .flatten()
+                    {
+                        for (entity_index, (curve_index, curve)) in curves.iter() {
+                            let entity_index = entities_map[entity_index as usize];
+                            if let Some(ref component) = components[entity_index as usize] {
+                                if let Some(asset) = assets.get_mut(&**component) {
+                                    let (k, v) =
+                                        curve.sample_indexed(keyframes[*curve_index], time);
+                                    keyframes[*curve_index] = k;
+                                    asset.albedo_texture.blend(&mut blend_group, v, w);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        std::mem::drop(__guard);
+    }
+}
+
+// animated_component! {
+//     struct Transform {
+//         translation: Vec3,
+//         rotation: Quat,
+//         scale: Vec3,
+//     }
+// }
+
+// animated_asset! {
+//     struct StandardMaterial {
+//         albedo: Color,
+//         albedo_texture: Option<Handle<Texture>>,
+//     }
+// }
+
+// animated_asset! {
+//     struct Sprite {}
+// }
+
+animated_asset! {
+    struct Mesh {}
+}
+
+animated_component! {
+    struct Visible {
+        is_visible: bool,
+    }
+}
+
+animated_component! {
+    struct Light {
+        color: Color,
+        fov: f32,
+        //depth: Range<f32>,
+    }
+}
+
+animated_component! {
+    struct PerspectiveProjection {
+        fov: f32,
+        aspect_ratio: f32,
+        near: f32,
+        far: f32,
+    }
+}
+
+animated_component! {
+    struct OrthographicProjection {
+        left: f32,
+        right: f32,
+        bottom: f32,
+        top: f32,
+        near: f32,
+        far: f32,
+        //window_origin: WindowOrigin,
+    }
+}
diff --git a/crates/bevy_animation/src/lerping.rs b/crates/bevy_animation/src/lerping.rs
index 465a7e4195f45..29ead00bd02e0 100644
--- a/crates/bevy_animation/src/lerping.rs
+++ b/crates/bevy_animation/src/lerping.rs
@@ -7,6 +7,7 @@ pub trait Lerp {
 }
 
 impl Lerp for bool {
+    #[inline(always)]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         if t > 0.99 {
             b.clone()
@@ -17,30 +18,35 @@ impl Lerp for bool {
 }
 
 impl Lerp for f32 {
+    #[inline(always)]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
 }
 
 impl Lerp for Vec2 {
+    #[inline(always)]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
 }
 
 impl Lerp for Vec3 {
+    #[inline(always)]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
 }
 
 impl Lerp for Vec4 {
+    #[inline(always)]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
 }
 
 impl Lerp for Color {
+    #[inline(always)]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
@@ -49,6 +55,7 @@ impl Lerp for Color {
 impl Lerp for Quat {
     /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
     /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
+    #[inline(always)]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
         let mut b = *b;
@@ -61,6 +68,7 @@ impl Lerp for Quat {
 }
 
 impl<T: Asset + 'static> Lerp for Handle<T> {
+    #[inline(always)]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         if t > 0.99 {
             b.clone()
@@ -71,6 +79,7 @@ impl<T: Asset + 'static> Lerp for Handle<T> {
 }
 
 impl Lerp for HandleUntyped {
+    #[inline(always)]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         if t > 0.99 {
             b.clone()
@@ -79,3 +88,18 @@ impl Lerp for HandleUntyped {
         }
     }
 }
+
+impl<T: Lerp + Clone> Lerp for Option<T> {
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        match (a.is_some(), b.is_some()) {
+            (true, true) => Some(T::lerp(a.as_ref().unwrap(), b.as_ref().unwrap(), t)),
+            (false, true) | (true, false) | (false, false) => {
+                if t > 0.99 {
+                    b.clone()
+                } else {
+                    a.clone()
+                }
+            }
+        }
+    }
+}
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index ae0c26c9719ac..b56e957f3db85 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -4,7 +4,7 @@ use bevy_reflect::RegisterTypeBuilder;
 
 mod app;
 mod custom;
-mod experimental;
+//mod experimental;
 mod hierarchy;
 mod impls;
 mod skinned_mesh;
@@ -14,10 +14,13 @@ pub mod curve;
 pub mod lerping;
 
 pub use crate::app::*;
+pub use crate::blending::AnimatorBlending;
 pub use crate::custom::*;
 pub use crate::hierarchy::Hierarchy;
 pub use crate::skinned_mesh::*;
 
+pub use bevy_animation_derive::*;
+
 pub mod prelude {
     pub use crate::app::AddAnimated;
     pub use crate::blending::AnimatorBlending;
@@ -27,6 +30,7 @@ pub mod prelude {
     pub use crate::hierarchy::Hierarchy;
     pub use crate::lerping::Lerp;
     pub use crate::skinned_mesh::{SkinAsset, SkinComponent, SkinDebugger};
+    pub use bevy_animation_derive::*;
 }
 
 pub mod stage {

From fbee3b935692adc5fc19f26b3ecec02bcbadb1a0 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Wed, 23 Dec 2020 20:38:34 -0300
Subject: [PATCH 057/153] expand attr for component derive + comments about
 other stuff

---
 .../src/animated_asset.rs                     |    2 +
 .../src/animated_component.rs                 |  132 +-
 .../bevy_animation_derive/src/lib.rs          |    4 +-
 crates/bevy_animation/src/clip.rs             |  279 -----
 crates/bevy_animation/src/custom.rs           |   36 +-
 crates/bevy_animation/src/generic.rs          | 1091 -----------------
 crates/bevy_animation/src/impls.rs            |   65 +-
 crates/bevy_animation/src/lib.rs              |    3 +-
 8 files changed, 213 insertions(+), 1399 deletions(-)
 delete mode 100644 crates/bevy_animation/src/clip.rs
 delete mode 100644 crates/bevy_animation/src/generic.rs

diff --git a/crates/bevy_animation/bevy_animation_derive/src/animated_asset.rs b/crates/bevy_animation/bevy_animation_derive/src/animated_asset.rs
index c4770e2dc378f..02f9f90f9e253 100644
--- a/crates/bevy_animation/bevy_animation_derive/src/animated_asset.rs
+++ b/crates/bevy_animation/bevy_animation_derive/src/animated_asset.rs
@@ -3,6 +3,8 @@ use proc_macro::TokenStream;
 use quote::quote;
 use syn::{parse::ParseStream, parse_macro_input, Data, DataStruct, DeriveInput, Field, Fields};
 
+// TODO: Add extended fields like in animated_component
+
 pub fn derive_animated_asset(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
 
diff --git a/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs b/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
index 86506e78030be..858ed240b0d5b 100644
--- a/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
+++ b/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
@@ -1,7 +1,63 @@
 use crate::modules::{get_modules, get_path};
 use proc_macro::TokenStream;
+use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
-use syn::{parse::ParseStream, parse_macro_input, Data, DataStruct, DeriveInput, Field, Fields};
+use syn::{
+    parse::ParseStream, parse_macro_input, parse_quote, punctuated::Punctuated, token::Comma, Data,
+    DataStruct, DeriveInput, Field, Fields, Ident, Type,
+};
+
+fn animate_property(
+    property: &str,
+    field_ident: &Ident,
+    field_inner: &[&Ident],
+    field_type: &Type,
+) -> TokenStream2 {
+    quote! {
+        if let Some(curves) = clip
+            .get(#property)
+            .map(|curve_untyped| curve_untyped.downcast_ref::<#field_type>())
+            .flatten()
+        {
+            for (entity_index, (curve_index, curve)) in curves.iter() {
+                let entity_index = entities_map[entity_index as usize];
+                if let Some(ref mut component) = components[entity_index as usize] {
+                    let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
+                    keyframes[*curve_index] = k;
+                    component.#field_ident #(. #field_inner)* .blend(&mut blend_group, v, w);
+                }
+            }
+        }
+    }
+}
+
+fn animate_property_extended(
+    property: &str,
+    field_ident: &Ident,
+    field_inner: &[Field],
+    field_type: &Type,
+) -> TokenStream2 {
+    let field_inner = field_inner
+        .iter()
+        .map(|field| field.ident.as_ref().unwrap());
+
+    quote! {
+        if let Some(curves) = clip
+            .get(#property)
+            .map(|curve_untyped| curve_untyped.downcast_ref::<#field_type>())
+            .flatten()
+        {
+            for (entity_index, (curve_index, curve)) in curves.iter() {
+                let entity_index = entities_map[entity_index as usize];
+                if let Some(ref mut component) = components[entity_index as usize] {
+                    let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
+                    keyframes[*curve_index] = k;
+                    #(component.#field_ident.#field_inner.blend(&mut blend_group, v.#field_inner, w);)*
+                }
+            }
+        }
+    }
+}
 
 pub fn derive_animated_component(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
@@ -14,10 +70,14 @@ pub fn derive_animated_component(input: TokenStream) -> TokenStream {
         _ => panic!("Expected a struct with named fields."),
     };
 
+    let mut expanded: Vec<Vec<Field>> = vec![];
+    expanded.resize_with(fields.len(), || vec![]);
+
     // Filter fields
     let fields = fields
         .iter()
-        .filter(|field| {
+        .enumerate()
+        .filter(|(field_index, field)| {
             field
                 .attrs
                 .iter()
@@ -26,9 +86,18 @@ pub fn derive_animated_component(input: TokenStream) -> TokenStream {
                     || true,
                     |a| {
                         syn::custom_keyword!(ignore);
+                        syn::custom_keyword!(expand);
                         a.parse_args_with(|input: ParseStream| {
                             if input.parse::<Option<ignore>>()?.is_some() {
                                 Ok(false)
+                            } else if input.parse::<Option<expand>>()?.is_some() {
+                                let content;
+                                //syn::parenthesized!(content in input);
+                                syn::braced!(content in input);
+                                let fields: Punctuated<Field, Comma> =
+                                    content.parse_terminated(Field::parse_named)?;
+                                expanded[*field_index].extend(fields.iter().cloned());
+                                Ok(true)
                             } else {
                                 Ok(true)
                             }
@@ -37,6 +106,7 @@ pub fn derive_animated_component(input: TokenStream) -> TokenStream {
                     },
                 )
         })
+        .map(|(_, field)| field)
         .collect::<Vec<&Field>>();
 
     let modules = get_modules(&ast.attrs);
@@ -45,11 +115,44 @@ pub fn derive_animated_component(input: TokenStream) -> TokenStream {
     let bevy_asset = get_path(&modules.bevy_asset);
 
     let struct_name = &ast.ident;
-    let properties = fields
+
+    let animate = fields
         .iter()
-        .map(|field| format!("{}.{}", struct_name, field.ident.as_ref().unwrap()));
-    let field_types = fields.iter().map(|field| &field.ty);
-    let fields = fields.iter().map(|field| field.ident.as_ref().unwrap());
+        .zip(expanded.iter())
+        .map(|(field, extended_fields)| {
+            if extended_fields.len() == 0 {
+                let ident = field.ident.as_ref().unwrap();
+                animate_property(
+                    &format!("{}.{}", struct_name, field.ident.as_ref().unwrap()),
+                    ident,
+                    &[],
+                    &field.ty,
+                )
+            } else {
+                let property = format!("{}.{}", struct_name, field.ident.as_ref().unwrap());
+                let ident = field.ident.as_ref().unwrap();
+                let main = animate_property_extended(
+                    &property,
+                    &parse_quote!(#ident),
+                    &extended_fields[..],
+                    &field.ty,
+                );
+                let extended = extended_fields.iter().map(|field| {
+                    let inner = field.ident.as_ref().unwrap();
+                    animate_property(
+                        &format!("{}.{}", property, inner),
+                        ident,
+                        &[inner],
+                        &field.ty,
+                    )
+                });
+                quote! {
+                    #main else {
+                        #( #extended )*
+                    }
+                }
+            }
+        });
 
     let generics = ast.generics;
     let (impl_generics, ty_generics, _where_clause) = generics.split_for_impl();
@@ -102,22 +205,7 @@ pub fn derive_animated_component(input: TokenStream) -> TokenStream {
                             // is accessed by two different systems, which is possible but weird and will hit the performance a bit
                             let keyframes = unsafe { layer.keyframes_unsafe() };
 
-                            #(
-                                if let Some(curves) = clip
-                                    .get(#properties)
-                                    .map(|curve_untyped| curve_untyped.downcast_ref::<#field_types>())
-                                    .flatten()
-                                {
-                                    for (entity_index, (curve_index, curve)) in curves.iter() {
-                                        let entity_index = entities_map[entity_index as usize];
-                                        if let Some(ref mut component) = components[entity_index as usize] {
-                                            let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
-                                            keyframes[*curve_index] = k;
-                                            component.#fields.blend(&mut blend_group, v, w);
-                                        }
-                                    }
-                                }
-                            )*
+                            #(#animate)*
                         }
                     }
                 }
diff --git a/crates/bevy_animation/bevy_animation_derive/src/lib.rs b/crates/bevy_animation/bevy_animation_derive/src/lib.rs
index 9e38120aa5962..568fa9b66d7c9 100644
--- a/crates/bevy_animation/bevy_animation_derive/src/lib.rs
+++ b/crates/bevy_animation/bevy_animation_derive/src/lib.rs
@@ -6,7 +6,7 @@ mod modules;
 
 use proc_macro::TokenStream;
 
-#[proc_macro_derive(AnimatedComponent)]
+#[proc_macro_derive(AnimatedComponent, attributes(animated))]
 pub fn derive_animated_component(input: TokenStream) -> TokenStream {
     animated_component::derive_animated_component(input)
 }
@@ -19,7 +19,7 @@ pub fn animated_component(input: TokenStream) -> TokenStream {
     animated_component::derive_animated_component(input)
 }
 
-#[proc_macro_derive(AnimatedAsset)]
+#[proc_macro_derive(AnimatedAsset, attributes(animated))]
 pub fn derive_animated_asset(input: TokenStream) -> TokenStream {
     animated_asset::derive_animated_asset(input)
 }
diff --git a/crates/bevy_animation/src/clip.rs b/crates/bevy_animation/src/clip.rs
deleted file mode 100644
index eb6c5d6169182..0000000000000
--- a/crates/bevy_animation/src/clip.rs
+++ /dev/null
@@ -1,279 +0,0 @@
-use bevy_core::Name;
-use bevy_type_registry::TypeUuid;
-
-use super::curve::CurveUntyped;
-use super::hierarchy::Hierarchy;
-
-// TODO: Curve/Clip need a validation during deserialization because they are
-// structured as SOA (struct of arrays), so the vec's length must match
-
-#[derive(Debug, Clone, Copy)]
-pub struct CurveEntry {
-    pub entity_index: u16,
-    pub property_index: u16,
-}
-
-// TODO: impl Serialize, Deserialize
-#[derive(Debug, Clone, TypeUuid)]
-#[uuid = "4c76e6c3-706d-4a74-af8e-4f48033e0733"]
-pub struct Clip {
-    //#[serde(default = "clip_default_warp")]
-    pub warp: bool,
-    duration: f32,
-    /// Entity identification made by parent index and name
-    hierarchy: Hierarchy,
-    /// Each curve as one entry that maps a curve to an entity and a property path
-    entries: Vec<CurveEntry>,
-    curves: Vec<CurveUntyped>,
-    /// A single property is made by string that combines
-    /// component name followed by their attributes spaced by a period,
-    /// like so: `"Transform.translation.x"`
-    properties: Vec<Name>,
-}
-
-// fn clip_default_warp() -> bool {
-//     true
-// }
-
-impl Default for Clip {
-    fn default() -> Self {
-        Self {
-            warp: true,
-            duration: 0.0,
-            // ? NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
-            hierarchy: Hierarchy::default(),
-            properties: vec![],
-            curves: vec![],
-            entries: vec![],
-        }
-    }
-}
-
-impl Clip {
-    /// Property to be animated must be in the following format `"path/to/named_entity@Transform.translation.x"`
-    /// where the left side `@` defines a path to the entity to animate,
-    /// while the right side the path to a property to animate starting from the component.
-    ///
-    /// *NOTE* This is a expensive function
-    pub fn add_animated_prop(&mut self, property_path: &str, mut curve: CurveUntyped) {
-        // Clip an only have some amount of curves and entities
-        // this limitation was added to save memory (but you can increase it if you want)
-        assert!(
-            (self.curves.len() as u16) <= u16::MAX,
-            "curve limit reached"
-        );
-
-        // Split in entity and attribute path,
-        // NOTE: use rfind because it's expected the latter to be generally shorter
-        let path =
-            property_path.split_at(property_path.rfind('@').expect("property path missing @"));
-
-        let (entity_index, just_created) = self.hierarchy.get_or_insert_entity(path.0);
-        let target_name = path.1.split_at(1).1;
-
-        // If some entity was created it means this property is a new one so we can safely skip the attribute testing
-        if !just_created {
-            for (i, entry) in self.entries.iter().enumerate() {
-                if entry.entity_index != entity_index {
-                    continue;
-                }
-
-                let property_name = &self.properties[entry.property_index as usize];
-                let mid = target_name.len().min(property_name.len());
-                let (head0, tail0) = property_name.split_at(mid);
-                let (head1, tail1) = target_name.split_at(mid);
-
-                if head0 == head1 {
-                    // Replace
-                    if tail0.len() == 0 && tail1.len() == 0 {
-                        // Found a property are equal the one been inserted
-                        // Replace curve, the property was already added, this is very important
-                        // because it guarantees that each property will have unique access to some
-                        // attribute during the update stages
-
-                        let inserted_duration = curve.duration();
-                        std::mem::swap(&mut self.curves[i], &mut curve);
-                        self.update_duration(curve.duration(), inserted_duration);
-                        return;
-                    } else {
-                        // Check the inserted attribute is nested of an already present attribute
-                        // NOTE: ".../Enity0@Transform.translation" and ".../Enity0@Transform.translation.x"
-                        // can't coexist because it may cause a problems of non unique access
-                        if tail0.starts_with('.') || tail1.starts_with('.') {
-                            panic!("nesting properties");
-                        }
-                    }
-                }
-            }
-        }
-
-        // Find property or insert as a new one
-        let target_name = Name::from_str(target_name);
-        let property_index = self
-            .properties
-            .iter()
-            .position(|property_name| property_name == &target_name)
-            .map_or_else(
-                || {
-                    let property_index = self.properties.len() as u16;
-                    self.properties.push(target_name);
-                    property_index
-                },
-                |property_index| property_index as u16,
-            );
-
-        self.duration = self.duration.max(curve.duration());
-        self.entries.push(CurveEntry {
-            entity_index,
-            property_index,
-        });
-        self.curves.push(curve);
-    }
-
-    /// Number of animated properties in this clip
-    #[inline(always)]
-    pub fn len(&self) -> u16 {
-        self.curves.len() as u16
-    }
-
-    /// Returns the property curve property path.
-    ///
-    /// The clip stores a property path in a specific way to improve search performance
-    /// thus it needs to rebuilt the curve property path in the human readable format
-    pub fn get_property_path(&self, index: u16) -> String {
-        let CurveEntry {
-            entity_index,
-            property_index,
-        } = &self.entries[index as usize];
-
-        format!(
-            "{}@{}",
-            self.hierarchy
-                .get_entity_path_at(*entity_index)
-                .expect("property as an invalid entity"),
-            self.properties[*property_index as usize].as_str()
-        )
-    }
-
-    /// Clip duration
-    #[inline(always)]
-    pub fn duration(&self) -> f32 {
-        self.duration
-    }
-
-    /// Updates the clip duration based of the inserted and removed curve durations
-    /// *WARNING* The curve must be already replaced before call this function
-    fn update_duration(&mut self, removed_duration: f32, inserted_duration: f32) {
-        if removed_duration == inserted_duration {
-            // If precisely matches the inserted curve duration we don't need to update anything
-        } else if float_cmp::approx_eq!(f32, removed_duration, self.duration, ulps = 2) {
-            // At this point the duration for the removed curve is the same as self.duration
-            // this mean that we have to compute the clip duration from scratch;
-            //
-            // NOTE: I opted for am approximated float comparison because it's better
-            // to do all the this work than get a hard to debug glitch
-            // TODO: Review approximated comparison
-
-            self.duration = self
-                .curves
-                .iter()
-                .map(|c| c.duration())
-                .fold(0.0, |acc, x| acc.max(x));
-        } else {
-            // Faster clip duration update
-            self.duration = self.duration.max(inserted_duration);
-        }
-    }
-
-    #[inline(always)]
-    pub fn hierarchy(&self) -> &Hierarchy {
-        &self.hierarchy
-    }
-
-    #[inline(always)]
-    pub fn properties(&self) -> &[Name] {
-        &self.properties[..]
-    }
-
-    #[inline(always)]
-    pub fn curves(&self) -> impl Iterator<Item = (&CurveEntry, &CurveUntyped)> {
-        self.entries.iter().zip(self.curves.iter())
-    }
-
-    #[inline(always)]
-    pub fn get(&self, curve_index: u16) -> Option<&CurveUntyped> {
-        self.curves.get(curve_index as usize)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::curve::Curve;
-    use bevy_math::prelude::*;
-
-    #[test]
-    fn create_clip() {
-        let mut clip = Clip::default();
-        let curve = Curve::from_linear(0.0, 1.0, 0.0, 1.0);
-        let prop = "/Root/Ball@Sphere.radius";
-        clip.add_animated_prop(prop, CurveUntyped::Float(curve));
-        assert_eq!(clip.get_property_path(0), prop);
-    }
-
-    #[test]
-    fn clip_replace_property() {
-        // NOTE: This test is very important because it guarantees that each property have unique
-        // access to some attribute during the update stages
-        let mut clip = Clip::default();
-        let prop = "/Root/Ball@Sphere.radius";
-        clip.add_animated_prop(
-            "/Root/Ball@Transform.translate.y",
-            CurveUntyped::Float(Curve::from_linear(0.0, 1.0, 0.0, 1.0)),
-        );
-        clip.add_animated_prop(
-            prop,
-            CurveUntyped::Float(Curve::from_linear(0.0, 1.0, 0.0, 1.0)),
-        );
-        assert_eq!(clip.duration(), 1.0);
-        clip.add_animated_prop(
-            prop,
-            CurveUntyped::Float(Curve::from_linear(0.0, 1.2, 0.1, 2.0)),
-        );
-        assert_eq!(clip.len(), 2);
-        assert_eq!(clip.get_property_path(1), prop);
-        assert_eq!(clip.duration(), 1.2);
-    }
-
-    #[test]
-    fn clip_fine_grain_properties() {
-        let mut clip = Clip::default();
-        clip.add_animated_prop(
-            "/Root/Ball@Transform.translate.y",
-            CurveUntyped::Float(Curve::from_linear(0.0, 1.0, 0.0, 1.0)),
-        );
-        assert_eq!(clip.duration(), 1.0);
-        clip.add_animated_prop(
-            "/Root/Ball@Transform.translate.x",
-            CurveUntyped::Float(Curve::from_linear(0.0, 1.2, 0.0, 2.0)),
-        );
-        assert_eq!(clip.len(), 2);
-        assert_eq!(clip.duration(), 1.2);
-    }
-
-    #[test]
-    #[should_panic]
-    fn clip_nested_properties() {
-        // Maybe required by `bevy_reflect` this guarantees are necessary
-        // because the way we execute
-        let mut clip = Clip::default();
-        clip.add_animated_prop(
-            "/Root/Ball@Transform.translate",
-            CurveUntyped::Vec3(Curve::from_linear(0.0, 1.0, Vec3::zero(), Vec3::unit_y())),
-        );
-        clip.add_animated_prop(
-            "/Root/Ball@Transform.translate.x",
-            CurveUntyped::Float(Curve::from_linear(0.0, 1.2, 0.0, 2.0)),
-        );
-    }
-}
diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index ab0b9aa2a29b7..e580f49aa8476 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -96,7 +96,28 @@ impl CurvesUntyped {
     }
 }
 
+// TODO: Didn't make my mind about it
+// Pros:
+//  - Can limit to only the entities that we really want to animate, from deep nested hierarchies
+//  - Entities names don't matter
+//  - Hierarchy don't matter with can be nice if you keep changing it
+// Cons:
+//  - Harder to modify and manipulate clips
+//  - Harder to find entities
+//  - Harder to mix clips with different hierarchies
+//  - Hierarchy don't matter which can lead to a giant mess, and will make impossible to parallelize
+//    over Animators
+// /// Defines a reusable entity hierarchy
+// #[derive(Debug, TypeUuid)]
+// #[uuid = "9d524787-1fbf-46c6-b34f-f2ae196664c5"]
+// pub struct AnimatorHierarchy {
+//     pub entities: Vec<String>,
+// }
+
 // TODO: impl Serialize, Deserialize using bevy reflect for that
+// TODO: Study an optional asset that lists all animated entities, to take preference over
+// the hierarchy, this animated entity asset must match the one been used in the animator
+// this could help retarget animations, but will mess the clip
 #[derive(Debug, TypeUuid)]
 #[uuid = "79e2ea58-8bf7-43af-8219-5898edb02f80"]
 pub struct Clip {
@@ -108,6 +129,8 @@ pub struct Clip {
     pub warp: bool,
     /// Clip compound duration
     duration: f32,
+    // ! FIXME: The hierarchy may need to know more entities than the current been animated
+    // ! this will case them to fetch extra entities components that aren't used at all
     hierarchy: Hierarchy,
     // ? NOTE: AHash performed worse than FnvHasher
     /// Each curve and keyframe cache index mapped by property name  
@@ -137,6 +160,8 @@ impl Default for Clip {
 }
 
 impl Clip {
+    // TODO: Make harder to make mistakes like assigning a Curve<f32> to a rotation, or misspell names
+    // TODO: Warn about properties that aren't been used so the user can check if they are wrong or not
     /// Property to be animated must be in the following format `"path/to/named_entity@Transform.translation.x"`
     /// where the left side `@` defines a path to the entity to animate,
     /// while the right side the path to a property to animate starting from the component.
@@ -149,6 +174,13 @@ impl Clip {
     where
         T: Lerp + Clone + Send + Sync + 'static,
     {
+        // Clip an only have some amount of curves and entities
+        // this limitation was added to save memory (but you can increase it if you want)
+        assert!(
+            self.len + 1 < (u16::MAX as usize),
+            "clip curve limit reached"
+        );
+
         // Split in entity and attribute path,
         // NOTE: use rfind because it's expected the latter to be generally shorter
         let path =
@@ -289,7 +321,7 @@ impl Clip {
     not(any(target_arch = "x86_64", target_arch = "aarch64")),
     repr(align(64))
 )]
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 struct KeyframeBucket([u16; KEYFRAMES_PER_CACHE]);
 
 impl Default for KeyframeBucket {
@@ -407,7 +439,7 @@ impl Animator {
         }
     }
 
-    // TODO: remove clip
+    // TODO: remove clip (this operation will be very hard)
 
     pub fn add_layer(&mut self, clip: Handle<Clip>, weight: f32) -> usize {
         let clip = self.add_clip(clip);
diff --git a/crates/bevy_animation/src/generic.rs b/crates/bevy_animation/src/generic.rs
deleted file mode 100644
index ba3ebc59ca1a6..0000000000000
--- a/crates/bevy_animation/src/generic.rs
+++ /dev/null
@@ -1,1091 +0,0 @@
-use anyhow::Result;
-use bevy_app::prelude::{EventReader, Events};
-use bevy_asset::{AssetEvent, Assets, Handle /*, HandleUntyped*/};
-use bevy_core::prelude::*;
-use bevy_ecs::prelude::*;
-use bevy_ecs::{Location, SystemId};
-use bevy_math::prelude::*;
-use bevy_property::{Properties, Property, PropertyType};
-use bevy_transform::prelude::*;
-use bevy_type_registry::TypeRegistry;
-//use serde::{Deserialize, Serialize};
-use std::any::TypeId;
-use std::hash::Hash;
-use std::ptr::null_mut;
-
-use super::clip::Clip;
-use super::curve::CurveUntyped;
-use super::lerping::LerpValue;
-
-#[derive(Debug, Clone, Properties)]
-pub struct Layer {
-    pub weight: f32,
-    pub clip: u16,
-    pub time: f32,
-    pub time_scale: f32,
-    keyframe: Vec<usize>,
-}
-
-impl Default for Layer {
-    fn default() -> Self {
-        Layer {
-            weight: 1.0,
-            clip: 0,
-            time: 0.0,
-            time_scale: 1.0,
-            keyframe: vec![],
-        }
-    }
-}
-
-#[derive(Debug, Properties)]
-pub struct Animator {
-    clips: Vec<Handle<Clip>>,
-    #[property(ignore)]
-    bind_clips: Vec<Option<ClipBind>>,
-    // masks: Vec<Handle<ClipMask>>,
-    // #[property(ignore)]
-    // bind_masks: Vec<ClipMaskBind>,
-    /// Used to blend all the active layers, durning the frame update each pointers
-    /// can only be set once, by the second time then need to perform blended with the next layer
-    ///
-    // ? NOTE: We may need to change this approach when blending more than 2 layers
-    // ? NOTE: It takes more memory but it's faster than having a local resource with a big chunk of data or even allocating at every frame
-    #[property(ignore)]
-    visited: fnv::FnvHashSet<Ptr>,
-    pub time_scale: f32,
-    pub layers: Vec<Layer>,
-}
-
-// TODO: AnimatorStateMachine + Transitions to simplify layer blending but in another file
-
-impl Default for Animator {
-    fn default() -> Self {
-        Self {
-            clips: vec![],
-            bind_clips: vec![],
-            visited: fnv::FnvHashSet::default(),
-            time_scale: 1.0,
-            layers: vec![],
-        }
-    }
-}
-
-impl Animator {
-    pub fn add_clip(&mut self, clip: Handle<Clip>) -> u16 {
-        if let Some(i) = self.clips.iter().position(|c| *c == clip) {
-            i as u16
-        } else {
-            // TODO: assert too many clips ...
-            let i = self.clips.len();
-            self.clips.push(clip);
-            i as u16
-        }
-    }
-
-    pub fn add_layer(&mut self, clip: Handle<Clip>, weight: f32) -> u16 {
-        let clip = self.add_clip(clip);
-        let layer_index = self.layers.len();
-        self.layers.push(Layer {
-            clip,
-            weight,
-            ..Default::default()
-        });
-        layer_index as u16
-    }
-
-    pub fn clips_len(&self) -> u16 {
-        self.clips.len() as u16
-    }
-}
-
-// TODO: Bind asset properties (edge case), notice that this feature will be on hold
-// until the atelier assets get through. I will probably just store pointers offsets
-// because require less conditions to be safe and is not too much that expensive to store
-// direct pointers
-
-#[derive(Debug)]
-struct ClipBindEntity {
-    parent: Option<Entity>,
-    entity: Entity,
-    location: Location,
-}
-
-#[derive(Debug)]
-struct ClipBind {
-    entities: Vec<Option<ClipBindEntity>>,
-    /// True only when all the attributes are binded
-    binded: bool,
-    /// Attributes pointers
-    pointers: Vec<Ptr>,
-}
-
-// #[derive(Debug)]
-// struct ClipMaskBind {
-//     allowed_entities: HashMap<Entity>,
-// }
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-struct Ptr(*mut u8);
-
-// SAFETY: Store pointers to each attribute to be updated, a clip can't have two pointers
-// with the same value. Each clip per Animator will be updated sequentially
-unsafe impl Send for Ptr {}
-unsafe impl Sync for Ptr {}
-
-// /// Marker type for missing component
-// struct MissingComponentMarker;
-
-/// State info for the system `animator_binding_system`
-#[derive(Default)]
-struct BindingState {
-    clips_event_reader: EventReader<AssetEvent<Clip>>,
-    clips_modified: fnv::FnvHashSet<Handle<Clip>>,
-}
-
-/// Creates a new vector with a given size filled with the values returned by the given default function
-#[inline(always)]
-fn vec_filled<T, F: Fn() -> T>(size: usize, default: F) -> Vec<T> {
-    let mut v = vec![];
-    v.resize_with(size, default);
-    v
-}
-
-#[tracing::instrument(skip(world, resources))]
-pub fn animator_binding_system(world: &mut World, resources: &mut Resources) {
-    let system_id = SystemId(0); // ? NOTE: shouldn't be required to match the system id
-
-    // ! FIXME: These local resources seams to be quite slow, maybe I need a random system id?
-    // Fetch resources
-    let mut state = {
-        let state = resources.get_local_mut::<BindingState>(system_id);
-        match state {
-            Some(state) => state,
-            None => {
-                std::mem::drop(state); // ? NOTE: Makes the borrow checker happy
-                resources.insert_local(system_id, BindingState::default());
-                resources.get_local_mut::<BindingState>(system_id).unwrap()
-            }
-        }
-    };
-
-    let type_registry = resources.get::<TypeRegistry>().unwrap();
-    let mut type_registry_read_guard = None;
-
-    let clips = resources.get::<Assets<Clip>>().unwrap();
-    let clip_events = resources.get::<Events<AssetEvent<Clip>>>().unwrap();
-
-    // Builds query
-    // SAFETY: This is the only query with mutable reference the Animator component
-    let animator_query = unsafe { world.query_unchecked::<(Entity, &mut Animator), ()>() };
-
-    // ? NOTE: Changing a clip on fly is supported, but very expensive so use with caution
-    // Query all clips that changed and remove their binds from the animator
-    state.clips_modified.clear();
-    for event in state.clips_event_reader.iter(&clip_events) {
-        match event {
-            AssetEvent::Removed { handle } => state.clips_modified.insert(handle.clone()),
-            AssetEvent::Modified { handle } => state.clips_modified.insert(handle.clone()),
-            _ => false,
-        };
-    }
-
-    let mut entities_parent_changed = vec![];
-
-    // Used for entity translation
-    let mut entities_table_cache = vec![];
-
-    for (root, mut animator) in animator_query {
-        let animator = &mut *animator; // Make sure the borrow checker is happy
-
-        // Make room for binds or deallocate unused
-        animator
-            .bind_clips
-            .resize_with(animator.clips.len(), || None);
-
-        for (clip_handle, bind) in animator.clips.iter().zip(animator.bind_clips.iter_mut()) {
-            // Invalidate binds for clips that where modified
-            if state.clips_modified.contains(clip_handle) {
-                *bind = None;
-            }
-
-            let clip = clips.get(clip_handle);
-            if clip.is_none() {
-                // Clip missing, invalidate binds if any
-                *bind = None;
-                continue;
-            }
-
-            // Unwraps the clip
-            let clip = clip.unwrap();
-
-            // Prepare the entities table cache
-            entities_table_cache.clear();
-            entities_table_cache.resize(clip.hierarchy().len(), None);
-            // Assign the root entity as the first element
-            entities_table_cache[0] = Some(root);
-
-            let bind = if let Some(bind) = bind.as_mut() {
-                // Invalidate previously binded attributes
-
-                // Borrow checker sugar coat
-                let binded = &mut bind.binded;
-                let pointers = &mut bind.pointers;
-                let entities = &mut bind.entities;
-
-                // NOTE: Must be empty in this next function, if not it means
-                // something went wrong in the previous iteration
-                debug_assert!(
-                    entities_parent_changed.len() == 0,
-                    "parent changes have not been properly handled"
-                );
-
-                entities
-                    .iter_mut()
-                    .enumerate()
-                    // Find entities that changed
-                    .filter(|(entity_index, entry)| {
-                        if entry.is_none() {
-                            // Already invalid
-                            return false;
-                        }
-                        let inner = entry.as_ref().unwrap();
-
-                        // Not root
-                        if *entity_index > 0 {
-                            // TODO: Check the entity name
-                            if let Ok(Parent(parent)) = world.query_one::<&Parent>(inner.entity) {
-                                // Parent changed or removed
-                                if inner.parent != Some(*parent) {
-                                    entities_parent_changed.push(*entity_index as u16);
-                                    return true;
-                                }
-                            } else {
-                                // Parent removed
-                                entities_parent_changed.push(*entity_index as u16);
-                                return true;
-                            }
-                        }
-
-                        if let Some(loc) = world.get_entity_location(inner.entity) {
-                            if inner.location != loc {
-                                // Entity archetype changed
-                                return true;
-                            }
-                        } else {
-                            // Entity deleted
-                            entities_parent_changed.push(*entity_index as u16);
-                            return true;
-                        }
-
-                        // Entity didn't change
-                        false
-                    })
-                    // Invalidate all entities that changed
-                    .for_each(|(entity_index, entry)| {
-                        *entry = None;
-                        // ? NOTE: Will only run if the bind was invalidated in this frame
-                        for (descriptor, attr) in clip.curves().zip(pointers.iter_mut()) {
-                            if descriptor.0.entity_index as usize == entity_index {
-                                *attr = Ptr(null_mut());
-                            }
-                        }
-                        *binded = false;
-                    });
-
-                // Handle entities that had theirs parents changed
-                // ? NOTE: Heavy code path triggered when an animated hierarchy changes
-                while let Some(entity_index) = entities_parent_changed.pop() {
-                    clip.hierarchy()
-                        .depth_first(entity_index, &mut |entity_index, _| {
-                            let entry = &mut entities[entity_index as usize];
-
-                            if entry.is_some() {
-                                // Yet not invalidated
-                                for (descriptor, attr) in clip.curves().zip(pointers.iter_mut()) {
-                                    if descriptor.0.entity_index == entity_index {
-                                        *attr = Ptr(null_mut());
-                                    }
-                                }
-
-                                *entry = None;
-                            }
-
-                            *binded = false;
-                        });
-                }
-
-                bind
-            } else {
-                // Create empty binds
-                *bind = Some(ClipBind {
-                    entities: vec_filled(clip.hierarchy().len(), || None),
-                    binded: false,
-                    pointers: vec_filled(clip.len() as usize, || Ptr(null_mut())),
-                });
-
-                bind.as_mut().unwrap()
-            };
-
-            // All attributes are binded
-            if bind.binded {
-                continue;
-            }
-
-            // Will be cleared if any attribute fail to bind
-            bind.binded = true;
-
-            // Bind attributes
-            for (attr_index, (attr, descriptor)) in
-                bind.pointers.iter_mut().zip(clip.curves()).enumerate()
-            {
-                let (entry, curve) = descriptor;
-
-                if *attr != Ptr(null_mut()) {
-                    // Already binded
-                    continue;
-                }
-
-                // ! NOTE: Unbinded attributes will trigger this code path every frame,
-                // ! so missing attributes will make a dent in the performance,
-
-                // Query component by name
-                // TODO: Log error instead of panic ...
-                let attr_path = &clip.properties()[entry.property_index as usize];
-                let mut path = attr_path.split('.');
-                let component_short_name = path.next().expect("missing component short name");
-
-                if let Some(entity) = clip.hierarchy().find_entity_in_world(
-                    entry.entity_index,
-                    &mut entities_table_cache,
-                    &world,
-                ) {
-                    let location = world.get_entity_location(entity).unwrap();
-
-                    bind.entities[entry.entity_index as usize].get_or_insert_with(|| {
-                        ClipBindEntity {
-                            // If the entity was found the parent was as well (unless is the root which will always be None)
-                            parent: entities_table_cache
-                                .get(clip.hierarchy().get_entity(entry.entity_index).0 as usize)
-                                .copied()
-                                .flatten(),
-                            entity,
-                            location,
-                        }
-                    });
-
-                    if let Some(component_reg) = type_registry_read_guard
-                        .get_or_insert_with(|| type_registry.component.read()) // Lazily gets type registry read lock
-                        .get_with_short_name(component_short_name)
-                    {
-                        // ! FIXME: This function should fail, if the entity doesn't have the component
-                        let root_props = component_reg.get_component_properties(
-                            &world.archetypes[location.archetype as usize],
-                            location.index,
-                        );
-
-                        *attr = find_property_ptr(
-                            path,
-                            root_props,
-                            clip.get(attr_index as u16).unwrap().value_type(),
-                        );
-
-                        // Clear binded bit if not fully binded
-                        bind.binded &= *attr != Ptr(null_mut());
-                    } else {
-                        bind.binded = false;
-                        panic!("component `{}` not registered", component_short_name);
-                    }
-                } else {
-                    // Missing entity
-                    bind.binded = false;
-                }
-
-                // TODO: Check bounds and memory alignment whenever the binds change
-                // do this by: sorting the pointers and then checking if the curve value type size
-                // doesn't overlap with the next pointer
-            }
-        }
-    }
-}
-
-fn find_property_at_path<'a, P: Iterator<Item = &'a str>>(
-    path: P,
-    root_props: &dyn Properties,
-    type_id: TypeId,
-) -> Option<&dyn Property> {
-    let mut target = None;
-    let mut current = Some(root_props);
-    for property_name in path {
-        if let Some(property) = current.map(|p| p.prop(property_name)).flatten() {
-            // NOTE: Vec, HashMap and other types can't be animated
-            // and needed to be filtered out
-            if property.property_type() != PropertyType::Value {
-                target = None;
-                break;
-            }
-
-            target = Some(property);
-            current = property.as_properties();
-        } else {
-            // Failed to find property
-            target = None;
-            break;
-        }
-    }
-
-    target.and_then(|prop| {
-        if prop.any().type_id() == type_id {
-            Some(prop)
-        } else {
-            None
-        }
-    })
-}
-
-#[inline(always)]
-fn find_property_ptr<'a, P: Iterator<Item = &'a str>>(
-    path: P,
-    root_props: &dyn Properties,
-    type_id: TypeId,
-) -> Ptr {
-    Ptr(find_property_at_path(path, root_props, type_id)
-        .map(|prop| {
-            let ptr = prop as *const _ as *mut u8;
-            // Perform an extra assertion to make sure this pointer is inside the component
-            // memory bounds, so no dangle pointers can be created
-            {
-                let root = root_props as *const _ as *mut u8;
-                let size = std::mem::size_of_val(root_props) as isize;
-                // With the new bevy_reflect we can ref properties inside vectors and other things
-                if unsafe { root.offset_from(ptr).abs() } >= size {
-                    // TODO: log also the full property path
-                    panic!("property outside component");
-                    //return null_mut();
-                }
-            }
-            ptr
-        })
-        .unwrap_or(null_mut()))
-}
-
-#[tracing::instrument(skip(world, resources))]
-pub fn animator_update_system(world: &mut World, resources: &mut Resources) {
-    /// Small value
-    const SMOL: f32 = 1e-8;
-
-    let time = resources.get::<Time>().unwrap();
-    let clips = resources.get::<Assets<Clip>>().unwrap();
-
-    // SAFETY: This is the only query with mutable reference the Animator component
-    let animators_query = unsafe { world.query_unchecked::<(&mut Animator,), ()>() };
-    let delta_time = time.delta_seconds;
-
-    // ? NOTE: Keep in mind that one hierarchy tree could have many `Animator`s thus
-    // ? we can't parallelize over the animators easily without creating a race condition
-    for (mut animator,) in animators_query {
-        let animator = &mut *animator;
-
-        // Time scales by component
-        let delta_time = delta_time * animator.time_scale;
-
-        let w_total = animator
-            .layers
-            .iter()
-            .fold(0.0, |w, layer| w + layer.weight);
-
-        let norm = 1.0 / w_total;
-
-        // Normalize all states weights
-        for layer in &mut animator.layers {
-            layer.weight *= norm;
-        }
-
-        animator.visited.clear();
-        for layer in &mut animator.layers {
-            let clip_index = layer.clip;
-            if let Some(clip) = animator
-                .clips
-                .get(clip_index as usize)
-                .map(|clip_handle| clips.get(clip_handle))
-                .flatten()
-            {
-                // TODO: Add layer mask
-
-                if let Some(bind) = &animator.bind_clips[clip_index as usize] {
-                    let curves_count = clip.len() as usize;
-
-                    // Ensure capacity for cached keyframe index vec
-                    if layer.keyframe.len() != curves_count {
-                        layer.keyframe.clear();
-                        layer
-                            .keyframe
-                            .resize_with(curves_count, || Default::default());
-                    }
-
-                    // Update time
-                    let mut time = layer.time + delta_time * layer.time_scale;
-
-                    // TODO: I notice some jitter during playback
-
-                    // Warp mode
-                    if clip.warp {
-                        // Warp Around
-                        if time > clip.duration() {
-                            time = (time / clip.duration()).fract() * clip.duration();
-                            // Reset all keyframes cached indexes
-                            layer
-                                .keyframe
-                                .iter_mut()
-                                .for_each(|x| *x = Default::default())
-                        }
-                    } else {
-                        // Hold
-                        time = time.min(clip.duration());
-                    }
-
-                    // Advance state time
-                    layer.time = time;
-
-                    let w = layer.weight;
-                    if w < SMOL {
-                        continue;
-                    }
-
-                    // TODO: can be done in bached_parallel if is visited warped inside a mutex
-                    for (curve_index, (ptr, keyframe)) in bind
-                        .pointers
-                        .iter()
-                        .zip(layer.keyframe.iter_mut())
-                        .enumerate()
-                    {
-                        // Skip invalid properties
-                        if *ptr == Ptr(null_mut()) {
-                            continue;
-                        }
-
-                        let curve = clip
-                            .get(curve_index as u16)
-                            .expect("curve index out of bounds");
-
-                        let viz = if animator.visited.contains(&ptr) {
-                            true
-                        } else {
-                            animator.visited.insert(*ptr);
-                            false
-                        };
-
-                        // SAFETY: The `animator_binding_system` is responsible to invalidate and/or update
-                        // any ptr that no longer pointers to the right component for the right entity;
-                        // Also it will only allows to ptr to attributes by value inside the component this means
-                        // no dangle pointers
-
-                        match curve {
-                            CurveUntyped::Float(v) => {
-                                let (k, v) = v.sample_indexed(*keyframe, time);
-                                *keyframe = k;
-
-                                unsafe {
-                                    let ptr = ptr.0 as *mut f32;
-                                    if viz {
-                                        *ptr = LerpValue::lerp(&*ptr, &v, w);
-                                    } else {
-                                        *ptr = v;
-                                    }
-                                }
-                            }
-                            CurveUntyped::Vec3(v) => {
-                                let (k, v) = v.sample_indexed(*keyframe, time);
-                                *keyframe = k;
-
-                                unsafe {
-                                    let ptr = ptr.0 as *mut Vec3;
-                                    if viz {
-                                        *ptr = LerpValue::lerp(&*ptr, &v, w);
-                                    } else {
-                                        *ptr = v;
-                                    }
-                                }
-                            }
-                            CurveUntyped::Vec4(c) => {
-                                let (k, v) = c.sample_indexed(*keyframe, time);
-                                *keyframe = k;
-
-                                unsafe {
-                                    let ptr = ptr.0 as *mut Vec4;
-                                    if viz {
-                                        *ptr = LerpValue::lerp(&*ptr, &v, w);
-                                    } else {
-                                        *ptr = v;
-                                    }
-                                }
-                            }
-                            CurveUntyped::Quat(v) => {
-                                let (k, v) = v.sample_indexed(*keyframe, time);
-                                *keyframe = k;
-
-                                unsafe {
-                                    let ptr = ptr.0 as *mut Quat;
-                                    if viz {
-                                        // ? NOTE: Always nlerp, because blending the same clips in different order must yield the same results
-                                        // ! NOTE: This now one of (if not) the most expensive thing been executed in the animator_update_system
-                                        // ! blending more layers will increase the cost, change this behavior will result in change of the final motion
-                                        // ! in unexpected ways (maybe not by much but still)
-                                        *ptr = LerpValue::lerp(&*ptr, &v, w);
-                                    } else {
-                                        *ptr = v;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        // TODO: Make sure to update the components states to trigger 'Mutated'
-    }
-}
-
-// pub struct ClipLoader;
-
-// impl AssetLoader for ClipLoader {
-//     fn load<'a>(
-//         &'a self,
-//         bytes: &'a [u8],
-//         load_context: &'a mut bevy::asset::LoadContext,
-//     ) -> bevy::utils::BoxedFuture<'a, Result<()>> {
-//         Box::pin(async move {
-//             let clip: Clip = ron::de::from_bytes(bytes)?;
-//             load_context.set_default_asset(LoadedAsset::new(clip));
-//             Ok(())
-//         })
-//     }
-
-//     fn extensions(&self) -> &[&str] {
-//         &["anim"]
-//     }
-// }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::curve::Curve;
-
-    #[test]
-    fn unhandled_properties_implementation_for_types() {
-        // This is take as granted to simplify the function `Clip::add_animated_prop`
-        // you can give a look into it to see more about their implications
-
-        macro_rules! check_for_properties {
-            ($t:ty) => {{
-                let v = <$t>::default();
-                let p: &dyn Property = &v;
-                assert!(
-                    p.as_properties().is_none(),
-                    "unhandled impl `Properties` for {}",
-                    stringify!($t)
-                );
-            }};
-        }
-
-        check_for_properties!(f32);
-        check_for_properties!(Vec2);
-        check_for_properties!(Vec3);
-        //check_for_properties!(Vec4); // TODO: Vec4 should implement at least Property
-        check_for_properties!(Quat);
-        //check_for_properties!(Color); // TODO: sRGB Color
-    }
-
-    #[allow(dead_code)]
-    struct AnimatorTestBench {
-        app: bevy_app::App,
-        entities: Vec<Entity>,
-        schedule: bevy_ecs::Schedule,
-    }
-
-    impl AnimatorTestBench {
-        fn new() -> Self {
-            let mut app_builder = bevy_app::App::build();
-            app_builder
-                .add_plugin(bevy_type_registry::TypeRegistryPlugin::default())
-                .add_plugin(bevy_core::CorePlugin::default())
-                .add_plugin(bevy_app::ScheduleRunnerPlugin::default())
-                .add_plugin(bevy_asset::AssetPlugin)
-                .add_plugin(bevy_transform::TransformPlugin)
-                .add_plugin(crate::AnimationPlugin);
-
-            let mut world = World::new();
-            let mut world_builder = world.build();
-            let base = (
-                GlobalTransform::default(),
-                Transform::from_translation(Vec3::new(0.0, 1.0, 0.0)),
-            );
-
-            // Create animator and assign some clips
-            let mut animator = Animator::default();
-            {
-                let mut clip_a = Clip::default();
-                clip_a.add_animated_prop(
-                    "@Transform.translation",
-                    CurveUntyped::Vec3(Curve::from_linear(
-                        0.0,
-                        1.0,
-                        Vec3::unit_x(),
-                        -Vec3::unit_x(),
-                    )),
-                );
-                let rot = CurveUntyped::Quat(Curve::from_constant(Quat::identity()));
-                clip_a.add_animated_prop("@Transform.rotation", rot.clone());
-                clip_a.add_animated_prop("/Node1@Transform.rotation", rot.clone());
-                clip_a.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
-
-                let mut clip_b = Clip::default();
-                clip_b.add_animated_prop(
-                    "@Transform.translation",
-                    CurveUntyped::Vec3(Curve::from_constant(Vec3::zero())),
-                );
-                let rot = CurveUntyped::Quat(Curve::from_linear(
-                    0.0,
-                    1.0,
-                    Quat::from_axis_angle(Vec3::unit_z(), 0.1),
-                    Quat::from_axis_angle(Vec3::unit_z(), -0.1),
-                ));
-                clip_b.add_animated_prop("@Transform.rotation", rot.clone());
-                clip_b.add_animated_prop("/Node1@Transform.rotation", rot.clone());
-                clip_b.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
-
-                let mut clips = app_builder
-                    .resources_mut()
-                    .get_mut::<Assets<Clip>>()
-                    .unwrap();
-                let clip_a = clips.add(clip_a);
-                let clip_b = clips.add(clip_b);
-
-                animator.add_layer(clip_a, 0.5);
-                animator.add_layer(clip_b, 0.5);
-            }
-
-            let mut entities = vec![];
-            entities.push(
-                world_builder
-                    .spawn(base.clone())
-                    .with(Name::from_str("Root"))
-                    .with(animator)
-                    .current_entity
-                    .unwrap(),
-            );
-            world_builder.with_children(|world_builder| {
-                entities.push(
-                    world_builder
-                        .spawn(base.clone())
-                        .with(Name::from_str("Node1"))
-                        .current_entity()
-                        .unwrap(),
-                );
-
-                world_builder.with_children(|world_builder| {
-                    entities.push(
-                        world_builder
-                            .spawn(base.clone())
-                            .with(Name::from_str("Node2"))
-                            .current_entity()
-                            .unwrap(),
-                    );
-
-                    world_builder.with_children(|world_builder| {
-                        entities.push(
-                            world_builder
-                                .spawn(base.clone())
-                                .with(Name::from_str("Node3"))
-                                .current_entity()
-                                .unwrap(),
-                        );
-                    });
-                });
-            });
-
-            app_builder.set_world(world);
-
-            let mut schedule = bevy_ecs::Schedule::default();
-            schedule.add_stage("update");
-            schedule.add_stage_after("update", "post_update");
-            schedule.add_system_to_stage("update", animator_binding_system);
-            schedule.add_system_to_stage("update", animator_update_system);
-            schedule.add_system_to_stage("post_update", parent_update_system);
-            //schedule.add_system_to_stage("update", transform_propagate_system);
-
-            schedule.initialize(&mut app_builder.app.world, &mut app_builder.app.resources);
-            schedule.run(&mut app_builder.app.world, &mut app_builder.app.resources);
-
-            Self {
-                app: app_builder.app,
-                entities,
-                schedule,
-            }
-        }
-
-        fn run(&mut self) {
-            self.schedule
-                .run(&mut self.app.world, &mut self.app.resources);
-        }
-
-        fn validate_binds<F: Fn(usize, usize, &Ptr)>(&self, validation: F) {
-            let animator = self
-                .app
-                .world
-                .get::<Animator>(self.entities[0])
-                .expect("missing animator");
-
-            animator
-                .bind_clips
-                .iter()
-                .map(|b| b.as_ref().expect("missing clip bind"))
-                .enumerate()
-                .for_each(|(i, b)| {
-                    b.pointers
-                        .iter()
-                        .enumerate()
-                        .for_each(|(j, attr)| validation(i, j, attr));
-                });
-        }
-    }
-
-    #[test]
-    fn entity_deleted() {
-        // Tests for hierarch change deletion and creation of some entity that is been animated
-        let mut test_bench = AnimatorTestBench::new();
-
-        test_bench.validate_binds(|curve_index, prop_index, ptr| {
-            assert!(
-                *ptr != Ptr(null_mut()),
-                "property {} unbinded in curve {}",
-                prop_index,
-                curve_index,
-            )
-        });
-
-        // delete "Node1"
-        test_bench
-            .app
-            .world
-            .despawn(test_bench.entities[1])
-            .unwrap();
-
-        // Tick
-        test_bench.run();
-
-        test_bench.validate_binds(|curve_index, prop_index, ptr| {
-            if prop_index < [2, 2][curve_index] {
-                assert!(
-                    *ptr != Ptr(null_mut()),
-                    "property {} unbinded in curve {}",
-                    prop_index,
-                    curve_index,
-                )
-            } else {
-                assert!(
-                    *ptr == Ptr(null_mut()),
-                    "property {} still binded in curve {}",
-                    prop_index,
-                    curve_index,
-                )
-            }
-        });
-
-        // Re-add "Node1"
-        test_bench.entities[1] = test_bench
-            .app
-            .world
-            .build()
-            .spawn((
-                GlobalTransform::default(),
-                Transform::from_translation(Vec3::new(0.0, 1.0, 0.0)),
-                Name::from_str("Node1"),
-                Parent(test_bench.entities[0]),
-            ))
-            .current_entity
-            .unwrap();
-
-        *test_bench
-            .app
-            .world
-            .get_mut::<Parent>(test_bench.entities[2])
-            .unwrap() = Parent(test_bench.entities[1]);
-
-        // Tick
-        // ! FIXME: May take one frame to bind the missing properties because
-        // ! the `parent_update_system` must run in order to update the `Children` component
-        test_bench.run();
-        test_bench.run();
-
-        test_bench.validate_binds(|curve_index, prop_index, ptr| {
-            assert!(
-                *ptr != Ptr(null_mut()),
-                "property {} wasn't rebinded in curve {}",
-                prop_index,
-                curve_index,
-            )
-        });
-    }
-
-    #[test]
-    fn entity_parent_changed() {
-        // Tests for hierarch change deletion and creation of some entity that is been animated
-        let mut test_bench = AnimatorTestBench::new();
-
-        test_bench.validate_binds(|curve_index, prop_index, ptr| {
-            assert!(
-                *ptr != Ptr(null_mut()),
-                "property {} unbinded in curve {}",
-                prop_index,
-                curve_index,
-            )
-        });
-
-        // Change parent of node "Node1"
-        let new_parent = test_bench
-            .app
-            .world
-            .build()
-            .spawn(())
-            .current_entity
-            .unwrap();
-
-        *test_bench
-            .app
-            .world
-            .get_mut::<Parent>(test_bench.entities[1])
-            .unwrap() = Parent(new_parent);
-
-        // Tick
-        test_bench.run();
-
-        test_bench.validate_binds(|curve_index, prop_index, ptr| {
-            if prop_index < [2, 2][curve_index] {
-                assert!(
-                    *ptr != Ptr(null_mut()),
-                    "property {} unbinded in curve {}",
-                    prop_index,
-                    curve_index,
-                )
-            } else {
-                assert!(
-                    *ptr == Ptr(null_mut()),
-                    "property {} still binded in curve {}",
-                    prop_index,
-                    curve_index,
-                )
-            }
-        });
-
-        // Re-parent "Node1"
-        *test_bench
-            .app
-            .world
-            .get_mut::<Parent>(test_bench.entities[1])
-            .unwrap() = Parent(test_bench.entities[0]);
-
-        // Tick
-        // ! FIXME: May take one frame to bind the missing properties because
-        // ! the `parent_update_system` must run in order to update the `Children` component
-        test_bench.run();
-        test_bench.run();
-
-        test_bench.validate_binds(|curve_index, prop_index, ptr| {
-            assert!(
-                *ptr != Ptr(null_mut()),
-                "property {} wasn't rebinded in curve {}",
-                prop_index,
-                curve_index,
-            )
-        });
-    }
-
-    #[test]
-    fn entity_archetype_change() {
-        // Add tests for entity archetype change
-
-        // TODO: Add extra dummy component
-        // TODO: Remove dummy component
-        // TODO: Remove parent
-
-        unimplemented!()
-    }
-
-    #[test]
-    fn entity_renamed() {
-        unimplemented!()
-    }
-
-    #[test]
-    fn missing_component_in_entity() {
-        // TODO: try to bind a property against a existent entity that doesn't have the target component
-        unimplemented!()
-    }
-
-    #[test]
-    fn entity_with_same_name() {
-        // TODO: Add tests for entities with same Name
-        unimplemented!()
-    }
-
-    #[test]
-    fn clip_changed() {
-        // TODO: Add tests for mutated events
-        unimplemented!()
-    }
-
-    #[test]
-    fn animated_components_are_marked_as_mutated() {
-        // TODO: Add tests for animated components should trigger 'Mutated' queries filters (impl missing)
-        unimplemented!()
-    }
-
-    #[test]
-    fn swapping_handle_animation() {
-        // TODO: Add tests for animated handle (impl missing)
-        unimplemented!()
-    }
-
-    #[test]
-    fn animate_asset_properties() {
-        // TODO: Add tests for animated asset properties (impl missing)
-        unimplemented!()
-    }
-
-    #[test]
-    #[cfg(feature = "extra-profiling-tests")]
-    fn test_bench_update() {
-        // ? NOTE: Mimics a basic system update behavior good for pref since criterion will pollute the
-        // ? annotations with many expensive instructions
-        let mut test_bench = AnimatorTestBench::new();
-        test_bench.run();
-
-        for _ in 0..1_000_000 {
-            // Time tick
-            {
-                let mut time = test_bench.app.resources.get_mut::<Time>().unwrap();
-                time.delta_seconds += 0.016;
-                time.delta_seconds_f64 += 0.016;
-            }
-
-            animator_update_system(&mut test_bench.app.world, &mut test_bench.app.resources);
-        }
-    }
-
-    #[test]
-    #[cfg(feature = "extra-profiling-tests")]
-    fn test_bench_binding() {
-        // ? NOTE: Mimics a basic system update behavior good for pref since criterion will pollute the
-        // ? annotations with many expensive instructions
-        let mut test_bench = AnimatorTestBench::new();
-        test_bench.run();
-
-        for _ in 0..1_000_000 {
-            animator_binding_system(&mut test_bench.app.world, &mut test_bench.app.resources);
-        }
-    }
-
-    // TODO: test update with 5 layers or more ...
-}
diff --git a/crates/bevy_animation/src/impls.rs b/crates/bevy_animation/src/impls.rs
index fdce41613896d..dc9c6dfcd1fe4 100644
--- a/crates/bevy_animation/src/impls.rs
+++ b/crates/bevy_animation/src/impls.rs
@@ -72,7 +72,59 @@ impl AnimatedComponent for Transform {
                             if let Some(ref mut component) = components[entity_index as usize] {
                                 let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
                                 keyframes[*curve_index] = k;
-                                component.translation.blend(&mut blend_group, v, w);
+                                //component.translation.blend(&mut blend_group, v, w);
+                                // ? NOTE: Blend must be done for each component in order for it to work
+                                component.translation.x.blend(&mut blend_group, v.x, w);
+                                component.translation.y.blend(&mut blend_group, v.y, w);
+                                component.translation.z.blend(&mut blend_group, v.z, w);
+                            }
+                        }
+                    } else {
+                        if let Some(curves) = clip
+                            .get("Transform.translation.x")
+                            .map(|curve_untyped| curve_untyped.downcast_ref::<f32>())
+                            .flatten()
+                        {
+                            for (entity_index, (curve_index, curve)) in curves.iter() {
+                                let entity_index = entities_map[entity_index as usize];
+                                if let Some(ref mut component) = components[entity_index as usize] {
+                                    let (k, v) =
+                                        curve.sample_indexed(keyframes[*curve_index], time);
+                                    keyframes[*curve_index] = k;
+                                    component.translation.x.blend(&mut blend_group, v, w);
+                                }
+                            }
+                        }
+
+                        if let Some(curves) = clip
+                            .get("Transform.translation.y")
+                            .map(|curve_untyped| curve_untyped.downcast_ref::<f32>())
+                            .flatten()
+                        {
+                            for (entity_index, (curve_index, curve)) in curves.iter() {
+                                let entity_index = entities_map[entity_index as usize];
+                                if let Some(ref mut component) = components[entity_index as usize] {
+                                    let (k, v) =
+                                        curve.sample_indexed(keyframes[*curve_index], time);
+                                    keyframes[*curve_index] = k;
+                                    component.translation.y.blend(&mut blend_group, v, w);
+                                }
+                            }
+                        }
+
+                        if let Some(curves) = clip
+                            .get("Transform.translation.z")
+                            .map(|curve_untyped| curve_untyped.downcast_ref::<f32>())
+                            .flatten()
+                        {
+                            for (entity_index, (curve_index, curve)) in curves.iter() {
+                                let entity_index = entities_map[entity_index as usize];
+                                if let Some(ref mut component) = components[entity_index as usize] {
+                                    let (k, v) =
+                                        curve.sample_indexed(keyframes[*curve_index], time);
+                                    keyframes[*curve_index] = k;
+                                    component.translation.z.blend(&mut blend_group, v, w);
+                                }
                             }
                         }
                     }
@@ -92,6 +144,8 @@ impl AnimatedComponent for Transform {
                         }
                     }
 
+                    // TODO: Euler rotation support?
+
                     if let Some(curves) = clip
                         .get("Transform.scale")
                         .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
@@ -228,6 +282,15 @@ impl AnimatedAsset for StandardMaterial {
     }
 }
 
+// #[derive(Debug, AnimatedComponent)]
+// struct Test {
+//     #[animated(expand { x: f32, y: f32, z: f32 })]
+//     a: Vec3,
+//     b: Vec2,
+//     #[animated(ignore)]
+//     c: Vec3,
+// }
+
 // animated_component! {
 //     struct Transform {
 //         translation: Vec3,
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index b56e957f3db85..21e18f69f6716 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -25,8 +25,7 @@ pub mod prelude {
     pub use crate::app::AddAnimated;
     pub use crate::blending::AnimatorBlending;
     pub use crate::curve::{Curve, CurveUntyped};
-    pub use crate::custom::Clip;
-    pub use crate::custom::{AnimatedAsset, AnimatedComponent, Animator};
+    pub use crate::custom::{AnimatedAsset, AnimatedComponent, Animator, Clip};
     pub use crate::hierarchy::Hierarchy;
     pub use crate::lerping::Lerp;
     pub use crate::skinned_mesh::{SkinAsset, SkinComponent, SkinDebugger};

From 7f790a5d2212fd63d159b94e297af24d67916777 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Thu, 24 Dec 2020 19:05:51 -0300
Subject: [PATCH 058/153] wip type safe animated properties

---
 crates/bevy_animation/src/custom.rs | 180 +++++++++++++++++++++-------
 crates/bevy_animation/src/impls.rs  |  92 ++++++++++++++
 2 files changed, 231 insertions(+), 41 deletions(-)

diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index e580f49aa8476..a14470eadb510 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -9,7 +9,10 @@ use fnv::FnvBuildHasher;
 use smallvec::{smallvec, SmallVec};
 use std::{
     any::Any,
+    borrow::Cow,
     collections::{HashMap, HashSet},
+    marker::PhantomData,
+    // ops::Deref,
 };
 
 use crate::blending::AnimatorBlending;
@@ -96,11 +99,12 @@ impl CurvesUntyped {
     }
 }
 
-// TODO: Didn't make my mind about it
 // Pros:
 //  - Can limit to only the entities that we really want to animate, from deep nested hierarchies
 //  - Entities names don't matter
 //  - Hierarchy don't matter with can be nice if you keep changing it
+//  - Easer to design a LayerMask around it
+//  - Bit less memory
 // Cons:
 //  - Harder to modify and manipulate clips
 //  - Harder to find entities
@@ -115,7 +119,6 @@ impl CurvesUntyped {
 // }
 
 // TODO: impl Serialize, Deserialize using bevy reflect for that
-// TODO: Study an optional asset that lists all animated entities, to take preference over
 // the hierarchy, this animated entity asset must match the one been used in the animator
 // this could help retarget animations, but will mess the clip
 #[derive(Debug, TypeUuid)]
@@ -129,11 +132,12 @@ pub struct Clip {
     pub warp: bool,
     /// Clip compound duration
     duration: f32,
-    // ! FIXME: The hierarchy may need to know more entities than the current been animated
-    // ! this will case them to fetch extra entities components that aren't used at all
+    // ! FIXME: Limit to only entities that have animations to avoid
+    // ! fetching extra components that aren't been used
     hierarchy: Hierarchy,
     // ? NOTE: AHash performed worse than FnvHasher
-    /// Each curve and keyframe cache index mapped by property name  
+    // TODO: Change to Cow<'static, str> since it will be used quit a lot as the common case
+    /// Each curve and keyframe cache index mapped by property name
     properties: HashMap<String, (usize, CurvesUntyped), FnvBuildHasher>,
     /// Number of animated properties
     len: usize,
@@ -159,18 +163,80 @@ impl Default for Clip {
     }
 }
 
+/// A type safe way of referring to properties that can be animated.
+///
+/// If a type implements `AnimatedProperties` each property can be retrieved
+/// by `Transform::props().translation().x()`
+pub struct Prop<CurveType, InnerProps = ()> {
+    pub name: Cow<'static, str>,
+    _marker: PhantomData<(CurveType, InnerProps)>,
+}
+
+impl<CurveType, InnerProps> Prop<CurveType, InnerProps> {
+    pub const fn borrowed(name: &'static str) -> Self {
+        Prop {
+            name: Cow::Borrowed(name),
+            _marker: PhantomData,
+        }
+    }
+
+    pub const fn owned(name: String) -> Self {
+        Prop {
+            name: Cow::Owned(name),
+            _marker: PhantomData,
+        }
+    }
+}
+
+// TODO: How to implement this
+// impl<CurveType, InnerProps> Deref for Prop<CurveType, InnerProps> {
+//     type Target = InnerProps;
+//
+//     fn deref(&self) -> &Self::Target {
+//         todo!()
+//     }
+// }
+
 impl Clip {
-    // TODO: Make harder to make mistakes like assigning a Curve<f32> to a rotation, or misspell names
     // TODO: Warn about properties that aren't been used so the user can check if they are wrong or not
-    /// Property to be animated must be in the following format `"path/to/named_entity@Transform.translation.x"`
-    /// where the left side `@` defines a path to the entity to animate,
-    /// while the right side the path to a property to animate starting from the component.
+    // TODO: Function docs
+    /// ???
+    /// This is the preferred method of adding curves into a clip, since it's better future proof than `add_curve_at_path`;
     ///
     /// **NOTE** This is a expensive function;
     ///
     /// **NOTE** You can safely ignore the return value as it's only used for assertions during tests;
     /// The return value is the assigned curve index in cache line bucket.
-    pub fn add_animated_prop<T>(&mut self, property_path: &str, mut curve: Curve<T>) -> usize
+    pub fn add_curve<T, DontCare>(
+        &mut self,
+        entity_path: &str,
+        property_path: Prop<T, DontCare>,
+        curve: Curve<T>,
+    ) -> usize
+    where
+        T: Lerp + Clone + Send + Sync + 'static,
+    {
+        // ? NOTE: DontCare generic will trigger multiple compilations of the `add_prop`
+        // ? function, here convert between types to make it generic only over `T`
+        self.add_curve_generic(
+            entity_path,
+            Prop {
+                name: property_path.name,
+                _marker: PhantomData,
+            },
+            curve,
+        )
+    }
+
+    // TODO: Can I make it generic over `T` ?
+    /// Used only by `add_prop` function and it's main purpose is prevent
+    /// create multiple versions of this function over the DontCare generic  
+    fn add_curve_generic<T>(
+        &mut self,
+        entity_path: &str, // TODO: Replace to `EntityPath` or something similar to Prop
+        property_path: Prop<T>,
+        mut curve: Curve<T>,
+    ) -> usize
     where
         T: Lerp + Clone + Send + Sync + 'static,
     {
@@ -181,15 +247,11 @@ impl Clip {
             "clip curve limit reached"
         );
 
-        // Split in entity and attribute path,
-        // NOTE: use rfind because it's expected the latter to be generally shorter
-        let path =
-            property_path.split_at(property_path.rfind('@').expect("property path missing @"));
+        let (entity_index, _) = self.hierarchy.get_or_insert_entity(entity_path);
 
-        let (entity_index, _) = self.hierarchy.get_or_insert_entity(path.0);
-        let target_name = path.1.split_at(1).1;
-
-        if let Some((cache_index, curves_untyped)) = self.properties.get_mut(target_name) {
+        if let Some((cache_index, curves_untyped)) =
+            self.properties.get_mut(property_path.name.as_ref())
+        {
             let curves = curves_untyped
                 .downcast_mut::<T>()
                 .expect("properties can't have the same name and different curve types");
@@ -249,7 +311,10 @@ impl Clip {
 
         self.duration = self.duration.max(curve.duration());
         self.properties.insert(
-            target_name.to_string(),
+            match property_path.name {
+                Cow::Borrowed(name) => name.to_string(),
+                Cow::Owned(name) => name,
+            },
             (
                 cache_index,
                 CurvesUntyped::new(Curves {
@@ -262,6 +327,28 @@ impl Clip {
         cache_index
     }
 
+    /// Property to be animated must be in the following format `"path/to/named_entity@Transform.translation.x"`
+    /// where the left side `@` defines a path to the entity to animate,
+    /// while the right side the path to a property to animate starting from the component.
+    ///
+    /// Please use preferably `add_curve` as it's future proof and type safe;
+    ///
+    /// **NOTE** This is a expensive function;
+    ///
+    /// **NOTE** You can safely ignore the return value as it's only used for assertions during tests;
+    /// The return value is the assigned curve index in cache line bucket.
+    pub fn add_curve_at_path<T>(&mut self, path: &str, curve: Curve<T>) -> usize
+    where
+        T: Lerp + Clone + Send + Sync + 'static,
+    {
+        // Split in entity and attribute path,
+        // NOTE: use rfind because it's expected the latter to be generally shorter
+        let path = path.split_at(path.rfind('@').expect("property path missing @"));
+        let property_path = path.1.split_at(1).1;
+
+        self.add_curve::<T, ()>(path.0, Prop::owned(property_path.to_string()), curve)
+    }
+
     /// Number of animated properties in this clip
     #[inline(always)]
     pub fn len(&self) -> usize {
@@ -338,6 +425,7 @@ pub struct Layer {
     pub time_scale: f32,
     #[reflect(ignore)]
     keyframes_buckets: Vec<KeyframeBucket>,
+    // TODO: LayerMask
 }
 
 impl Default for Layer {
@@ -730,6 +818,14 @@ pub(crate) fn animator_update_system(
 
 // ! FIXME: Theres no way of free memory used by the `Local<AnimatorBlending>` in each system
 
+/// Provides a type safe way of get all properties that can be animated
+pub trait AnimatedProperties {
+    type Props;
+
+    /// Type safe animated properties of this component or asset
+    fn props() -> Self::Props;
+}
+
 pub trait AnimatedComponent: Component + Sized {
     fn animator_update_system(
         clips: Res<Assets<Clip>>,
@@ -788,18 +884,20 @@ mod tests {
             let mut animator = Animator::default();
             {
                 let mut clip_a = Clip::default();
-                clip_a.add_animated_prop(
-                    "@Transform.translation",
+                clip_a.add_curve(
+                    "",
+                    Transform::props().translation(),
                     Curve::from_linear(0.0, 1.0, Vec3::unit_x(), -Vec3::unit_x()),
                 );
                 let rot = Curve::from_constant(Quat::identity());
-                clip_a.add_animated_prop("@Transform.rotation", rot.clone());
-                clip_a.add_animated_prop("/Node1@Transform.rotation", rot.clone());
-                clip_a.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
+                clip_a.add_curve("", Transform::props().rotation(), rot.clone());
+                clip_a.add_curve("/Node1", Transform::props().rotation(), rot.clone());
+                clip_a.add_curve("/Node1/Node2", Transform::props().rotation(), rot);
 
                 let mut clip_b = Clip::default();
-                clip_b.add_animated_prop(
-                    "@Transform.translation",
+                clip_b.add_curve(
+                    "",
+                    Transform::props().translation(),
                     Curve::from_constant(Vec3::zero()),
                 );
                 let rot = Curve::from_linear(
@@ -808,9 +906,9 @@ mod tests {
                     Quat::from_axis_angle(Vec3::unit_z(), 0.1),
                     Quat::from_axis_angle(Vec3::unit_z(), -0.1),
                 );
-                clip_b.add_animated_prop("@Transform.rotation", rot.clone());
-                clip_b.add_animated_prop("/Node1@Transform.rotation", rot.clone());
-                clip_b.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
+                clip_b.add_curve("", Transform::props().rotation(), rot.clone());
+                clip_b.add_curve("/Node1", Transform::props().rotation(), rot.clone());
+                clip_b.add_curve("/Node1/Node2", Transform::props().rotation(), rot);
 
                 let mut clips = app_builder
                     .resources_mut()
@@ -1183,7 +1281,7 @@ mod tests {
             let clip_a_handle = test_bench.animator().clips()[0].clone();
             let mut clips = test_bench.app.resources.get_mut::<Assets<Clip>>().unwrap();
             let clip_a = clips.get_mut(clip_a_handle).unwrap();
-            clip_a.add_animated_prop(
+            clip_a.add_curve_at_path(
                 "/Node3/@Transform.translation",
                 Curve::from_linear(0.0, 1.0, Vec3::unit_z(), -Vec3::unit_z()),
             );
@@ -1216,40 +1314,40 @@ mod tests {
     fn clip_property_index_are_grouped_into_cache_line_buckets() {
         let curve = Curve::from_constant(0.0);
         let mut clip = Clip::default();
-        assert_eq!(clip.add_animated_prop("a@T.t", curve.clone()), 0);
-        assert_eq!(clip.add_animated_prop("b@T.t", curve.clone()), 1);
+        assert_eq!(clip.add_curve_at_path("a@T.t", curve.clone()), 0);
+        assert_eq!(clip.add_curve_at_path("b@T.t", curve.clone()), 1);
         assert_eq!(
-            clip.add_animated_prop("a@T.r", curve.clone()),
+            clip.add_curve_at_path("a@T.r", curve.clone()),
             KEYFRAMES_PER_CACHE
         );
-        assert_eq!(clip.add_animated_prop("c@T.t", curve.clone()), 2);
+        assert_eq!(clip.add_curve_at_path("c@T.t", curve.clone()), 2);
         assert_eq!(
-            clip.add_animated_prop("b@T.r", curve.clone()),
+            clip.add_curve_at_path("b@T.r", curve.clone()),
             KEYFRAMES_PER_CACHE + 1
         );
         assert_eq!(
-            clip.add_animated_prop("c@T.r", curve.clone()),
+            clip.add_curve_at_path("c@T.r", curve.clone()),
             KEYFRAMES_PER_CACHE + 2
         );
-        assert_eq!(clip.add_animated_prop("d@T.t", curve.clone()), 3);
+        assert_eq!(clip.add_curve_at_path("d@T.t", curve.clone()), 3);
 
         for i in 4..KEYFRAMES_PER_CACHE {
             assert_eq!(
-                clip.add_animated_prop(&format!("node_{}@T.t", i), curve.clone()),
+                clip.add_curve_at_path(&format!("node_{}@T.t", i), curve.clone()),
                 i
             );
         }
 
         assert_eq!(
-            clip.add_animated_prop("za@T.t", curve.clone()),
+            clip.add_curve_at_path("za@T.t", curve.clone()),
             KEYFRAMES_PER_CACHE * 2
         );
         assert_eq!(
-            clip.add_animated_prop("za@T.r", curve.clone()),
+            clip.add_curve_at_path("za@T.r", curve.clone()),
             KEYFRAMES_PER_CACHE + 3
         );
         assert_eq!(
-            clip.add_animated_prop("zb@T.t", curve.clone()),
+            clip.add_curve_at_path("zb@T.t", curve.clone()),
             KEYFRAMES_PER_CACHE * 2 + 1
         );
     }
diff --git a/crates/bevy_animation/src/impls.rs b/crates/bevy_animation/src/impls.rs
index dc9c6dfcd1fe4..5f32b2bb7f9ec 100644
--- a/crates/bevy_animation/src/impls.rs
+++ b/crates/bevy_animation/src/impls.rs
@@ -15,6 +15,58 @@ use bevy_render::{
 };
 use bevy_transform::prelude::*;
 
+pub struct TransformTranslationProps;
+
+impl Prop<Vec3, TransformTranslationProps> {
+    pub const fn x(&self) -> Prop<f32> {
+        Prop::borrowed("Transform.translation.x")
+    }
+
+    pub const fn y(&self) -> Prop<f32> {
+        Prop::borrowed("Transform.translation.y")
+    }
+
+    pub const fn z(&self) -> Prop<f32> {
+        Prop::borrowed("Transform.translation.z")
+    }
+}
+
+impl std::ops::Deref for Prop<Vec3, TransformTranslationProps> {
+    type Target = TransformTranslationProps;
+
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &TransformTranslationProps
+    }
+}
+
+pub struct TransformProps;
+
+impl TransformProps {
+    pub const fn translation(&self) -> Prop<Vec3, TransformTranslationProps> {
+        Prop::borrowed("Transform.translation")
+    }
+
+    pub const fn rotation(&self) -> Prop<Quat> {
+        Prop::borrowed("Transform.rotation")
+    }
+
+    pub const fn scale(&self) -> Prop<Vec3> {
+        Prop::borrowed("Transform.scale")
+    }
+}
+
+impl AnimatedProperties for Transform {
+    type Props = TransformProps;
+
+    #[inline(always)]
+    fn props() -> Self::Props {
+        TransformProps
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 impl AnimatedComponent for Transform {
     fn animator_update_system(
         clips: Res<Assets<Clip>>,
@@ -168,6 +220,42 @@ impl AnimatedComponent for Transform {
     }
 }
 
+///////////////////////////////////////////////////////////////////////////////
+
+pub struct StandardMaterialProps;
+
+impl StandardMaterialProps {
+    pub const fn albedo(&self) -> Prop<Color> {
+        Prop::borrowed("Handle<StandardMaterial>.albedo")
+    }
+
+    pub const fn albedo_texture(&self) -> Prop<Option<Handle<Texture>>> {
+        Prop::borrowed("Handle<StandardMaterial>.albedo_texture")
+    }
+}
+
+pub struct HandleStandardMaterialProps;
+
+impl HandleStandardMaterialProps {
+    pub const fn handle(&self) -> Prop<Handle<StandardMaterial>> {
+        Prop::borrowed("Handle<StandardMaterial>")
+    }
+
+    pub const fn fields(&self) -> StandardMaterialProps {
+        StandardMaterialProps
+    }
+}
+
+impl AnimatedProperties for StandardMaterial {
+    type Props = HandleStandardMaterialProps;
+
+    fn props() -> Self::Props {
+        HandleStandardMaterialProps
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 impl AnimatedAsset for StandardMaterial {
     fn animator_update_system(
         clips: Res<Assets<Clip>>,
@@ -282,6 +370,8 @@ impl AnimatedAsset for StandardMaterial {
     }
 }
 
+///////////////////////////////////////////////////////////////////////////////
+
 // #[derive(Debug, AnimatedComponent)]
 // struct Test {
 //     #[animated(expand { x: f32, y: f32, z: f32 })]
@@ -293,8 +383,10 @@ impl AnimatedAsset for StandardMaterial {
 
 // animated_component! {
 //     struct Transform {
+//         #[animated(expand { x: f32, y: f32, z: f32 })]
 //         translation: Vec3,
 //         rotation: Quat,
+//         #[animated(expand { x: f32, y: f32, z: f32 })]
 //         scale: Vec3,
 //     }
 // }

From d989f113970e0b37f7d76f6c7a2d53ebfaebbd4b Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Thu, 24 Dec 2020 20:12:20 -0300
Subject: [PATCH 059/153] hierarchy assert

---
 crates/bevy_animation/src/hierarchy.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/crates/bevy_animation/src/hierarchy.rs b/crates/bevy_animation/src/hierarchy.rs
index c9ddad17baa60..857c1f50fb619 100644
--- a/crates/bevy_animation/src/hierarchy.rs
+++ b/crates/bevy_animation/src/hierarchy.rs
@@ -46,7 +46,16 @@ impl<I: Index> Hierarchy<I> {
     /// Many different root nodes are supported although having other roots
     /// make hard to search entities, please refer to the documentation of
     /// `find_entity` or `find_entity_in_world` to see how.
+    ///
+    /// **WARNING** Be caution when using this function because it may create a
+    /// an invalid hierarchy
     pub fn from_ordered_entities(entities: Vec<(I, Name)>) -> Self {
+        assert_eq!(
+            entities[0].0,
+            I::MAX_VALUE,
+            "first entry must be an root entity"
+        );
+
         let mut children = vec![];
         children.resize_with(entities.len(), || smallvec![]);
 

From 8b23ea63a0633283ea9c694cee5d66bc37787123 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Thu, 24 Dec 2020 23:26:16 -0300
Subject: [PATCH 060/153] clean up and comments

---
 crates/bevy_animation/src/curve.rs  | 41 -----------------------------
 crates/bevy_animation/src/custom.rs |  4 +--
 crates/bevy_animation/src/lib.rs    |  2 +-
 3 files changed, 3 insertions(+), 44 deletions(-)

diff --git a/crates/bevy_animation/src/curve.rs b/crates/bevy_animation/src/curve.rs
index a76d63d2b41c1..5c42a4a94c6f2 100644
--- a/crates/bevy_animation/src/curve.rs
+++ b/crates/bevy_animation/src/curve.rs
@@ -1,48 +1,7 @@
-use bevy_math::prelude::*;
 use std::any::TypeId;
 
 use super::lerping::Lerp;
 
-// TODO: impl Serialize, Deserialize
-#[derive(Debug, Clone)]
-pub enum CurveUntyped {
-    Float(Curve<f32>),
-    //Vec2(Curve<Vec2>),
-    Vec3(Curve<Vec3>),
-    Vec4(Curve<Vec4>),
-    Quat(Curve<Quat>),
-    //Handle(Curve<HandleUntyped>),
-    // TODO: Color(Curve<Color>),
-}
-
-macro_rules! untyped_fn {
-    ($v:vis fn $name:ident ( &self, $( $arg:ident : $arg_ty:ty ,)* ) $(-> $ret:ty)* ) => {
-        $v fn $name(&self, $( $arg : $arg_ty ),*) $(-> $ret)* {
-            match self {
-                CurveUntyped::Float(v) => v.$name($($arg,)*),
-                CurveUntyped::Vec3(v) => v.$name($($arg,)*),
-                CurveUntyped::Vec4(v) => v.$name($($arg,)*),
-                CurveUntyped::Quat(v) => v.$name($($arg,)*),
-            }
-        }
-    };
-}
-
-impl CurveUntyped {
-    untyped_fn!(pub fn duration(&self,) -> f32);
-    untyped_fn!(pub fn value_type(&self,) -> TypeId);
-    //untyped_fn!(pub fn add_time_offset(&mut self, time: f32,) -> ());
-
-    pub fn add_time_offset(&mut self, time: f32) {
-        match self {
-            CurveUntyped::Float(v) => v.add_offset_time(time),
-            CurveUntyped::Vec3(v) => v.add_offset_time(time),
-            CurveUntyped::Vec4(v) => v.add_offset_time(time),
-            CurveUntyped::Quat(v) => v.add_offset_time(time),
-        }
-    }
-}
-
 // TODO: Curve/Clip need a validation during deserialization because they are
 // structured as SOA (struct of arrays), so the vec's length must match
 
diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index a14470eadb510..62e92925da0c1 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -199,8 +199,8 @@ impl<CurveType, InnerProps> Prop<CurveType, InnerProps> {
 
 impl Clip {
     // TODO: Warn about properties that aren't been used so the user can check if they are wrong or not
-    // TODO: Function docs
-    /// ???
+    /// Animates an entity property with a curve.
+    /// Adding the a second curve to the same entity and property will replace the first one;
     /// This is the preferred method of adding curves into a clip, since it's better future proof than `add_curve_at_path`;
     ///
     /// **NOTE** This is a expensive function;
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 21e18f69f6716..71be72aa5d75b 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -24,7 +24,7 @@ pub use bevy_animation_derive::*;
 pub mod prelude {
     pub use crate::app::AddAnimated;
     pub use crate::blending::AnimatorBlending;
-    pub use crate::curve::{Curve, CurveUntyped};
+    pub use crate::curve::Curve;
     pub use crate::custom::{AnimatedAsset, AnimatedComponent, Animator, Clip};
     pub use crate::hierarchy::Hierarchy;
     pub use crate::lerping::Lerp;

From 8e58b7f6e0c6f5e794468a9030709bfb81056987 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Thu, 24 Dec 2020 23:26:35 -0300
Subject: [PATCH 061/153] wip animator properties derive

---
 .../src/animated_properties.rs                | 156 ++++++++++++++++++
 .../bevy_animation_derive/src/help.rs         |  15 ++
 .../bevy_animation_derive/src/lib.rs          |  19 +++
 3 files changed, 190 insertions(+)
 create mode 100644 crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs
 create mode 100644 crates/bevy_animation/bevy_animation_derive/src/help.rs

diff --git a/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs b/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs
new file mode 100644
index 0000000000000..8193b1048788e
--- /dev/null
+++ b/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs
@@ -0,0 +1,156 @@
+use crate::{
+    help::snake_to_pascal_case,
+    modules::{get_modules, get_path},
+};
+use proc_macro::TokenStream;
+use proc_macro2::Span;
+use quote::quote;
+use syn::{
+    parse::ParseStream, parse_macro_input, parse_quote, parse_str, punctuated::Punctuated,
+    token::Comma, Data, DataStruct, DeriveInput, Field, Fields, Ident, Type,
+};
+
+// TODO: Make a version for assets ...
+
+pub fn derive_animated_properties(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+
+    let fields = match &ast.data {
+        Data::Struct(DataStruct {
+            fields: Fields::Named(fields),
+            ..
+        }) => &fields.named,
+        _ => panic!("Expected a struct with named fields."),
+    };
+
+    let mut expanded: Vec<Vec<Field>> = vec![];
+    expanded.resize_with(fields.len(), || vec![]);
+
+    // Filter fields
+    let fields = fields
+        .iter()
+        .enumerate()
+        .filter(|(field_index, field)| {
+            field
+                .attrs
+                .iter()
+                .find(|a| *a.path.get_ident().as_ref().unwrap() == "animated")
+                .map_or_else(
+                    || true,
+                    |a| {
+                        syn::custom_keyword!(ignore);
+                        syn::custom_keyword!(expand);
+                        a.parse_args_with(|input: ParseStream| {
+                            if input.parse::<Option<ignore>>()?.is_some() {
+                                Ok(false)
+                            } else if input.parse::<Option<expand>>()?.is_some() {
+                                let content;
+                                //syn::parenthesized!(content in input);
+                                syn::braced!(content in input);
+                                let fields: Punctuated<Field, Comma> =
+                                    content.parse_terminated(Field::parse_named)?;
+                                expanded[*field_index].extend(fields.iter().cloned());
+                                Ok(true)
+                            } else {
+                                Ok(true)
+                            }
+                        })
+                        .expect("Invalid 'animated' attribute format.")
+                    },
+                )
+        })
+        .map(|(_, field)| field)
+        .collect::<Vec<&Field>>();
+
+    let modules = get_modules(&ast.attrs);
+    let bevy_animation = get_path(&modules.bevy_animation);
+
+    let struct_name = &ast.ident;
+    let root_ident = Ident::new(&format!("{}Properties", struct_name), Span::call_site());
+
+    let mut field_ident = vec![];
+    let mut field_inner: Vec<Type> = vec![];
+    let mut field_type = vec![];
+    let mut field_path = vec![];
+    let mut field_inner_impls = vec![];
+
+    fields
+        .iter()
+        .zip(expanded.iter())
+        .for_each(|(field, extended_fields)| {
+            let ident = field.ident.as_ref().unwrap();
+            let ty = &field.ty;
+            field_ident.push(ident);
+            field_type.push(ty);
+            field_path.push(format!("{}.{}", struct_name, ident));
+
+            if extended_fields.len() == 0 {
+                field_inner_impls.push(quote! {});
+                field_inner.push(parse_quote!(()));
+            } else {
+                // TODO case style conversion
+                let type_inner: Type = parse_str(&format!(
+                    "{}{}Properties",
+                    struct_name,
+                    snake_to_pascal_case(&ident.to_string())
+                ))
+                .unwrap();
+
+                let mut field_ident = vec![];
+                let mut field_type = vec![];
+                let mut field_path = vec![];
+                extended_fields.iter().for_each(|field| {
+                    let inner = field.ident.as_ref().unwrap();
+                    field_ident.push(inner);
+                    field_type.push(&field.ty);
+                    field_path.push(format!("{}.{}.{}", struct_name, ident, inner));
+                });
+
+                field_inner_impls.push(quote! {
+                    pub struct #type_inner;
+                    impl #type_inner {
+                        #(
+                            pub fn #field_ident(&self) -> #bevy_animation::Prop<#field_type> {
+                                #bevy_animation::Prop::borrowed(#field_path)
+                            }
+                        )*
+                    }
+                    impl std::ops::Deref for #bevy_animation::Prop<#ty, #type_inner> {
+                        type Target = #type_inner;
+
+                        #[inline(always)]
+                        fn deref(&self) -> &Self::Target {
+                            &#type_inner
+                        }
+                    }
+                });
+                field_inner.push(type_inner);
+            }
+        });
+
+    let generics = ast.generics;
+    let (impl_generics, ty_generics, _where_clause) = generics.split_for_impl();
+
+    TokenStream::from(quote! {
+        #(#field_inner_impls)*
+
+        pub struct #root_ident;
+
+        impl #root_ident {
+            #(
+                pub fn #field_ident(&self) -> #bevy_animation::Prop<#field_type, #field_inner> {
+                    #bevy_animation::Prop::borrowed(#field_path)
+                }
+            )*
+        }
+
+        impl #impl_generics #bevy_animation::AnimatedProperties for #struct_name #ty_generics {
+            type Props = #root_ident;
+
+            #[inline(always)]
+            fn props() -> Self::Props {
+                #root_ident
+            }
+        }
+    })
+}
diff --git a/crates/bevy_animation/bevy_animation_derive/src/help.rs b/crates/bevy_animation/bevy_animation_derive/src/help.rs
new file mode 100644
index 0000000000000..b39f70452219d
--- /dev/null
+++ b/crates/bevy_animation/bevy_animation_derive/src/help.rs
@@ -0,0 +1,15 @@
+pub fn snake_to_pascal_case(name: &str) -> String {
+    let mut n = String::new();
+
+    name.split('_').for_each(|s| {
+        s.chars().enumerate().for_each(|(i, c)| {
+            if i == 0 {
+                n.extend(c.to_uppercase());
+            } else {
+                n.push(c);
+            }
+        });
+    });
+
+    n
+}
diff --git a/crates/bevy_animation/bevy_animation_derive/src/lib.rs b/crates/bevy_animation/bevy_animation_derive/src/lib.rs
index 568fa9b66d7c9..afe5d6270a1cc 100644
--- a/crates/bevy_animation/bevy_animation_derive/src/lib.rs
+++ b/crates/bevy_animation/bevy_animation_derive/src/lib.rs
@@ -2,6 +2,8 @@ extern crate proc_macro;
 
 mod animated_asset;
 mod animated_component;
+mod animated_properties;
+mod help;
 mod modules;
 
 use proc_macro::TokenStream;
@@ -32,4 +34,21 @@ pub fn animated_asset(input: TokenStream) -> TokenStream {
     animated_asset::derive_animated_asset(input)
 }
 
+///////////////////////////////////////////////////////////////////////////////
+
+#[proc_macro_derive(AnimatedProperties, attributes(animated))]
+pub fn derive_animated_properties(input: TokenStream) -> TokenStream {
+    animated_properties::derive_animated_properties(input)
+}
+
+/// Used to implement the `AnimatedAsset` for an struct defined externally;
+/// Only useful inside the bevy_animation crate.
+#[doc(hidden)]
+#[proc_macro]
+pub fn animated_properties(input: TokenStream) -> TokenStream {
+    animated_properties::derive_animated_properties(input)
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 // TODO: LerpValue and Blend

From 5d9aa59a2dd7be38d72bad28f420b3ef83630894 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Thu, 24 Dec 2020 23:31:11 -0300
Subject: [PATCH 062/153] fix gltf loader

---
 crates/bevy_gltf/src/loader.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index d69da0b468ad2..4b7125b03fa48 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -331,13 +331,13 @@ async fn load_gltf<'a, 'b>(
         for (property_path, mut curve) in clip_curves_rotation {
             Curve::<Quat>::add_offset_time(&mut curve, -start_time);
             //curve.add_time_offset(-start_time);
-            clip.add_animated_prop(&property_path, curve);
+            clip.add_curve_at_path(&property_path, curve);
         }
 
         for (property_path, mut curve) in clip_curves_translation_and_scale {
             Curve::<Vec3>::add_offset_time(&mut curve, -start_time);
             //curve.add_time_offset(-start_time);
-            clip.add_animated_prop(&property_path, curve);
+            clip.add_curve_at_path(&property_path, curve);
         }
 
         load_context.set_labeled_asset(&anim_label, LoadedAsset::new(clip));

From 3ddf17ee28cee71b819b024efeb187d92998fcc4 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Fri, 25 Dec 2020 00:33:59 -0300
Subject: [PATCH 063/153] type safe properties and derive trait

---
 .../src/animated_asset.rs                     |  10 +-
 .../src/animated_component.rs                 |   9 +-
 .../src/animated_properties.rs                | 165 +++++++++++++++++-
 .../bevy_animation_derive/src/lib.rs          |  15 --
 4 files changed, 177 insertions(+), 22 deletions(-)

diff --git a/crates/bevy_animation/bevy_animation_derive/src/animated_asset.rs b/crates/bevy_animation/bevy_animation_derive/src/animated_asset.rs
index 02f9f90f9e253..d40db24724a84 100644
--- a/crates/bevy_animation/bevy_animation_derive/src/animated_asset.rs
+++ b/crates/bevy_animation/bevy_animation_derive/src/animated_asset.rs
@@ -1,11 +1,17 @@
-use crate::modules::{get_modules, get_path};
+use crate::{
+    animated_properties::derive_animated_properties_for_asset,
+    modules::{get_modules, get_path},
+};
 use proc_macro::TokenStream;
+use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
 use syn::{parse::ParseStream, parse_macro_input, Data, DataStruct, DeriveInput, Field, Fields};
 
 // TODO: Add extended fields like in animated_component
 
 pub fn derive_animated_asset(input: TokenStream) -> TokenStream {
+    let animated_properties: TokenStream2 =
+        derive_animated_properties_for_asset(input.clone()).into();
     let ast = parse_macro_input!(input as DeriveInput);
 
     let fields = match &ast.data {
@@ -58,6 +64,8 @@ pub fn derive_animated_asset(input: TokenStream) -> TokenStream {
     let (impl_generics, ty_generics, _where_clause) = generics.split_for_impl();
 
     TokenStream::from(quote! {
+        #animated_properties
+
         impl #impl_generics #bevy_animation::AnimatedAsset for #struct_name #ty_generics {
             fn animator_update_system(
                 clips: #bevy_ecs::Res<#bevy_asset::Assets<#bevy_animation::Clip>>,
diff --git a/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs b/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
index 858ed240b0d5b..615dc1fa67d7e 100644
--- a/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
+++ b/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
@@ -1,4 +1,7 @@
-use crate::modules::{get_modules, get_path};
+use crate::{
+    animated_properties::derive_animated_properties_for_component,
+    modules::{get_modules, get_path},
+};
 use proc_macro::TokenStream;
 use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
@@ -60,6 +63,8 @@ fn animate_property_extended(
 }
 
 pub fn derive_animated_component(input: TokenStream) -> TokenStream {
+    let animated_properties: TokenStream2 =
+        derive_animated_properties_for_component(input.clone()).into();
     let ast = parse_macro_input!(input as DeriveInput);
 
     let fields = match &ast.data {
@@ -158,6 +163,8 @@ pub fn derive_animated_component(input: TokenStream) -> TokenStream {
     let (impl_generics, ty_generics, _where_clause) = generics.split_for_impl();
 
     TokenStream::from(quote! {
+        #animated_properties
+
         impl #impl_generics #bevy_animation::AnimatedComponent for #struct_name #ty_generics {
             fn animator_update_system(
                 clips: #bevy_ecs::Res<#bevy_asset::Assets<#bevy_animation::Clip>>,
diff --git a/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs b/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs
index 8193b1048788e..77feb54dfd41f 100644
--- a/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs
+++ b/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs
@@ -10,9 +10,7 @@ use syn::{
     token::Comma, Data, DataStruct, DeriveInput, Field, Fields, Ident, Type,
 };
 
-// TODO: Make a version for assets ...
-
-pub fn derive_animated_properties(input: TokenStream) -> TokenStream {
+pub fn derive_animated_properties_for_component(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
 
     let fields = match &ast.data {
@@ -110,7 +108,7 @@ pub fn derive_animated_properties(input: TokenStream) -> TokenStream {
                     pub struct #type_inner;
                     impl #type_inner {
                         #(
-                            pub fn #field_ident(&self) -> #bevy_animation::Prop<#field_type> {
+                            pub const fn #field_ident(&self) -> #bevy_animation::Prop<#field_type> {
                                 #bevy_animation::Prop::borrowed(#field_path)
                             }
                         )*
@@ -138,12 +136,169 @@ pub fn derive_animated_properties(input: TokenStream) -> TokenStream {
 
         impl #root_ident {
             #(
-                pub fn #field_ident(&self) -> #bevy_animation::Prop<#field_type, #field_inner> {
+                pub const fn #field_ident(&self) -> #bevy_animation::Prop<#field_type, #field_inner> {
+                    #bevy_animation::Prop::borrowed(#field_path)
+                }
+            )*
+        }
+
+        impl #impl_generics #bevy_animation::AnimatedProperties for #struct_name #ty_generics {
+            type Props = #root_ident;
+
+            #[inline(always)]
+            fn props() -> Self::Props {
+                #root_ident
+            }
+        }
+    })
+}
+
+pub fn derive_animated_properties_for_asset(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+
+    let fields = match &ast.data {
+        Data::Struct(DataStruct {
+            fields: Fields::Named(fields),
+            ..
+        }) => &fields.named,
+        _ => panic!("Expected a struct with named fields."),
+    };
+
+    let mut expanded: Vec<Vec<Field>> = vec![];
+    expanded.resize_with(fields.len(), || vec![]);
+
+    // Filter fields
+    let fields = fields
+        .iter()
+        .enumerate()
+        .filter(|(field_index, field)| {
+            field
+                .attrs
+                .iter()
+                .find(|a| *a.path.get_ident().as_ref().unwrap() == "animated")
+                .map_or_else(
+                    || true,
+                    |a| {
+                        syn::custom_keyword!(ignore);
+                        syn::custom_keyword!(expand);
+                        a.parse_args_with(|input: ParseStream| {
+                            if input.parse::<Option<ignore>>()?.is_some() {
+                                Ok(false)
+                            } else if input.parse::<Option<expand>>()?.is_some() {
+                                let content;
+                                //syn::parenthesized!(content in input);
+                                syn::braced!(content in input);
+                                let fields: Punctuated<Field, Comma> =
+                                    content.parse_terminated(Field::parse_named)?;
+                                expanded[*field_index].extend(fields.iter().cloned());
+                                Ok(true)
+                            } else {
+                                Ok(true)
+                            }
+                        })
+                        .expect("Invalid 'animated' attribute format.")
+                    },
+                )
+        })
+        .map(|(_, field)| field)
+        .collect::<Vec<&Field>>();
+
+    let modules = get_modules(&ast.attrs);
+    let bevy_animation = get_path(&modules.bevy_animation);
+
+    let struct_name = &ast.ident;
+    let root_ident = Ident::new(&format!("{}Properties", struct_name), Span::call_site());
+    let fields_struct = Ident::new(
+        &format!("{}FieldsProperties", struct_name),
+        Span::call_site(),
+    );
+    let handle_path = format!("Handle<{}>", struct_name);
+
+    let mut field_ident = vec![];
+    let mut field_inner: Vec<Type> = vec![];
+    let mut field_type = vec![];
+    let mut field_path = vec![];
+    let mut field_inner_impls = vec![];
+
+    fields
+        .iter()
+        .zip(expanded.iter())
+        .for_each(|(field, extended_fields)| {
+            let ident = field.ident.as_ref().unwrap();
+            let ty = &field.ty;
+            field_ident.push(ident);
+            field_type.push(ty);
+            field_path.push(format!("Handle<{}>.{}", struct_name, ident));
+
+            if extended_fields.len() == 0 {
+                field_inner_impls.push(quote! {});
+                field_inner.push(parse_quote!(()));
+            } else {
+                // TODO case style conversion
+                let type_inner: Type = parse_str(&format!(
+                    "{}{}Properties",
+                    struct_name,
+                    snake_to_pascal_case(&ident.to_string())
+                ))
+                .unwrap();
+
+                let mut field_ident = vec![];
+                let mut field_type = vec![];
+                let mut field_path = vec![];
+                extended_fields.iter().for_each(|field| {
+                    let inner = field.ident.as_ref().unwrap();
+                    field_ident.push(inner);
+                    field_type.push(&field.ty);
+                    field_path.push(format!("Handle<{}>.{}.{}", struct_name, ident, inner));
+                });
+
+                field_inner_impls.push(quote! {
+                    pub struct #type_inner;
+                    impl #type_inner {
+                        #(
+                            pub const fn #field_ident(&self) -> #bevy_animation::Prop<#field_type> {
+                                #bevy_animation::Prop::borrowed(#field_path)
+                            }
+                        )*
+                    }
+                    impl std::ops::Deref for #bevy_animation::Prop<#ty, #type_inner> {
+                        type Target = #type_inner;
+
+                        #[inline(always)]
+                        fn deref(&self) -> &Self::Target {
+                            &#type_inner
+                        }
+                    }
+                });
+                field_inner.push(type_inner);
+            }
+        });
+
+    let generics = ast.generics;
+    let (impl_generics, ty_generics, _where_clause) = generics.split_for_impl();
+
+    TokenStream::from(quote! {
+        #(#field_inner_impls)*
+
+        pub struct #fields_struct;
+        impl #fields_struct {
+            #(
+                pub const fn #field_ident(&self) -> #bevy_animation::Prop<#field_type, #field_inner> {
                     #bevy_animation::Prop::borrowed(#field_path)
                 }
             )*
         }
 
+        pub struct #root_ident;
+        impl #root_ident {
+            pub const fn handle(&self) -> #bevy_animation::Prop<Handle<#struct_name>> {
+                #bevy_animation::Prop::borrowed(#handle_path)
+            }
+            pub const fn fields(&self) -> #fields_struct {
+                #fields_struct
+            }
+        }
+
         impl #impl_generics #bevy_animation::AnimatedProperties for #struct_name #ty_generics {
             type Props = #root_ident;
 
diff --git a/crates/bevy_animation/bevy_animation_derive/src/lib.rs b/crates/bevy_animation/bevy_animation_derive/src/lib.rs
index afe5d6270a1cc..7c4c9d509ad52 100644
--- a/crates/bevy_animation/bevy_animation_derive/src/lib.rs
+++ b/crates/bevy_animation/bevy_animation_derive/src/lib.rs
@@ -36,19 +36,4 @@ pub fn animated_asset(input: TokenStream) -> TokenStream {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[proc_macro_derive(AnimatedProperties, attributes(animated))]
-pub fn derive_animated_properties(input: TokenStream) -> TokenStream {
-    animated_properties::derive_animated_properties(input)
-}
-
-/// Used to implement the `AnimatedAsset` for an struct defined externally;
-/// Only useful inside the bevy_animation crate.
-#[doc(hidden)]
-#[proc_macro]
-pub fn animated_properties(input: TokenStream) -> TokenStream {
-    animated_properties::derive_animated_properties(input)
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
 // TODO: LerpValue and Blend

From 2310e5f94a38d9cf07b5a4c9870c8c3a15cd8617 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Fri, 25 Dec 2020 04:11:00 -0300
Subject: [PATCH 064/153] basic checks for unregistered clip properties

---
 .../src/animated_properties.rs                | 41 ++++++++++++-------
 crates/bevy_animation/src/app.rs              | 39 ++++++++++++++----
 crates/bevy_animation/src/custom.rs           | 40 +++++++++++++++---
 3 files changed, 94 insertions(+), 26 deletions(-)

diff --git a/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs b/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs
index 77feb54dfd41f..3aa3324dce2cc 100644
--- a/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs
+++ b/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs
@@ -65,11 +65,12 @@ pub fn derive_animated_properties_for_component(input: TokenStream) -> TokenStre
 
     let struct_name = &ast.ident;
     let root_ident = Ident::new(&format!("{}Properties", struct_name), Span::call_site());
+    let mut available_properties = vec![];
 
     let mut field_ident = vec![];
     let mut field_inner: Vec<Type> = vec![];
     let mut field_type = vec![];
-    let mut field_path = vec![];
+    let mut field_property_index = vec![];
     let mut field_inner_impls = vec![];
 
     fields
@@ -80,7 +81,9 @@ pub fn derive_animated_properties_for_component(input: TokenStream) -> TokenStre
             let ty = &field.ty;
             field_ident.push(ident);
             field_type.push(ty);
-            field_path.push(format!("{}.{}", struct_name, ident));
+
+            field_property_index.push(available_properties.len());
+            available_properties.push(format!("{}.{}", struct_name, ident));
 
             if extended_fields.len() == 0 {
                 field_inner_impls.push(quote! {});
@@ -96,12 +99,13 @@ pub fn derive_animated_properties_for_component(input: TokenStream) -> TokenStre
 
                 let mut field_ident = vec![];
                 let mut field_type = vec![];
-                let mut field_path = vec![];
+                let mut field_property_index = vec![];
                 extended_fields.iter().for_each(|field| {
                     let inner = field.ident.as_ref().unwrap();
                     field_ident.push(inner);
                     field_type.push(&field.ty);
-                    field_path.push(format!("{}.{}.{}", struct_name, ident, inner));
+                    field_property_index.push(available_properties.len());
+                    available_properties.push(format!("{}.{}.{}", struct_name, ident, inner));
                 });
 
                 field_inner_impls.push(quote! {
@@ -109,7 +113,7 @@ pub fn derive_animated_properties_for_component(input: TokenStream) -> TokenStre
                     impl #type_inner {
                         #(
                             pub const fn #field_ident(&self) -> #bevy_animation::Prop<#field_type> {
-                                #bevy_animation::Prop::borrowed(#field_path)
+                                #bevy_animation::Prop::borrowed( #struct_name::PROPERTIES[#field_property_index] )
                             }
                         )*
                     }
@@ -137,7 +141,7 @@ pub fn derive_animated_properties_for_component(input: TokenStream) -> TokenStre
         impl #root_ident {
             #(
                 pub const fn #field_ident(&self) -> #bevy_animation::Prop<#field_type, #field_inner> {
-                    #bevy_animation::Prop::borrowed(#field_path)
+                    #bevy_animation::Prop::borrowed( #struct_name::PROPERTIES[#field_property_index] )
                 }
             )*
         }
@@ -145,6 +149,8 @@ pub fn derive_animated_properties_for_component(input: TokenStream) -> TokenStre
         impl #impl_generics #bevy_animation::AnimatedProperties for #struct_name #ty_generics {
             type Props = #root_ident;
 
+            const PROPERTIES: &'static [&'static str] = &[ #( #available_properties, )* ];
+
             #[inline(always)]
             fn props() -> Self::Props {
                 #root_ident
@@ -212,12 +218,14 @@ pub fn derive_animated_properties_for_asset(input: TokenStream) -> TokenStream {
         &format!("{}FieldsProperties", struct_name),
         Span::call_site(),
     );
-    let handle_path = format!("Handle<{}>", struct_name);
+
+    let mut available_properties = vec![];
+    available_properties.push(format!("Handle<{}>", struct_name));
 
     let mut field_ident = vec![];
     let mut field_inner: Vec<Type> = vec![];
     let mut field_type = vec![];
-    let mut field_path = vec![];
+    let mut field_property_index = vec![];
     let mut field_inner_impls = vec![];
 
     fields
@@ -228,7 +236,8 @@ pub fn derive_animated_properties_for_asset(input: TokenStream) -> TokenStream {
             let ty = &field.ty;
             field_ident.push(ident);
             field_type.push(ty);
-            field_path.push(format!("Handle<{}>.{}", struct_name, ident));
+            field_property_index.push(available_properties.len());
+            available_properties.push(format!("Handle<{}>.{}", struct_name, ident));
 
             if extended_fields.len() == 0 {
                 field_inner_impls.push(quote! {});
@@ -244,12 +253,14 @@ pub fn derive_animated_properties_for_asset(input: TokenStream) -> TokenStream {
 
                 let mut field_ident = vec![];
                 let mut field_type = vec![];
-                let mut field_path = vec![];
+                let mut field_property_index = vec![];
                 extended_fields.iter().for_each(|field| {
                     let inner = field.ident.as_ref().unwrap();
                     field_ident.push(inner);
                     field_type.push(&field.ty);
-                    field_path.push(format!("Handle<{}>.{}.{}", struct_name, ident, inner));
+                    field_property_index.push(available_properties.len());
+                    available_properties
+                        .push(format!("Handle<{}>.{}.{}", struct_name, ident, inner));
                 });
 
                 field_inner_impls.push(quote! {
@@ -257,7 +268,7 @@ pub fn derive_animated_properties_for_asset(input: TokenStream) -> TokenStream {
                     impl #type_inner {
                         #(
                             pub const fn #field_ident(&self) -> #bevy_animation::Prop<#field_type> {
-                                #bevy_animation::Prop::borrowed(#field_path)
+                                #bevy_animation::Prop::borrowed(#struct_name::PROPERTIES[#field_property_index])
                             }
                         )*
                     }
@@ -284,7 +295,7 @@ pub fn derive_animated_properties_for_asset(input: TokenStream) -> TokenStream {
         impl #fields_struct {
             #(
                 pub const fn #field_ident(&self) -> #bevy_animation::Prop<#field_type, #field_inner> {
-                    #bevy_animation::Prop::borrowed(#field_path)
+                    #bevy_animation::Prop::borrowed(#struct_name::PROPERTIES[#field_property_index])
                 }
             )*
         }
@@ -292,7 +303,7 @@ pub fn derive_animated_properties_for_asset(input: TokenStream) -> TokenStream {
         pub struct #root_ident;
         impl #root_ident {
             pub const fn handle(&self) -> #bevy_animation::Prop<Handle<#struct_name>> {
-                #bevy_animation::Prop::borrowed(#handle_path)
+                #bevy_animation::Prop::borrowed(#struct_name::PROPERTIES[0usize])
             }
             pub const fn fields(&self) -> #fields_struct {
                 #fields_struct
@@ -302,6 +313,8 @@ pub fn derive_animated_properties_for_asset(input: TokenStream) -> TokenStream {
         impl #impl_generics #bevy_animation::AnimatedProperties for #struct_name #ty_generics {
             type Props = #root_ident;
 
+            const PROPERTIES: &'static [&'static str] = &[ #( #available_properties, )* ];
+
             #[inline(always)]
             fn props() -> Self::Props {
                 #root_ident
diff --git a/crates/bevy_animation/src/app.rs b/crates/bevy_animation/src/app.rs
index a0886681cd9bf..ffa6529a62f2d 100644
--- a/crates/bevy_animation/src/app.rs
+++ b/crates/bevy_animation/src/app.rs
@@ -1,7 +1,10 @@
-use bevy_app::AppBuilder;
-
-use crate::custom::{AnimatedAsset, AnimatedComponent};
+use crate::custom::{AnimatedAsset, AnimatedComponent, AnimatorRegistry};
 use crate::stage;
+use bevy_app::AppBuilder;
+use std::{
+    any::{type_name, TypeId},
+    mem::drop,
+};
 
 pub trait AddAnimated {
     fn register_animated_component<T: AnimatedComponent>(&mut self) -> &mut Self;
@@ -10,13 +13,35 @@ pub trait AddAnimated {
 }
 
 impl AddAnimated for AppBuilder {
-    #[inline(always)]
     fn register_animated_component<T: AnimatedComponent>(&mut self) -> &mut Self {
-        self.add_system_to_stage(stage::ANIMATE, T::animator_update_system)
+        let mut registry = self
+            .resources_mut()
+            .get_or_insert_with(AnimatorRegistry::default);
+
+        if registry.targets.insert(TypeId::of::<T>()) {
+            registry.static_properties.extend(T::PROPERTIES.iter());
+            drop(registry);
+
+            self.add_system_to_stage(stage::ANIMATE, T::animator_update_system);
+            self
+        } else {
+            panic!("animator already registered for '{}'", type_name::<T>());
+        }
     }
 
-    #[inline(always)]
     fn register_animated_asset<T: AnimatedAsset>(&mut self) -> &mut Self {
-        self.add_system_to_stage(stage::ANIMATE, T::animator_update_system)
+        let mut registry = self
+            .resources_mut()
+            .get_or_insert_with(AnimatorRegistry::default);
+
+        if registry.targets.insert(TypeId::of::<T>()) {
+            registry.static_properties.extend(T::PROPERTIES.iter());
+            drop(registry);
+
+            self.add_system_to_stage(stage::ANIMATE, T::animator_update_system);
+            self
+        } else {
+            panic!("animator already registered for '{}'", type_name::<T>());
+        }
     }
 }
diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 62e92925da0c1..b6c5293856e7e 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -9,11 +9,12 @@ use fnv::FnvBuildHasher;
 use smallvec::{smallvec, SmallVec};
 use std::{
     any::Any,
+    any::TypeId,
     borrow::Cow,
     collections::{HashMap, HashSet},
     marker::PhantomData,
-    // ops::Deref,
 };
+use tracing::warn;
 
 use crate::blending::AnimatorBlending;
 use crate::curve::Curve;
@@ -198,7 +199,6 @@ impl<CurveType, InnerProps> Prop<CurveType, InnerProps> {
 // }
 
 impl Clip {
-    // TODO: Warn about properties that aren't been used so the user can check if they are wrong or not
     /// Animates an entity property with a curve.
     /// Adding the a second curve to the same entity and property will replace the first one;
     /// This is the preferred method of adding curves into a clip, since it's better future proof than `add_curve_at_path`;
@@ -595,6 +595,15 @@ impl<'a> Iterator for LayerIterator<'a> {
 
 ///////////////////////////////////////////////////////////////////////////////
 
+#[derive(Default)]
+pub(crate) struct AnimatorRegistry {
+    /// Set of registered animators for components and assets
+    pub(crate) targets: HashSet<TypeId, FnvBuildHasher>,
+    // TODO: Also include TypeId when it becomes stable in as as const fn
+    /// All static properties available
+    pub(crate) static_properties: HashSet<&'static str, FnvBuildHasher>,
+}
+
 /// State info for the system `animator_binding_system`
 #[derive(Default)]
 pub(crate) struct BindingState {
@@ -606,6 +615,7 @@ pub(crate) fn animator_update_system(
     commands: &mut Commands,
     mut state: Local<BindingState>,
     clip_events: Res<Events<AssetEvent<Clip>>>,
+    animator_registry: Res<AnimatorRegistry>,
     time: Res<Time>,
     clips: Res<Assets<Clip>>,
     mut animators_query: Query<(Entity, &mut Animator, Option<&AnimatorBlending>)>,
@@ -746,6 +756,19 @@ pub(crate) fn animator_update_system(
             if let Some(clip) = clips.get(clip_handle) {
                 let bind_slot = &mut animator.bind_clips[clip_index];
                 if bind_slot.is_none() {
+                    // TODO: Add option to ignore these extra checks (or not)
+                    // Check if the clips properties are registered
+                    for (property_name, _) in clip.properties.iter() {
+                        if !animator_registry
+                            .static_properties
+                            .contains(property_name.as_str())
+                        {
+                            // TODO: Check dynamic properties names using regex
+                            // TODO: Include clip name on warning
+                            warn!("property '{}' isn't registered", property_name);
+                        }
+                    }
+
                     // Merge newly added clip hierarchy into the animator global hierarchy
                     let mut bind = Bind::default();
                     animator
@@ -822,11 +845,18 @@ pub(crate) fn animator_update_system(
 pub trait AnimatedProperties {
     type Props;
 
-    /// Type safe animated properties of this component or asset
+    // TODO: Also include TypeId when it becomes stable in as as const fn
+    /// List of all animated properties, is used to search invalid properties in clips
+    const PROPERTIES: &'static [&'static str];
+    /// Similar to `PROPERTIES` but contains a regex to validate dynamic properties
+    const DYNAMIC_PROPERTIES: &'static [&'static str] = &[];
+
+    /// Type safe animated properties of this component or asset;
+    /// Meant to be used only by code, to be type safe and future proof way of defining properties.
     fn props() -> Self::Props;
 }
 
-pub trait AnimatedComponent: Component + Sized {
+pub trait AnimatedComponent: AnimatedProperties + Component + Sized {
     fn animator_update_system(
         clips: Res<Assets<Clip>>,
         animator_blending: Local<AnimatorBlending>,
@@ -835,7 +865,7 @@ pub trait AnimatedComponent: Component + Sized {
     );
 }
 
-pub trait AnimatedAsset: Asset + Sized {
+pub trait AnimatedAsset: AnimatedProperties + Asset + Sized {
     fn animator_update_system(
         clips: Res<Assets<Clip>>,
         animator_blending: Local<AnimatorBlending>,

From dbad8c9f27a597c56fb82d0936e84d9880c3aedb Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sat, 26 Dec 2020 13:57:00 -0300
Subject: [PATCH 065/153] faster lerping blend

---
 crates/bevy_animation/src/blending.rs | 125 +++++--
 crates/bevy_animation/src/impls.rs    | 466 +++++++++++++++-----------
 crates/bevy_animation/src/lib.rs      |   2 +
 3 files changed, 365 insertions(+), 228 deletions(-)

diff --git a/crates/bevy_animation/src/blending.rs b/crates/bevy_animation/src/blending.rs
index 8a0cf6e3fee9b..713d1956e460e 100644
--- a/crates/bevy_animation/src/blending.rs
+++ b/crates/bevy_animation/src/blending.rs
@@ -1,10 +1,23 @@
+use crate::lerping::Lerp;
 use bevy_asset::{Asset, Handle, HandleUntyped};
 use bevy_math::prelude::*;
 use bevy_render::color::Color;
 use fnv::FnvBuildHasher;
-use std::collections::{HashMap, HashSet};
-
-use crate::lerping::Lerp;
+use std::collections::HashMap;
+
+// pub struct Bit<'a>(&'a mut u32, u32);
+
+// impl<'a> Bit<'a> {
+//     #[inline(always)]
+//     pub fn set(&mut self) -> bool {
+//         if (*self.0 & self.1) != 0 {
+//             *self.0 |= self.1;
+//             true
+//         } else {
+//             false
+//         }
+//     }
+// }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 struct Ptr(*const u8);
@@ -16,17 +29,18 @@ unsafe impl Sync for Ptr {}
 
 #[derive(Default, Debug)]
 pub struct AnimatorBlending {
-    // ? NOTE: FnvHasher performed better over the PtrHasher (ptr value as hash) and AHash
-    blend: HashSet<Ptr, FnvBuildHasher>,
+    bits: Vec<u32>,
+    // ? NOTE: HashMap is used here to reduce memory waste, it's slower but other wise a lot of memory won't be used
     /// Used for contest blend type
-    blend_memory: HashMap<Ptr, f32, FnvBuildHasher>,
+    weights: HashMap<Ptr, f32, FnvBuildHasher>,
 }
 
 impl AnimatorBlending {
     #[inline(always)]
-    pub fn begin_blending(&mut self) -> AnimatorBlendGroup {
-        self.blend.clear();
-        self.blend_memory.clear();
+    pub fn begin_blending(&mut self, entities: usize) -> AnimatorBlendGroup {
+        self.bits.clear();
+        self.bits.resize(entities, 0);
+        self.weights.clear();
         AnimatorBlendGroup { blending: self }
     }
 }
@@ -37,20 +51,29 @@ pub struct AnimatorBlendGroup<'a> {
 
 impl<'a> AnimatorBlendGroup<'a> {
     /// Blend using lerping
-    pub fn blend_lerp<T: Lerp>(&mut self, attribute: &mut T, value: T, weight: f32) {
-        let ptr = Ptr(attribute as *const _ as *const u8);
-        if self.blending.blend.contains(&ptr) {
+    #[inline(always)]
+    pub fn blend_lerp<T: Lerp>(
+        &mut self,
+        entity_index: usize,
+        bit_mask: u32,
+        attribute: &mut T,
+        value: T,
+        weight: f32,
+    ) {
+        let b = &mut self.blending.bits[entity_index];
+        if *b & bit_mask != 0 {
             *attribute = Lerp::lerp(&*attribute, &value, weight);
         } else {
-            self.blending.blend.insert(ptr);
             *attribute = value;
         }
+        *b |= bit_mask;
     }
 
     /// Contest blending, only the value with the highest weight value will remain
+    #[inline(always)]
     pub fn blend_contest<T>(&mut self, attribute: &mut T, value: T, weight: f32) {
         let ptr = Ptr(attribute as *const _ as *const u8);
-        let w = self.blending.blend_memory.entry(ptr).or_insert(0.0);
+        let w = self.blending.weights.entry(ptr).or_insert(0.0);
         if weight > *w {
             *w = weight;
             *attribute = value;
@@ -69,23 +92,44 @@ impl<'a> AnimatorBlendGroup<'a> {
 ///
 /// impl Blend for MyType {
 ///     #[inline(always)]
-///     fn blend(&mut self, blend_group: &mut AnimatorBlendGroup, value: Self, weight: f32) {
+///     fn blend(
+///         &mut self,
+///         entity_index: usize,
+///         bit_mask: u32,
+///         blend_group: &mut AnimatorBlendGroup,
+///         value: Self,
+///         weight: f32,
+///     ){
 ///         blend_group.blend_contest(self, value, weight);
-///         // or
-///         // blend_group.blend_lerp(self, value, weight);
+///         // or (MyType needs to implement `Lerp`)
+///         // blend_group.blend_lerp(entity_index, bit_mask, self, value, weight);
 ///     }
 /// }
 /// ```
 pub trait Blend {
-    fn blend(&mut self, blend_group: &mut AnimatorBlendGroup, value: Self, weight: f32);
+    fn blend(
+        &mut self,
+        entity_index: usize,
+        bit_mask: u32,
+        blend_group: &mut AnimatorBlendGroup,
+        value: Self,
+        weight: f32,
+    );
 }
 
 macro_rules! lerp {
     ($t:ty) => {
         impl Blend for $t {
             #[inline(always)]
-            fn blend(&mut self, blend_group: &mut AnimatorBlendGroup, value: Self, weight: f32) {
-                blend_group.blend_lerp(self, value, weight);
+            fn blend(
+                &mut self,
+                entity_index: usize,
+                bit_mask: u32,
+                blend_group: &mut AnimatorBlendGroup,
+                value: Self,
+                weight: f32,
+            ) {
+                blend_group.blend_lerp(entity_index, bit_mask, self, value, weight);
             }
         }
     };
@@ -101,38 +145,63 @@ lerp!(Color);
 
 impl<T: Asset + 'static> Blend for Handle<T> {
     #[inline(always)]
-    fn blend(&mut self, blend_group: &mut AnimatorBlendGroup, value: Self, weight: f32) {
+    fn blend(
+        &mut self,
+        _: usize,
+        _: u32,
+        blend_group: &mut AnimatorBlendGroup,
+        value: Self,
+        weight: f32,
+    ) {
         blend_group.blend_contest(self, value, weight);
     }
 }
 
 impl Blend for HandleUntyped {
     #[inline(always)]
-    fn blend(&mut self, blend_group: &mut AnimatorBlendGroup, value: Self, weight: f32) {
+    fn blend(
+        &mut self,
+        _: usize,
+        _: u32,
+        blend_group: &mut AnimatorBlendGroup,
+        value: Self,
+        weight: f32,
+    ) {
         blend_group.blend_contest(self, value, weight);
     }
 }
 
 impl<T: Blend> Blend for Option<T> {
-    fn blend(&mut self, blend_group: &mut AnimatorBlendGroup, value: Self, weight: f32) {
+    fn blend(
+        &mut self,
+        entity_index: usize,
+        bit_mask: u32,
+        blend_group: &mut AnimatorBlendGroup,
+        value: Self,
+        weight: f32,
+    ) {
         let ptr = Ptr(self as *const _ as *const u8);
 
         match (self.is_some(), value.is_some()) {
             (true, true) => {
                 // Blend by lerp but also add the entry for the conext blending
-                self.as_mut()
-                    .unwrap()
-                    .blend(blend_group, value.unwrap(), weight);
+                self.as_mut().unwrap().blend(
+                    entity_index,
+                    bit_mask,
+                    blend_group,
+                    value.unwrap(),
+                    weight,
+                );
 
                 // Make sure to also add an entry for contest blent to work
-                let w = blend_group.blending.blend_memory.entry(ptr).or_insert(0.0);
+                let w = blend_group.blending.weights.entry(ptr).or_insert(0.0);
                 if weight > *w {
                     *w = weight;
                 }
             }
             (false, true) | (true, false) | (false, false) => {
                 // Blend by context but also add an entry for the next blend_lerp if needed
-                blend_group.blending.blend.insert(ptr);
+                blend_group.blending.bits[entity_index] |= bit_mask;
                 blend_group.blend_contest(self, value, weight);
             }
         }
diff --git a/crates/bevy_animation/src/impls.rs b/crates/bevy_animation/src/impls.rs
index 5f32b2bb7f9ec..2d93cad4becd4 100644
--- a/crates/bevy_animation/src/impls.rs
+++ b/crates/bevy_animation/src/impls.rs
@@ -1,7 +1,8 @@
-use crate as bevy_animation;
+use crate::{self as bevy_animation};
 use crate::{
     blending::{AnimatorBlending, Blend},
     custom::*,
+    lerping::Lerp,
 };
 use bevy_animation_derive::*;
 use bevy_asset::{Assets, Handle};
@@ -59,6 +60,18 @@ impl TransformProps {
 impl AnimatedProperties for Transform {
     type Props = TransformProps;
 
+    const PROPERTIES: &'static [&'static str] = &[
+        "Transform.translation",
+        "Transform.translation.x",
+        "Transform.translation.y",
+        "Transform.translation.z",
+        "Transform.rotation",
+        "Transform.scale",
+        // "Transform.scale.x",
+        // "Transform.scale.y",
+        // "Transform.scale.z",
+    ];
+
     #[inline(always)]
     fn props() -> Self::Props {
         TransformProps
@@ -80,8 +93,6 @@ impl AnimatedComponent for Transform {
         let mut components = vec![];
 
         for animator in animators_query.iter() {
-            let mut blend_group = animator_blending.begin_blending();
-
             components.clear();
 
             // ? NOTE: Lazy get each component is worse than just fetching everything at once
@@ -99,6 +110,15 @@ impl AnimatedComponent for Transform {
                 }
             }
 
+            let mut blend_group = animator_blending.begin_blending(components.len());
+
+            // Bit fields
+            const TRANSLATE_X: u32 = 1;
+            const TRANSLATE_Y: u32 = 2;
+            const TRANSLATE_Z: u32 = 4;
+            const ROTATION: u32 = 8;
+            const SCALE: u32 = 16;
+
             for (_, layer, clip_handle, entities_map) in animator.animate() {
                 let w = layer.weight;
                 if w < 1.0e-8 {
@@ -120,15 +140,32 @@ impl AnimatedComponent for Transform {
                         .flatten()
                     {
                         for (entity_index, (curve_index, curve)) in curves.iter() {
-                            let entity_index = entities_map[entity_index as usize];
-                            if let Some(ref mut component) = components[entity_index as usize] {
+                            let entity_index = entities_map[entity_index as usize] as usize;
+                            if let Some(ref mut component) = components[entity_index] {
                                 let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
                                 keyframes[*curve_index] = k;
-                                //component.translation.blend(&mut blend_group, v, w);
                                 // ? NOTE: Blend must be done for each component in order for it to work
-                                component.translation.x.blend(&mut blend_group, v.x, w);
-                                component.translation.y.blend(&mut blend_group, v.y, w);
-                                component.translation.z.blend(&mut blend_group, v.z, w);
+                                component.translation.x.blend(
+                                    entity_index,
+                                    TRANSLATE_X,
+                                    &mut blend_group,
+                                    v.x,
+                                    w,
+                                );
+                                component.translation.y.blend(
+                                    entity_index,
+                                    TRANSLATE_Y,
+                                    &mut blend_group,
+                                    v.y,
+                                    w,
+                                );
+                                component.translation.z.blend(
+                                    entity_index,
+                                    TRANSLATE_Z,
+                                    &mut blend_group,
+                                    v.z,
+                                    w,
+                                );
                             }
                         }
                     } else {
@@ -138,12 +175,18 @@ impl AnimatedComponent for Transform {
                             .flatten()
                         {
                             for (entity_index, (curve_index, curve)) in curves.iter() {
-                                let entity_index = entities_map[entity_index as usize];
-                                if let Some(ref mut component) = components[entity_index as usize] {
+                                let entity_index = entities_map[entity_index as usize] as usize;
+                                if let Some(ref mut component) = components[entity_index] {
                                     let (k, v) =
                                         curve.sample_indexed(keyframes[*curve_index], time);
                                     keyframes[*curve_index] = k;
-                                    component.translation.x.blend(&mut blend_group, v, w);
+                                    component.translation.x.blend(
+                                        entity_index,
+                                        TRANSLATE_X,
+                                        &mut blend_group,
+                                        v,
+                                        w,
+                                    );
                                 }
                             }
                         }
@@ -154,12 +197,18 @@ impl AnimatedComponent for Transform {
                             .flatten()
                         {
                             for (entity_index, (curve_index, curve)) in curves.iter() {
-                                let entity_index = entities_map[entity_index as usize];
-                                if let Some(ref mut component) = components[entity_index as usize] {
+                                let entity_index = entities_map[entity_index as usize] as usize;
+                                if let Some(ref mut component) = components[entity_index] {
                                     let (k, v) =
                                         curve.sample_indexed(keyframes[*curve_index], time);
                                     keyframes[*curve_index] = k;
-                                    component.translation.y.blend(&mut blend_group, v, w);
+                                    component.translation.y.blend(
+                                        entity_index,
+                                        TRANSLATE_Y,
+                                        &mut blend_group,
+                                        v,
+                                        w,
+                                    );
                                 }
                             }
                         }
@@ -170,12 +219,18 @@ impl AnimatedComponent for Transform {
                             .flatten()
                         {
                             for (entity_index, (curve_index, curve)) in curves.iter() {
-                                let entity_index = entities_map[entity_index as usize];
-                                if let Some(ref mut component) = components[entity_index as usize] {
+                                let entity_index = entities_map[entity_index as usize] as usize;
+                                if let Some(ref mut component) = components[entity_index] {
                                     let (k, v) =
                                         curve.sample_indexed(keyframes[*curve_index], time);
                                     keyframes[*curve_index] = k;
-                                    component.translation.z.blend(&mut blend_group, v, w);
+                                    component.translation.z.blend(
+                                        entity_index,
+                                        TRANSLATE_Z,
+                                        &mut blend_group,
+                                        v,
+                                        w,
+                                    );
                                 }
                             }
                         }
@@ -187,11 +242,17 @@ impl AnimatedComponent for Transform {
                         .flatten()
                     {
                         for (entity_index, (curve_index, curve)) in curves.iter() {
-                            let entity_index = entities_map[entity_index as usize];
-                            if let Some(ref mut component) = components[entity_index as usize] {
+                            let entity_index = entities_map[entity_index as usize] as usize;
+                            if let Some(ref mut component) = components[entity_index] {
                                 let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
                                 keyframes[*curve_index] = k;
-                                component.rotation.blend(&mut blend_group, v, w);
+                                component.rotation.blend(
+                                    entity_index,
+                                    ROTATION,
+                                    &mut blend_group,
+                                    v,
+                                    w,
+                                );
                             }
                         }
                     }
@@ -204,11 +265,13 @@ impl AnimatedComponent for Transform {
                         .flatten()
                     {
                         for (entity_index, (curve_index, curve)) in curves.iter() {
-                            let entity_index = entities_map[entity_index as usize];
-                            if let Some(ref mut component) = components[entity_index as usize] {
+                            let entity_index = entities_map[entity_index as usize] as usize;
+                            if let Some(ref mut component) = components[entity_index] {
                                 let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
                                 keyframes[*curve_index] = k;
-                                component.scale.blend(&mut blend_group, v, w);
+                                component
+                                    .scale
+                                    .blend(entity_index, SCALE, &mut blend_group, v, w);
                             }
                         }
                     }
@@ -220,161 +283,163 @@ impl AnimatedComponent for Transform {
     }
 }
 
-///////////////////////////////////////////////////////////////////////////////
-
-pub struct StandardMaterialProps;
-
-impl StandardMaterialProps {
-    pub const fn albedo(&self) -> Prop<Color> {
-        Prop::borrowed("Handle<StandardMaterial>.albedo")
-    }
-
-    pub const fn albedo_texture(&self) -> Prop<Option<Handle<Texture>>> {
-        Prop::borrowed("Handle<StandardMaterial>.albedo_texture")
-    }
-}
-
-pub struct HandleStandardMaterialProps;
-
-impl HandleStandardMaterialProps {
-    pub const fn handle(&self) -> Prop<Handle<StandardMaterial>> {
-        Prop::borrowed("Handle<StandardMaterial>")
-    }
-
-    pub const fn fields(&self) -> StandardMaterialProps {
-        StandardMaterialProps
-    }
-}
-
-impl AnimatedProperties for StandardMaterial {
-    type Props = HandleStandardMaterialProps;
-
-    fn props() -> Self::Props {
-        HandleStandardMaterialProps
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-impl AnimatedAsset for StandardMaterial {
-    fn animator_update_system(
-        clips: Res<Assets<Clip>>,
-        mut animator_blending: Local<AnimatorBlending>,
-        animators_query: Query<&Animator>,
-        mut assets: ResMut<Assets<Self>>,
-        component_query: Query<&mut Handle<Self>>,
-    ) {
-        let __span = tracing::info_span!("animator_standard_material_update_system");
-        let __guard = __span.enter();
-
-        let mut components = vec![];
+// ///////////////////////////////////////////////////////////////////////////////
 
-        for animator in animators_query.iter() {
-            let mut blend_group = animator_blending.begin_blending();
+// pub struct StandardMaterialProps;
 
-            for (_, layer, clip_handle, entities_map) in animator.animate() {
-                let w = layer.weight;
-                if w < 1.0e-8 {
-                    continue;
-                }
-
-                components.clear();
-
-                // TODO: Test performance with lazy component fetch
-                // SAFETY: each component will be updated one at the time and this function
-                // currently has the mutability over the Transform type, so no race conditions
-                // are possible
-                unsafe {
-                    for entity in animator.entities() {
-                        components.push(
-                            entity
-                                .map(|entity| component_query.get_unsafe(entity).ok())
-                                .flatten(),
-                        );
-                    }
-                }
-
-                if let Some(clip) = clips.get(clip_handle) {
-                    let time = layer.time;
+// impl StandardMaterialProps {
+//     pub const fn albedo(&self) -> Prop<Color> {
+//         Prop::borrowed("Handle<StandardMaterial>.albedo")
+//     }
 
-                    // SAFETY: Never a different thread will modify or access the same index as this one;
-                    // Plus as a nice and crazy feature each property is grouped by name into their own cache line
-                    // buckets, this way no cache line will be accessed by the same thread unless the same property
-                    // is accessed by two different systems, which is possible but weird and will hit the performance a bit
-                    let keyframes = unsafe { layer.keyframes_unsafe() };
+//     pub const fn albedo_texture(&self) -> Prop<Option<Handle<Texture>>> {
+//         Prop::borrowed("Handle<StandardMaterial>.albedo_texture")
+//     }
+// }
 
-                    // Replace the material handle
-                    if let Some(curves) = clip
-                        .get("Handle<StandardMaterial>")
-                        .map(|curve_untyped| {
-                            curve_untyped.downcast_ref::<Handle<StandardMaterial>>()
-                        })
-                        .flatten()
-                    {
-                        for (entity_index, (curve_index, curve)) in curves.iter() {
-                            let entity_index = entities_map[entity_index as usize];
+// pub struct HandleStandardMaterialProps;
 
-                            if let Some(ref mut component) = components[entity_index as usize] {
-                                let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
-                                keyframes[*curve_index] = k;
-                                component.blend(&mut blend_group, v, w);
-                            }
-                        }
-                    }
+// impl HandleStandardMaterialProps {
+//     pub const fn handle(&self) -> Prop<Handle<StandardMaterial>> {
+//         Prop::borrowed("Handle<StandardMaterial>")
+//     }
 
-                    // Change asset properties
+//     pub const fn fields(&self) -> StandardMaterialProps {
+//         StandardMaterialProps
+//     }
+// }
 
-                    if let Some(curves) = clip
-                        .get("Handle<StandardMaterial>.albedo")
-                        .map(|curve_untyped| curve_untyped.downcast_ref::<Color>())
-                        .flatten()
-                    {
-                        for (entity_index, (curve_index, curve)) in curves.iter() {
-                            let entity_index = entities_map[entity_index as usize];
+// impl AnimatedProperties for StandardMaterial {
+//     type Props = HandleStandardMaterialProps;
 
-                            if let Some(ref component) = components[entity_index as usize] {
-                                if let Some(asset) = assets.get_mut(&**component) {
-                                    let (k, v) =
-                                        curve.sample_indexed(keyframes[*curve_index], time);
-                                    keyframes[*curve_index] = k;
-                                    asset.albedo.blend(&mut blend_group, v, w);
-                                }
-                            }
-                        }
-                    }
+//     const PROPERTIES: &'static [&'static str] = &[];
 
-                    if let Some(curves) = clip
-                        .get("Handle<StandardMaterial>.albedo_texture")
-                        .map(|curve_untyped| {
-                            curve_untyped.downcast_ref::<Option<Handle<Texture>>>()
-                        })
-                        .flatten()
-                    {
-                        for (entity_index, (curve_index, curve)) in curves.iter() {
-                            let entity_index = entities_map[entity_index as usize];
-                            if let Some(ref component) = components[entity_index as usize] {
-                                if let Some(asset) = assets.get_mut(&**component) {
-                                    let (k, v) =
-                                        curve.sample_indexed(keyframes[*curve_index], time);
-                                    keyframes[*curve_index] = k;
-                                    asset.albedo_texture.blend(&mut blend_group, v, w);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
+//     fn props() -> Self::Props {
+//         HandleStandardMaterialProps
+//     }
+// }
 
-        std::mem::drop(__guard);
-    }
-}
+// ///////////////////////////////////////////////////////////////////////////////
+
+// impl AnimatedAsset for StandardMaterial {
+//     fn animator_update_system(
+//         clips: Res<Assets<Clip>>,
+//         mut animator_blending: Local<AnimatorBlending>,
+//         animators_query: Query<&Animator>,
+//         mut assets: ResMut<Assets<Self>>,
+//         component_query: Query<&mut Handle<Self>>,
+//     ) {
+//         let __span = tracing::info_span!("animator_standard_material_update_system");
+//         let __guard = __span.enter();
+
+//         let mut components = vec![];
+
+//         for animator in animators_query.iter() {
+//             let mut blend_group = animator_blending.begin_blending();
+
+//             for (_, layer, clip_handle, entities_map) in animator.animate() {
+//                 let w = layer.weight;
+//                 if w < 1.0e-8 {
+//                     continue;
+//                 }
+
+//                 components.clear();
+
+//                 // TODO: Test performance with lazy component fetch
+//                 // SAFETY: each component will be updated one at the time and this function
+//                 // currently has the mutability over the Transform type, so no race conditions
+//                 // are possible
+//                 unsafe {
+//                     for entity in animator.entities() {
+//                         components.push(
+//                             entity
+//                                 .map(|entity| component_query.get_unsafe(entity).ok())
+//                                 .flatten(),
+//                         );
+//                     }
+//                 }
+
+//                 if let Some(clip) = clips.get(clip_handle) {
+//                     let time = layer.time;
+
+//                     // SAFETY: Never a different thread will modify or access the same index as this one;
+//                     // Plus as a nice and crazy feature each property is grouped by name into their own cache line
+//                     // buckets, this way no cache line will be accessed by the same thread unless the same property
+//                     // is accessed by two different systems, which is possible but weird and will hit the performance a bit
+//                     let keyframes = unsafe { layer.keyframes_unsafe() };
+
+//                     // Replace the material handle
+//                     if let Some(curves) = clip
+//                         .get("Handle<StandardMaterial>")
+//                         .map(|curve_untyped| {
+//                             curve_untyped.downcast_ref::<Handle<StandardMaterial>>()
+//                         })
+//                         .flatten()
+//                     {
+//                         for (entity_index, (curve_index, curve)) in curves.iter() {
+//                             let entity_index = entities_map[entity_index as usize];
+
+//                             if let Some(ref mut component) = components[entity_index as usize] {
+//                                 let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
+//                                 keyframes[*curve_index] = k;
+//                                 component.blend(&mut blend_group, v, w);
+//                             }
+//                         }
+//                     }
+
+//                     // Change asset properties
+
+//                     if let Some(curves) = clip
+//                         .get("Handle<StandardMaterial>.albedo")
+//                         .map(|curve_untyped| curve_untyped.downcast_ref::<Color>())
+//                         .flatten()
+//                     {
+//                         for (entity_index, (curve_index, curve)) in curves.iter() {
+//                             let entity_index = entities_map[entity_index as usize];
+
+//                             if let Some(ref component) = components[entity_index as usize] {
+//                                 if let Some(asset) = assets.get_mut(&**component) {
+//                                     let (k, v) =
+//                                         curve.sample_indexed(keyframes[*curve_index], time);
+//                                     keyframes[*curve_index] = k;
+//                                     asset.albedo.blend(&mut blend_group, v, w);
+//                                 }
+//                             }
+//                         }
+//                     }
+
+//                     if let Some(curves) = clip
+//                         .get("Handle<StandardMaterial>.albedo_texture")
+//                         .map(|curve_untyped| {
+//                             curve_untyped.downcast_ref::<Option<Handle<Texture>>>()
+//                         })
+//                         .flatten()
+//                     {
+//                         for (entity_index, (curve_index, curve)) in curves.iter() {
+//                             let entity_index = entities_map[entity_index as usize];
+//                             if let Some(ref component) = components[entity_index as usize] {
+//                                 if let Some(asset) = assets.get_mut(&**component) {
+//                                     let (k, v) =
+//                                         curve.sample_indexed(keyframes[*curve_index], time);
+//                                     keyframes[*curve_index] = k;
+//                                     asset.albedo_texture.blend(&mut blend_group, v, w);
+//                                 }
+//                             }
+//                         }
+//                     }
+//                 }
+//             }
+//         }
+
+//         std::mem::drop(__guard);
+//     }
+// }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // #[derive(Debug, AnimatedComponent)]
 // struct Test {
-//     #[animated(expand { x: f32, y: f32, z: f32 })]
+//     #[animated(fields { x: f32, y: f32, z: f32 })]
 //     a: Vec3,
 //     b: Vec2,
 //     #[animated(ignore)]
@@ -383,10 +448,10 @@ impl AnimatedAsset for StandardMaterial {
 
 // animated_component! {
 //     struct Transform {
-//         #[animated(expand { x: f32, y: f32, z: f32 })]
+//         #[animated(fields(x: f32, y: f32, z: f32))]
 //         translation: Vec3,
 //         rotation: Quat,
-//         #[animated(expand { x: f32, y: f32, z: f32 })]
+//         #[animated(fields(x: f32, y: f32, z: f32))]
 //         scale: Vec3,
 //     }
 // }
@@ -402,41 +467,42 @@ impl AnimatedAsset for StandardMaterial {
 //     struct Sprite {}
 // }
 
-animated_asset! {
-    struct Mesh {}
-}
+// animated_asset! {
+//     struct Mesh {}
+// }
 
-animated_component! {
-    struct Visible {
-        is_visible: bool,
-    }
-}
+// animated_component! {
+//     struct Visible {
+//         is_visible: bool,
+//     }
+// }
 
-animated_component! {
-    struct Light {
-        color: Color,
-        fov: f32,
-        //depth: Range<f32>,
-    }
-}
+// animated_component! {
+//     struct Light {
+//         color: Color,
+//         fov: f32,
+//         #[animated(ignore, fields(start: f32, end: f32))]
+//         depth: Range<f32>,
+//     }
+// }
 
-animated_component! {
-    struct PerspectiveProjection {
-        fov: f32,
-        aspect_ratio: f32,
-        near: f32,
-        far: f32,
-    }
-}
+// animated_component! {
+//     struct PerspectiveProjection {
+//         fov: f32,
+//         aspect_ratio: f32,
+//         near: f32,
+//         far: f32,
+//     }
+// }
 
-animated_component! {
-    struct OrthographicProjection {
-        left: f32,
-        right: f32,
-        bottom: f32,
-        top: f32,
-        near: f32,
-        far: f32,
-        //window_origin: WindowOrigin,
-    }
-}
+// animated_component! {
+//     struct OrthographicProjection {
+//         left: f32,
+//         right: f32,
+//         bottom: f32,
+//         top: f32,
+//         near: f32,
+//         far: f32,
+//         //window_origin: WindowOrigin,
+//     }
+// }
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 71be72aa5d75b..fdcd4677ec4fd 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -52,6 +52,8 @@ impl Plugin for AnimationPlugin {
             .add_system_to_stage(stage::ANIMATE, Assets::<Clip>::asset_event_system) // ? NOTE: Fix asset event handle
             .add_system_to_stage(stage::ANIMATE, animator_update_system);
 
+        // ! FIXME: Each added animated component or asset will add a bit of overhead in the animation
+        // ! system, I have no idea how big this is but I would like to make it pay only for what you use
         app.register_animated_component::<bevy_transform::prelude::Transform>();
 
         // Skinning

From 5ee3daac3bcabde4e41b13f64c186960085ba254 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sat, 26 Dec 2020 22:48:33 -0300
Subject: [PATCH 066/153] note on dynamic props

---
 crates/bevy_animation/src/custom.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index b6c5293856e7e..5cf8bdf5161d2 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -849,6 +849,8 @@ pub trait AnimatedProperties {
     /// List of all animated properties, is used to search invalid properties in clips
     const PROPERTIES: &'static [&'static str];
     /// Similar to `PROPERTIES` but contains a regex to validate dynamic properties
+    ///
+    /// **NOTE** Use sparelly, as it's more expensive to validate
     const DYNAMIC_PROPERTIES: &'static [&'static str] = &[];
 
     /// Type safe animated properties of this component or asset;

From 7dc1eb22a3eb972c06060669cb51fef21b34c349 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sat, 26 Dec 2020 22:50:07 -0300
Subject: [PATCH 067/153] wip derives

---
 .../src/animated_component.rs                 | 318 +++++++----
 .../src/animated_properties.rs                | 116 +++-
 .../bevy_animation_derive/src/help.rs         |  59 ++
 crates/bevy_animation/src/impls.rs            | 527 +++++++++---------
 4 files changed, 639 insertions(+), 381 deletions(-)

diff --git a/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs b/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
index 615dc1fa67d7e..7136eb223676a 100644
--- a/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
+++ b/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
@@ -1,61 +1,109 @@
 use crate::{
-    animated_properties::derive_animated_properties_for_component,
+    animated_properties::{query_prop, query_prop_nested},
+    help::parse_animate_options,
     modules::{get_modules, get_path},
 };
 use proc_macro::TokenStream;
-use proc_macro2::TokenStream as TokenStream2;
+use proc_macro2::{Span, TokenStream as TokenStream2};
 use quote::quote;
+use std::collections::{HashMap, HashSet};
 use syn::{
-    parse::ParseStream, parse_macro_input, parse_quote, punctuated::Punctuated, token::Comma, Data,
-    DataStruct, DeriveInput, Field, Fields, Ident, Type,
+    parse::{Error as ParseError, Parse, ParseStream, Result as ParserResult},
+    parse_macro_input, parse_quote,
+    punctuated::Punctuated,
+    token::Comma,
+    Data, DataStruct, DeriveInput, Field, Fields, Ident, Type,
 };
 
 fn animate_property(
-    property: &str,
-    field_ident: &Ident,
-    field_inner: &[&Ident],
-    field_type: &Type,
+    property_bit_masks: &mut HashSet<Ident>,
+    property_map: &mut HashMap<String, usize>,
+    property_name: String,
+    ident: &Ident,
+    nested_fields: Option<&Ident>,
+    ty: &Type,
 ) -> TokenStream2 {
+    let mut c = ident.to_string();
+    for n in nested_fields {
+        c.push('_');
+        c.push_str(&n.to_string());
+    }
+    c = c.to_uppercase();
+    let c = Ident::new(&c, Span::call_site());
+    property_bit_masks.insert(c.clone());
+
+    let default_property_index = property_map.len();
+    let property_index = property_map
+        .entry(property_name)
+        .or_insert(default_property_index);
+
+    let nested_fields = nested_fields.into_iter();
+
     quote! {
         if let Some(curves) = clip
-            .get(#property)
-            .map(|curve_untyped| curve_untyped.downcast_ref::<#field_type>())
+            .get(Self::PROPERTIES[#property_index])
+            .map(|curve_untyped| curve_untyped.downcast_ref::<#ty>())
             .flatten()
         {
             for (entity_index, (curve_index, curve)) in curves.iter() {
-                let entity_index = entities_map[entity_index as usize];
-                if let Some(ref mut component) = components[entity_index as usize] {
-                    let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
-                    keyframes[*curve_index] = k;
-                    component.#field_ident #(. #field_inner)* .blend(&mut blend_group, v, w);
+                let entity_index = entities_map[entity_index as usize] as usize;
+                if let Some(ref mut component) = components[entity_index] {
+                    let kr = &mut keyframes[*curve_index];
+                    let (k, v) = curve.sample_indexed(*kr, time);
+                    *kr = k;
+                    component.#ident #(. #nested_fields)* .blend(entity_index, #c, &mut blend_group, v, w);
                 }
             }
         }
     }
 }
 
-fn animate_property_extended(
-    property: &str,
-    field_ident: &Ident,
-    field_inner: &[Field],
-    field_type: &Type,
+fn animate_property_extended<'a>(
+    property_bit_masks: &mut HashSet<Ident>,
+    property_map: &mut HashMap<String, usize>,
+    property_name: String,
+    ident: &Ident,
+    nested_fields: impl Iterator<Item = &'a Field>,
+    ty: &Type,
 ) -> TokenStream2 {
-    let field_inner = field_inner
+    let nested_fields = nested_fields
+        .map(|field| field.ident.as_ref().unwrap())
+        .collect::<Vec<_>>();
+
+    let bit_masks = nested_fields
         .iter()
-        .map(|field| field.ident.as_ref().unwrap());
+        .map(|field_inner| {
+            let mut c = ident.to_string();
+            c.push('_');
+            c.push_str(&field_inner.to_string());
+            c = c.to_uppercase();
+            let c = Ident::new(&c, Span::call_site());
+            c
+        })
+        .collect::<Vec<_>>();
+
+    for c in &bit_masks {
+        property_bit_masks.insert(c.clone());
+    }
+
+    let default_property_index = property_map.len();
+    let property_index = property_map
+        .entry(property_name)
+        .or_insert(default_property_index);
 
     quote! {
         if let Some(curves) = clip
-            .get(#property)
-            .map(|curve_untyped| curve_untyped.downcast_ref::<#field_type>())
+            .get(Self::PROPERTIES[#property_index])
+            .map(|curve_untyped| curve_untyped.downcast_ref::<#ty>())
             .flatten()
         {
             for (entity_index, (curve_index, curve)) in curves.iter() {
-                let entity_index = entities_map[entity_index as usize];
-                if let Some(ref mut component) = components[entity_index as usize] {
-                    let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
-                    keyframes[*curve_index] = k;
-                    #(component.#field_ident.#field_inner.blend(&mut blend_group, v.#field_inner, w);)*
+                let entity_index = entities_map[entity_index as usize] as usize;
+                if let Some(ref mut component) = components[entity_index] {
+                    let kr = &mut keyframes[*curve_index];
+                    let (k, v) = curve.sample_indexed(*kr, time);
+                    *kr = k;
+                    #(component.#ident.#nested_fields.blend(entity_index, #bit_masks, &mut blend_group, v.#nested_fields, w);)*
                 }
             }
         }
@@ -63,11 +111,16 @@ fn animate_property_extended(
 }
 
 pub fn derive_animated_component(input: TokenStream) -> TokenStream {
-    let animated_properties: TokenStream2 =
-        derive_animated_properties_for_component(input.clone()).into();
-    let ast = parse_macro_input!(input as DeriveInput);
+    let derive_input = parse_macro_input!(input as DeriveInput);
+    let struct_name = &derive_input.ident;
 
-    let fields = match &ast.data {
+    // Modules namespaces
+    let modules = get_modules(&derive_input.attrs);
+    let bevy_animation = get_path(&modules.bevy_animation);
+    let bevy_ecs = get_path(&modules.bevy_ecs);
+    let bevy_asset = get_path(&modules.bevy_asset);
+
+    let fields = match &derive_input.data {
         Data::Struct(DataStruct {
             fields: Fields::Named(fields),
             ..
@@ -75,95 +128,131 @@ pub fn derive_animated_component(input: TokenStream) -> TokenStream {
         _ => panic!("Expected a struct with named fields."),
     };
 
-    let mut expanded: Vec<Vec<Field>> = vec![];
-    expanded.resize_with(fields.len(), || vec![]);
+    // Animation blocks for each animated property
+    let mut properties_blocks = vec![];
+    let mut property_bit_masks = HashSet::default();
+    let mut property_map = HashMap::default();
 
     // Filter fields
-    let fields = fields
-        .iter()
-        .enumerate()
-        .filter(|(field_index, field)| {
-            field
-                .attrs
-                .iter()
-                .find(|a| *a.path.get_ident().as_ref().unwrap() == "animated")
-                .map_or_else(
-                    || true,
-                    |a| {
-                        syn::custom_keyword!(ignore);
-                        syn::custom_keyword!(expand);
-                        a.parse_args_with(|input: ParseStream| {
-                            if input.parse::<Option<ignore>>()?.is_some() {
-                                Ok(false)
-                            } else if input.parse::<Option<expand>>()?.is_some() {
-                                let content;
-                                //syn::parenthesized!(content in input);
-                                syn::braced!(content in input);
-                                let fields: Punctuated<Field, Comma> =
-                                    content.parse_terminated(Field::parse_named)?;
-                                expanded[*field_index].extend(fields.iter().cloned());
-                                Ok(true)
-                            } else {
-                                Ok(true)
-                            }
-                        })
-                        .expect("Invalid 'animated' attribute format.")
-                    },
-                )
-        })
-        .map(|(_, field)| field)
-        .collect::<Vec<&Field>>();
-
-    let modules = get_modules(&ast.attrs);
-    let bevy_animation = get_path(&modules.bevy_animation);
-    let bevy_ecs = get_path(&modules.bevy_ecs);
-    let bevy_asset = get_path(&modules.bevy_asset);
+    for field in fields.iter() {
+        let ident = field.ident.as_ref().unwrap();
+        let ty = &field.ty;
+        let field_options = field
+            .attrs
+            .iter()
+            .find(|a| *a.path.get_ident().as_ref().unwrap() == "animated")
+            .map(|attr| parse_animate_options(attr).expect("Invalid 'animated' attribute format."));
 
-    let struct_name = &ast.ident;
-
-    let animate = fields
-        .iter()
-        .zip(expanded.iter())
-        .map(|(field, extended_fields)| {
-            if extended_fields.len() == 0 {
-                let ident = field.ident.as_ref().unwrap();
-                animate_property(
-                    &format!("{}.{}", struct_name, field.ident.as_ref().unwrap()),
-                    ident,
-                    &[],
-                    &field.ty,
-                )
-            } else {
-                let property = format!("{}.{}", struct_name, field.ident.as_ref().unwrap());
-                let ident = field.ident.as_ref().unwrap();
-                let main = animate_property_extended(
-                    &property,
-                    &parse_quote!(#ident),
-                    &extended_fields[..],
-                    &field.ty,
-                );
-                let extended = extended_fields.iter().map(|field| {
-                    let inner = field.ident.as_ref().unwrap();
+        if let Some(options) = field_options {
+            // Have some custom options attached
+            let nested_fields = options.fields.unwrap_or_else(Default::default);
+            let nested = nested_fields
+                .iter()
+                .map(|nested_field| {
+                    let nested_ident = nested_field.ident.as_ref().unwrap();
                     animate_property(
-                        &format!("{}.{}", property, inner),
+                        &mut property_bit_masks,
+                        &mut property_map,
+                        format!("{}.{}.{}", struct_name, ident, nested_ident),
                         ident,
-                        &[inner],
-                        &field.ty,
+                        Some(nested_ident),
+                        &nested_field.ty,
                     )
-                });
-                quote! {
-                    #main else {
-                        #( #extended )*
-                    }
+                })
+                .collect::<Vec<_>>();
+
+            if options.ignore {
+                if !nested_fields.is_empty() {
+                    // Only expanded properties
+                    properties_blocks.push(quote! { #( #nested )* });
                 }
+                continue;
+            } else {
+                if !nested_fields.is_empty() {
+                    // With expanded attributes
+                    let root = animate_property_extended(
+                        &mut property_bit_masks,
+                        &mut property_map,
+                        format!("{}.{}", struct_name, ident),
+                        ident,
+                        nested_fields.iter(),
+                        &ty,
+                    );
+                    properties_blocks.push(quote! { #root else {  #( #nested )* } });
+                    continue;
+                }
+                // Default behavior
             }
-        });
+        }
 
-    let generics = ast.generics;
+        // Default
+        let root = animate_property(
+            &mut property_bit_masks,
+            &mut property_map,
+            format!("{}.{}", struct_name, ident),
+            ident,
+            None,
+            ty,
+        );
+        properties_blocks.push(root);
+    }
+
+    let generics = derive_input.generics;
     let (impl_generics, ty_generics, _where_clause) = generics.split_for_impl();
 
+    let (constants_values, constants_idents): (Vec<u32>, Vec<&Ident>) = property_bit_masks
+        .iter()
+        .enumerate()
+        .map(|(i, n)| {
+            if i >= 32 {
+                panic!("more than 32 animated fields");
+            }
+
+            ((1 << i) as u32, n)
+        })
+        .unzip();
+
+    let mut properties_names = vec![];
+    properties_names.resize_with(property_map.len(), || String::new());
+    for (k, i) in property_map {
+        properties_names[i] = k;
+    }
+
     TokenStream::from(quote! {
-        #animated_properties
+
+        // #(
+        //     pub struct #property_ident;
+
+        //     impl #property_ident {
+        //         #(
+        //             pub const fn #property_field_ident(&self) -> #bevy_animation::Prop<#property_ty, #property_nested> {
+        //                 #bevy_animation::Prop::borrowed( #struct_name::PROPERTIES[#property_index] )
+        //             }
+        //         )*
+        //     }
+        // )*
+
+        // #(
+        //     impl std::ops::Deref for #bevy_animation::Prop<#property_ty, #property_nested> {
+        //         type Target = #property_nested;
+
+        //         #[inline(always)]
+        //         fn deref(&self) -> &Self::Target {
+        //             &#property_nested
+        //         }
+        //     }
+        // )*
+
+        impl #impl_generics #bevy_animation::AnimatedProperties for #struct_name #ty_generics {
+            type Props = #root_properties;
+
+            const PROPERTIES: &'static [&'static str] = &[ #( #properties_names, )* ];
+
+            #[inline(always)]
+            fn props() -> Self::Props {
+                #root_properties
+            }
+        }
 
         impl #impl_generics #bevy_animation::AnimatedComponent for #struct_name #ty_generics {
             fn animator_update_system(
@@ -172,13 +261,16 @@ pub fn derive_animated_component(input: TokenStream) -> TokenStream {
                 animators_query: #bevy_ecs::Query<& #bevy_animation::Animator>,
                 component_query: #bevy_ecs::Query<&mut Self>,
             ) {
+
+                #(const #constants_idents: u32 = #constants_values;)*
+
+                // TODO: add tracing span
                 // let __span = tracing::info_span!("animator_transform_update_system");
                 // let __guard = __span.enter();
 
                 let mut components = vec![];
 
                 for animator in animators_query.iter() {
-                    let mut blend_group = animator_blending.begin_blending();
 
                     components.clear();
 
@@ -197,6 +289,8 @@ pub fn derive_animated_component(input: TokenStream) -> TokenStream {
                         }
                     }
 
+                    let mut blend_group = animator_blending.begin_blending(components.len());
+
                     for (_, layer, clip_handle, entities_map) in animator.animate() {
                         let w = layer.weight;
                         if w < 1.0e-8 {
@@ -212,7 +306,7 @@ pub fn derive_animated_component(input: TokenStream) -> TokenStream {
                             // is accessed by two different systems, which is possible but weird and will hit the performance a bit
                             let keyframes = unsafe { layer.keyframes_unsafe() };
 
-                            #(#animate)*
+                            #(#properties_blocks)*
                         }
                     }
                 }
diff --git a/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs b/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs
index 3aa3324dce2cc..f1e14732c9bbe 100644
--- a/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs
+++ b/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs
@@ -3,13 +3,117 @@ use crate::{
     modules::{get_modules, get_path},
 };
 use proc_macro::TokenStream;
-use proc_macro2::Span;
-use quote::quote;
+use proc_macro2::{Span, TokenStream as TokenStream2};
+use quote::{quote, ToTokens, TokenStreamExt};
 use syn::{
     parse::ParseStream, parse_macro_input, parse_quote, parse_str, punctuated::Punctuated,
-    token::Comma, Data, DataStruct, DeriveInput, Field, Fields, Ident, Type,
+    token::Comma, Data, DataStruct, DeriveInput, Field, Fields, Ident, Path, Type,
 };
 
+// pub struct PropDerive<'a> {
+//     pub namespace: &'a Path,
+//     pub root: &'a Ident,
+//     pub name: Type,
+//     pub field: Vec<Ident>,
+//     pub ty: Vec<Type>,
+//     pub index: Vec<usize>,
+//     pub nested: Vec<Option<PropDerive<'a>>>,
+// }
+
+// impl<'a> ToTokens for PropDerive<'a> {
+//     fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+//         for (n, ty) in self
+//             .nested
+//             .iter()
+//             .zip(self.ty.iter())
+//             .filter_map(|(n, ty)| n.as_ref().map(|n| (n, ty)))
+//         {
+//             n.to_tokens(tokens);
+
+//             let namespace = &n.namespace;
+//             let name = &n.name;
+
+//             tokens.append_all(quote! {
+//                 impl std::ops::Deref for #namespace::Prop<#ty, #name> {
+//                     type Target = #name;
+
+//                     #[inline(always)]
+//                     fn deref(&self) -> &Self::Target {
+//                         &#name
+//                     }
+//                 }
+//             });
+//         }
+
+//         let unit: Type = parse_str("()").unwrap();
+//         let namespace = &self.namespace;
+//         let root = &self.root;
+//         let name = &self.name;
+//         let field = &self.field;
+//         let ty = &self.ty;
+//         let index = &self.index;
+//         let nested = self.nested.iter().map(|n| n.map_or(&unit, |n| n.name));
+//         tokens.append_all(quote! {
+//             pub struct #name;
+//             impl #name {
+//                 #(pub const fn #field(&self) -> #namespace::Prop<#ty, #nested> {
+//                     #namespace::Prop::borrowed( #root::PROPERTIES[#index] )
+//                 })*
+//             }
+//         });
+//     }
+// }
+
+pub fn query_prop_nested(
+    namespace: &Path,
+    struct_name: &Ident,
+    nested: &Type,
+    root_ty: &Type,
+    field: &[&Ident],
+    ty: &[&Type],
+    index: &[usize],
+) -> TokenStream2 {
+    quote! {
+        pub struct #nested;
+        impl #nested {
+            #(
+                pub const fn #field(&self) -> #namespace::Prop<#ty> {
+                    #namespace::Prop::borrowed( #struct_name::PROPERTIES[#index] )
+                }
+            )*
+        }
+        impl std::ops::Deref for #namespace::Prop<#root_ty, #nested> {
+            type Target = #nested;
+
+            #[inline(always)]
+            fn deref(&self) -> &Self::Target {
+                &#nested
+            }
+        }
+    }
+}
+
+pub fn query_prop(
+    namespace: &Path,
+    struct_name: &Ident,
+    root: &Type,
+    field: &[&Ident],
+    ty: &[&Type],
+    nested: &[&Type],
+    index: &[usize],
+) -> TokenStream2 {
+    quote! {
+        pub struct #root;
+        impl #root {
+            #(
+                pub const fn #field(&self) -> #namespace::Prop<#ty, #nested> {
+                    #namespace::Prop::borrowed( #struct_name::PROPERTIES[#index] )
+                }
+            )*
+        }
+    }
+}
+
 pub fn derive_animated_properties_for_component(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
 
@@ -43,8 +147,7 @@ pub fn derive_animated_properties_for_component(input: TokenStream) -> TokenStre
                                 Ok(false)
                             } else if input.parse::<Option<expand>>()?.is_some() {
                                 let content;
-                                //syn::parenthesized!(content in input);
-                                syn::braced!(content in input);
+                                syn::parenthesized!(content in input);
                                 let fields: Punctuated<Field, Comma> =
                                     content.parse_terminated(Field::parse_named)?;
                                 expanded[*field_index].extend(fields.iter().cloned());
@@ -192,8 +295,7 @@ pub fn derive_animated_properties_for_asset(input: TokenStream) -> TokenStream {
                                 Ok(false)
                             } else if input.parse::<Option<expand>>()?.is_some() {
                                 let content;
-                                //syn::parenthesized!(content in input);
-                                syn::braced!(content in input);
+                                syn::parenthesized!(content in input);
                                 let fields: Punctuated<Field, Comma> =
                                     content.parse_terminated(Field::parse_named)?;
                                 expanded[*field_index].extend(fields.iter().cloned());
diff --git a/crates/bevy_animation/bevy_animation_derive/src/help.rs b/crates/bevy_animation/bevy_animation_derive/src/help.rs
index b39f70452219d..149e137f27e01 100644
--- a/crates/bevy_animation/bevy_animation_derive/src/help.rs
+++ b/crates/bevy_animation/bevy_animation_derive/src/help.rs
@@ -1,3 +1,11 @@
+use proc_macro2::Span;
+use syn::{
+    parse::{Error as ParseError, Parse, ParseStream, Result as ParserResult},
+    punctuated::Punctuated,
+    token::Comma,
+    Attribute, Field,
+};
+
 pub fn snake_to_pascal_case(name: &str) -> String {
     let mut n = String::new();
 
@@ -13,3 +21,54 @@ pub fn snake_to_pascal_case(name: &str) -> String {
 
     n
 }
+
+enum AnimateOptEnum {
+    Ignore(Span),
+    Expand(Span, Punctuated<Field, Comma>),
+}
+
+impl Parse for AnimateOptEnum {
+    fn parse(input: ParseStream) -> ParserResult<Self> {
+        syn::custom_keyword!(ignore);
+        syn::custom_keyword!(fields);
+
+        if let Some(k) = input.parse::<Option<ignore>>()? {
+            Ok(AnimateOptEnum::Ignore(k.span))
+        } else if let Some(k) = input.parse::<Option<fields>>()? {
+            let content;
+            syn::parenthesized!(content in input);
+            Ok(AnimateOptEnum::Expand(
+                k.span,
+                content.parse_terminated(Field::parse_named)?,
+            ))
+        } else {
+            Err(ParseError::new(input.span(), "invalid attribute format"))
+        }
+    }
+}
+
+#[derive(Default)]
+pub struct AnimateOpt {
+    pub ignore: bool,
+    pub fields: Option<Punctuated<Field, Comma>>,
+}
+
+pub fn parse_animate_options(attr: &Attribute) -> ParserResult<AnimateOpt> {
+    let mut opt = AnimateOpt::default();
+    for attr in attr.parse_args_with(|input: ParseStream| {
+        input.parse_terminated::<AnimateOptEnum, Comma>(AnimateOptEnum::parse)
+    })? {
+        match attr {
+            AnimateOptEnum::Ignore(_) => {
+                opt.ignore = true;
+            }
+            AnimateOptEnum::Expand(span, fields) => {
+                if opt.fields.is_some() {
+                    Err(ParseError::new(span, "redefined `expand` attribute"))?;
+                }
+                opt.fields = Some(fields);
+            }
+        }
+    }
+    Ok(opt)
+}
diff --git a/crates/bevy_animation/src/impls.rs b/crates/bevy_animation/src/impls.rs
index 2d93cad4becd4..9f03817873315 100644
--- a/crates/bevy_animation/src/impls.rs
+++ b/crates/bevy_animation/src/impls.rs
@@ -16,272 +16,275 @@ use bevy_render::{
 };
 use bevy_transform::prelude::*;
 
-pub struct TransformTranslationProps;
+// pub struct TransformTranslationProps;
 
-impl Prop<Vec3, TransformTranslationProps> {
-    pub const fn x(&self) -> Prop<f32> {
-        Prop::borrowed("Transform.translation.x")
-    }
+// impl Prop<Vec3, TransformTranslationProps> {
+//     pub const fn x(&self) -> Prop<f32> {
+//         Prop::borrowed("Transform.translation.x")
+//     }
 
-    pub const fn y(&self) -> Prop<f32> {
-        Prop::borrowed("Transform.translation.y")
-    }
+//     pub const fn y(&self) -> Prop<f32> {
+//         Prop::borrowed("Transform.translation.y")
+//     }
 
-    pub const fn z(&self) -> Prop<f32> {
-        Prop::borrowed("Transform.translation.z")
-    }
-}
+//     pub const fn z(&self) -> Prop<f32> {
+//         Prop::borrowed("Transform.translation.z")
+//     }
+// }
 
-impl std::ops::Deref for Prop<Vec3, TransformTranslationProps> {
-    type Target = TransformTranslationProps;
+// impl std::ops::Deref for Prop<Vec3, TransformTranslationProps> {
+//     type Target = TransformTranslationProps;
 
-    #[inline(always)]
-    fn deref(&self) -> &Self::Target {
-        &TransformTranslationProps
-    }
-}
+//     #[inline(always)]
+//     fn deref(&self) -> &Self::Target {
+//         &TransformTranslationProps
+//     }
+// }
 
-pub struct TransformProps;
+// pub struct TransformProps;
 
-impl TransformProps {
-    pub const fn translation(&self) -> Prop<Vec3, TransformTranslationProps> {
-        Prop::borrowed("Transform.translation")
-    }
+// impl TransformProps {
+//     pub const fn translation(&self) -> Prop<Vec3, TransformTranslationProps> {
+//         Prop::borrowed("Transform.translation")
+//     }
 
-    pub const fn rotation(&self) -> Prop<Quat> {
-        Prop::borrowed("Transform.rotation")
-    }
+//     pub const fn rotation(&self) -> Prop<Quat> {
+//         Prop::borrowed("Transform.rotation")
+//     }
 
-    pub const fn scale(&self) -> Prop<Vec3> {
-        Prop::borrowed("Transform.scale")
-    }
-}
+//     pub const fn scale(&self) -> Prop<Vec3> {
+//         Prop::borrowed("Transform.scale")
+//     }
+// }
 
-impl AnimatedProperties for Transform {
-    type Props = TransformProps;
-
-    const PROPERTIES: &'static [&'static str] = &[
-        "Transform.translation",
-        "Transform.translation.x",
-        "Transform.translation.y",
-        "Transform.translation.z",
-        "Transform.rotation",
-        "Transform.scale",
-        // "Transform.scale.x",
-        // "Transform.scale.y",
-        // "Transform.scale.z",
-    ];
-
-    #[inline(always)]
-    fn props() -> Self::Props {
-        TransformProps
-    }
-}
+// impl AnimatedProperties for Transform {
+//     type Props = TransformProps;
+
+//     const PROPERTIES: &'static [&'static str] = &[
+//         "Transform.translation",
+//         "Transform.translation.x",
+//         "Transform.translation.y",
+//         "Transform.translation.z",
+//         "Transform.rotation",
+//         "Transform.scale",
+//         // "Transform.scale.x",
+//         // "Transform.scale.y",
+//         // "Transform.scale.z",
+//     ];
+
+//     #[inline(always)]
+//     fn props() -> Self::Props {
+//         TransformProps
+//     }
+// }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-impl AnimatedComponent for Transform {
-    fn animator_update_system(
-        clips: Res<Assets<Clip>>,
-        mut animator_blending: Local<AnimatorBlending>,
-        animators_query: Query<&Animator>,
-        component_query: Query<&mut Self>,
-    ) {
-        let __span = tracing::info_span!("animator_transform_update_system");
-        let __guard = __span.enter();
-
-        let mut components = vec![];
-
-        for animator in animators_query.iter() {
-            components.clear();
-
-            // ? NOTE: Lazy get each component is worse than just fetching everything at once
-            // Pre-fetch all transforms to avoid calling get_mut multiple times
-            // SAFETY: each component will be updated one at the time and this function
-            // currently has the mutability over the Transform type, so no race conditions
-            // are possible
-            unsafe {
-                for entity in animator.entities() {
-                    components.push(
-                        entity
-                            .map(|entity| component_query.get_unsafe(entity).ok())
-                            .flatten(),
-                    );
-                }
-            }
-
-            let mut blend_group = animator_blending.begin_blending(components.len());
-
-            // Bit fields
-            const TRANSLATE_X: u32 = 1;
-            const TRANSLATE_Y: u32 = 2;
-            const TRANSLATE_Z: u32 = 4;
-            const ROTATION: u32 = 8;
-            const SCALE: u32 = 16;
-
-            for (_, layer, clip_handle, entities_map) in animator.animate() {
-                let w = layer.weight;
-                if w < 1.0e-8 {
-                    continue;
-                }
-
-                if let Some(clip) = clips.get(clip_handle) {
-                    let time = layer.time;
-
-                    // SAFETY: Never a different thread will modify or access the same index as this one;
-                    // Plus as a nice and crazy feature each property is grouped by name into their own cache line
-                    // buckets, this way no cache line will be accessed by the same thread unless the same property
-                    // is accessed by two different systems, which is possible but weird and will hit the performance a bit
-                    let keyframes = unsafe { layer.keyframes_unsafe() };
-
-                    if let Some(curves) = clip
-                        .get("Transform.translation")
-                        .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
-                        .flatten()
-                    {
-                        for (entity_index, (curve_index, curve)) in curves.iter() {
-                            let entity_index = entities_map[entity_index as usize] as usize;
-                            if let Some(ref mut component) = components[entity_index] {
-                                let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
-                                keyframes[*curve_index] = k;
-                                // ? NOTE: Blend must be done for each component in order for it to work
-                                component.translation.x.blend(
-                                    entity_index,
-                                    TRANSLATE_X,
-                                    &mut blend_group,
-                                    v.x,
-                                    w,
-                                );
-                                component.translation.y.blend(
-                                    entity_index,
-                                    TRANSLATE_Y,
-                                    &mut blend_group,
-                                    v.y,
-                                    w,
-                                );
-                                component.translation.z.blend(
-                                    entity_index,
-                                    TRANSLATE_Z,
-                                    &mut blend_group,
-                                    v.z,
-                                    w,
-                                );
-                            }
-                        }
-                    } else {
-                        if let Some(curves) = clip
-                            .get("Transform.translation.x")
-                            .map(|curve_untyped| curve_untyped.downcast_ref::<f32>())
-                            .flatten()
-                        {
-                            for (entity_index, (curve_index, curve)) in curves.iter() {
-                                let entity_index = entities_map[entity_index as usize] as usize;
-                                if let Some(ref mut component) = components[entity_index] {
-                                    let (k, v) =
-                                        curve.sample_indexed(keyframes[*curve_index], time);
-                                    keyframes[*curve_index] = k;
-                                    component.translation.x.blend(
-                                        entity_index,
-                                        TRANSLATE_X,
-                                        &mut blend_group,
-                                        v,
-                                        w,
-                                    );
-                                }
-                            }
-                        }
-
-                        if let Some(curves) = clip
-                            .get("Transform.translation.y")
-                            .map(|curve_untyped| curve_untyped.downcast_ref::<f32>())
-                            .flatten()
-                        {
-                            for (entity_index, (curve_index, curve)) in curves.iter() {
-                                let entity_index = entities_map[entity_index as usize] as usize;
-                                if let Some(ref mut component) = components[entity_index] {
-                                    let (k, v) =
-                                        curve.sample_indexed(keyframes[*curve_index], time);
-                                    keyframes[*curve_index] = k;
-                                    component.translation.y.blend(
-                                        entity_index,
-                                        TRANSLATE_Y,
-                                        &mut blend_group,
-                                        v,
-                                        w,
-                                    );
-                                }
-                            }
-                        }
-
-                        if let Some(curves) = clip
-                            .get("Transform.translation.z")
-                            .map(|curve_untyped| curve_untyped.downcast_ref::<f32>())
-                            .flatten()
-                        {
-                            for (entity_index, (curve_index, curve)) in curves.iter() {
-                                let entity_index = entities_map[entity_index as usize] as usize;
-                                if let Some(ref mut component) = components[entity_index] {
-                                    let (k, v) =
-                                        curve.sample_indexed(keyframes[*curve_index], time);
-                                    keyframes[*curve_index] = k;
-                                    component.translation.z.blend(
-                                        entity_index,
-                                        TRANSLATE_Z,
-                                        &mut blend_group,
-                                        v,
-                                        w,
-                                    );
-                                }
-                            }
-                        }
-                    }
-
-                    if let Some(curves) = clip
-                        .get("Transform.rotation")
-                        .map(|curve_untyped| curve_untyped.downcast_ref::<Quat>())
-                        .flatten()
-                    {
-                        for (entity_index, (curve_index, curve)) in curves.iter() {
-                            let entity_index = entities_map[entity_index as usize] as usize;
-                            if let Some(ref mut component) = components[entity_index] {
-                                let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
-                                keyframes[*curve_index] = k;
-                                component.rotation.blend(
-                                    entity_index,
-                                    ROTATION,
-                                    &mut blend_group,
-                                    v,
-                                    w,
-                                );
-                            }
-                        }
-                    }
-
-                    // TODO: Euler rotation support?
-
-                    if let Some(curves) = clip
-                        .get("Transform.scale")
-                        .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
-                        .flatten()
-                    {
-                        for (entity_index, (curve_index, curve)) in curves.iter() {
-                            let entity_index = entities_map[entity_index as usize] as usize;
-                            if let Some(ref mut component) = components[entity_index] {
-                                let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
-                                keyframes[*curve_index] = k;
-                                component
-                                    .scale
-                                    .blend(entity_index, SCALE, &mut blend_group, v, w);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        std::mem::drop(__guard);
-    }
-}
+// impl AnimatedComponent for Transform {
+//     fn animator_update_system(
+//         clips: Res<Assets<Clip>>,
+//         mut animator_blending: Local<AnimatorBlending>,
+//         animators_query: Query<&Animator>,
+//         component_query: Query<&mut Self>,
+//     ) {
+//         let __span = tracing::info_span!("animator_transform_update_system");
+//         let __guard = __span.enter();
+
+//         let mut components = vec![];
+
+//         for animator in animators_query.iter() {
+//             components.clear();
+
+//             // ? NOTE: Lazy get each component is worse than just fetching everything at once
+//             // Pre-fetch all transforms to avoid calling get_mut multiple times
+//             // SAFETY: each component will be updated one at the time and this function
+//             // currently has the mutability over the Transform type, so no race conditions
+//             // are possible
+//             unsafe {
+//                 for entity in animator.entities() {
+//                     components.push(
+//                         entity
+//                             .map(|entity| component_query.get_unsafe(entity).ok())
+//                             .flatten(),
+//                     );
+//                 }
+//             }
+
+//             let mut blend_group = animator_blending.begin_blending(components.len());
+
+//             // Bit fields
+//             const TRANSLATE_X: u32 = 1;
+//             const TRANSLATE_Y: u32 = 2;
+//             const TRANSLATE_Z: u32 = 4;
+//             const ROTATION: u32 = 8;
+//             const SCALE: u32 = 16;
+
+//             for (_, layer, clip_handle, entities_map) in animator.animate() {
+//                 let w = layer.weight;
+//                 if w < 1.0e-8 {
+//                     continue;
+//                 }
+
+//                 if let Some(clip) = clips.get(clip_handle) {
+//                     let time = layer.time;
+
+//                     // SAFETY: Never a different thread will modify or access the same index as this one;
+//                     // Plus as a nice and crazy feature each property is grouped by name into their own cache line
+//                     // buckets, this way no cache line will be accessed by the same thread unless the same property
+//                     // is accessed by two different systems, which is possible but weird and will hit the performance a bit
+//                     let keyframes = unsafe { layer.keyframes_unsafe() };
+
+//                     if let Some(curves) = clip
+//                         .get("Transform.translation")
+//                         .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
+//                         .flatten()
+//                     {
+//                         for (entity_index, (curve_index, curve)) in curves.iter() {
+//                             let entity_index = entities_map[entity_index as usize] as usize;
+//                             if let Some(ref mut component) = components[entity_index] {
+//                                 let kr = &mut keyframes[*curve_index];
+//                                 let (k, v) = curve.sample_indexed(*kr, time);
+//                                 *kr = k;
+//                                 // ? NOTE: Blend must be done for each component in order for it to work
+//                                 component.translation.x.blend(
+//                                     entity_index,
+//                                     TRANSLATE_X,
+//                                     &mut blend_group,
+//                                     v.x,
+//                                     w,
+//                                 );
+//                                 component.translation.y.blend(
+//                                     entity_index,
+//                                     TRANSLATE_Y,
+//                                     &mut blend_group,
+//                                     v.y,
+//                                     w,
+//                                 );
+//                                 component.translation.z.blend(
+//                                     entity_index,
+//                                     TRANSLATE_Z,
+//                                     &mut blend_group,
+//                                     v.z,
+//                                     w,
+//                                 );
+//                             }
+//                         }
+//                     } else {
+//                         if let Some(curves) = clip
+//                             .get("Transform.translation.x")
+//                             .map(|curve_untyped| curve_untyped.downcast_ref::<f32>())
+//                             .flatten()
+//                         {
+//                             for (entity_index, (curve_index, curve)) in curves.iter() {
+//                                 let entity_index = entities_map[entity_index as usize] as usize;
+//                                 if let Some(ref mut component) = components[entity_index] {
+//                                     let kr = &mut keyframes[*curve_index];
+//                                     let (k, v) = curve.sample_indexed(*kr, time);
+//                                     *kr = k;
+//                                     component.translation.x.blend(
+//                                         entity_index,
+//                                         TRANSLATE_X,
+//                                         &mut blend_group,
+//                                         v,
+//                                         w,
+//                                     );
+//                                 }
+//                             }
+//                         }
+
+//                         if let Some(curves) = clip
+//                             .get("Transform.translation.y")
+//                             .map(|curve_untyped| curve_untyped.downcast_ref::<f32>())
+//                             .flatten()
+//                         {
+//                             for (entity_index, (curve_index, curve)) in curves.iter() {
+//                                 let entity_index = entities_map[entity_index as usize] as usize;
+//                                 if let Some(ref mut component) = components[entity_index] {
+//                                     let kr = &mut keyframes[*curve_index];
+//                                     let (k, v) = curve.sample_indexed(*kr, time);
+//                                     *kr = k;
+//                                     component.translation.y.blend(
+//                                         entity_index,
+//                                         TRANSLATE_Y,
+//                                         &mut blend_group,
+//                                         v,
+//                                         w,
+//                                     );
+//                                 }
+//                             }
+//                         }
+
+//                         if let Some(curves) = clip
+//                             .get("Transform.translation.z")
+//                             .map(|curve_untyped| curve_untyped.downcast_ref::<f32>())
+//                             .flatten()
+//                         {
+//                             for (entity_index, (curve_index, curve)) in curves.iter() {
+//                                 let entity_index = entities_map[entity_index as usize] as usize;
+//                                 if let Some(ref mut component) = components[entity_index] {
+//                                     let kr = &mut keyframes[*curve_index];
+//                                     let (k, v) = curve.sample_indexed(*kr, time);
+//                                     *kr = k;
+//                                     component.translation.z.blend(
+//                                         entity_index,
+//                                         TRANSLATE_Z,
+//                                         &mut blend_group,
+//                                         v,
+//                                         w,
+//                                     );
+//                                 }
+//                             }
+//                         }
+//                     }
+
+//                     if let Some(curves) = clip
+//                         .get("Transform.rotation")
+//                         .map(|curve_untyped| curve_untyped.downcast_ref::<Quat>())
+//                         .flatten()
+//                     {
+//                         for (entity_index, (curve_index, curve)) in curves.iter() {
+//                             let entity_index = entities_map[entity_index as usize] as usize;
+//                             if let Some(ref mut component) = components[entity_index] {
+//                                 let kr = &mut keyframes[*curve_index];
+//                                 let (k, v) = curve.sample_indexed(*kr, time);
+//                                 *kr = k;
+//                                 component.rotation.blend(
+//                                     entity_index,
+//                                     ROTATION,
+//                                     &mut blend_group,
+//                                     v,
+//                                     w,
+//                                 );
+//                             }
+//                         }
+//                     }
+
+//                     // TODO: Euler rotation support?
+
+//                     if let Some(curves) = clip
+//                         .get("Transform.scale")
+//                         .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
+//                         .flatten()
+//                     {
+//                         for (entity_index, (curve_index, curve)) in curves.iter() {
+//                             let entity_index = entities_map[entity_index as usize] as usize;
+//                             if let Some(ref mut component) = components[entity_index] {
+//                                 let kr = &mut keyframes[*curve_index];
+//                                 let (k, v) = curve.sample_indexed(*kr, time);
+//                                 *kr = k;
+//                                 component
+//                                     .scale
+//                                     .blend(entity_index, SCALE, &mut blend_group, v, w);
+//                             }
+//                         }
+//                     }
+//                 }
+//             }
+//         }
+
+//         std::mem::drop(__guard);
+//     }
+// }
 
 // ///////////////////////////////////////////////////////////////////////////////
 
@@ -446,15 +449,15 @@ impl AnimatedComponent for Transform {
 //     c: Vec3,
 // }
 
-// animated_component! {
-//     struct Transform {
-//         #[animated(fields(x: f32, y: f32, z: f32))]
-//         translation: Vec3,
-//         rotation: Quat,
-//         #[animated(fields(x: f32, y: f32, z: f32))]
-//         scale: Vec3,
-//     }
-// }
+animated_component! {
+    struct Transform {
+        #[animated(fields(x: f32, y: f32, z: f32))]
+        translation: Vec3,
+        rotation: Quat,
+        #[animated(fields(x: f32, y: f32, z: f32))]
+        scale: Vec3,
+    }
+}
 
 // animated_asset! {
 //     struct StandardMaterial {

From 43a80fa090a18c6d8c5015db58b2400e3a47f0d7 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sun, 27 Dec 2020 00:36:44 -0300
Subject: [PATCH 068/153] reflect animation

---
 .../src/animated_component.rs                 |   4 +-
 crates/bevy_animation/src/app.rs              |  27 ++-
 crates/bevy_animation/src/impls.rs            | 120 +++++-----
 crates/bevy_animation/src/lib.rs              |   3 +-
 crates/bevy_animation/src/reflect.rs          | 217 ++++++++++++++++++
 5 files changed, 306 insertions(+), 65 deletions(-)
 create mode 100644 crates/bevy_animation/src/reflect.rs

diff --git a/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs b/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
index 7136eb223676a..bea19f37e2bbf 100644
--- a/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
+++ b/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
@@ -244,13 +244,13 @@ pub fn derive_animated_component(input: TokenStream) -> TokenStream {
         // )*
 
         impl #impl_generics #bevy_animation::AnimatedProperties for #struct_name #ty_generics {
-            type Props = #root_properties;
+            type Props = ();
 
             const PROPERTIES: &'static [&'static str] = &[ #( #properties_names, )* ];
 
             #[inline(always)]
             fn props() -> Self::Props {
-                #root_properties
+                todo!()
             }
         }
 
diff --git a/crates/bevy_animation/src/app.rs b/crates/bevy_animation/src/app.rs
index ffa6529a62f2d..06ac713ea9d21 100644
--- a/crates/bevy_animation/src/app.rs
+++ b/crates/bevy_animation/src/app.rs
@@ -1,15 +1,22 @@
-use crate::custom::{AnimatedAsset, AnimatedComponent, AnimatorRegistry};
-use crate::stage;
 use bevy_app::AppBuilder;
+use bevy_ecs::prelude::*;
+use bevy_reflect::prelude::*;
 use std::{
     any::{type_name, TypeId},
     mem::drop,
 };
 
+use crate::{
+    custom::{AnimatedAsset, AnimatedComponent, AnimatorRegistry},
+    reflect, stage,
+};
+
 pub trait AddAnimated {
     fn register_animated_component<T: AnimatedComponent>(&mut self) -> &mut Self;
 
     fn register_animated_asset<T: AnimatedAsset>(&mut self) -> &mut Self;
+
+    fn register_animated<T: Struct + Component>(&mut self) -> &mut Self;
 }
 
 impl AddAnimated for AppBuilder {
@@ -44,4 +51,20 @@ impl AddAnimated for AppBuilder {
             panic!("animator already registered for '{}'", type_name::<T>());
         }
     }
+
+    fn register_animated<T: Struct + Component>(&mut self) -> &mut Self {
+        let mut registry = self
+            .resources_mut()
+            .get_or_insert_with(AnimatorRegistry::default);
+
+        if registry.targets.insert(TypeId::of::<T>()) {
+            // registry.static_properties.extend(T::PROPERTIES.iter());
+            drop(registry);
+
+            self.add_system_to_stage(stage::ANIMATE, reflect::animate_system::<T>);
+            self
+        } else {
+            panic!("animator already registered for '{}'", type_name::<T>());
+        }
+    }
 }
diff --git a/crates/bevy_animation/src/impls.rs b/crates/bevy_animation/src/impls.rs
index 9f03817873315..ca48a04eb0bf6 100644
--- a/crates/bevy_animation/src/impls.rs
+++ b/crates/bevy_animation/src/impls.rs
@@ -16,67 +16,67 @@ use bevy_render::{
 };
 use bevy_transform::prelude::*;
 
-// pub struct TransformTranslationProps;
+pub struct TransformTranslationProps;
 
-// impl Prop<Vec3, TransformTranslationProps> {
-//     pub const fn x(&self) -> Prop<f32> {
-//         Prop::borrowed("Transform.translation.x")
-//     }
+impl Prop<Vec3, TransformTranslationProps> {
+    pub const fn x(&self) -> Prop<f32> {
+        Prop::borrowed("Transform.translation.x")
+    }
 
-//     pub const fn y(&self) -> Prop<f32> {
-//         Prop::borrowed("Transform.translation.y")
-//     }
+    pub const fn y(&self) -> Prop<f32> {
+        Prop::borrowed("Transform.translation.y")
+    }
 
-//     pub const fn z(&self) -> Prop<f32> {
-//         Prop::borrowed("Transform.translation.z")
-//     }
-// }
+    pub const fn z(&self) -> Prop<f32> {
+        Prop::borrowed("Transform.translation.z")
+    }
+}
 
-// impl std::ops::Deref for Prop<Vec3, TransformTranslationProps> {
-//     type Target = TransformTranslationProps;
+impl std::ops::Deref for Prop<Vec3, TransformTranslationProps> {
+    type Target = TransformTranslationProps;
 
-//     #[inline(always)]
-//     fn deref(&self) -> &Self::Target {
-//         &TransformTranslationProps
-//     }
-// }
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &TransformTranslationProps
+    }
+}
 
-// pub struct TransformProps;
+pub struct TransformProps;
 
-// impl TransformProps {
-//     pub const fn translation(&self) -> Prop<Vec3, TransformTranslationProps> {
-//         Prop::borrowed("Transform.translation")
-//     }
+impl TransformProps {
+    pub const fn translation(&self) -> Prop<Vec3, TransformTranslationProps> {
+        Prop::borrowed("Transform.translation")
+    }
 
-//     pub const fn rotation(&self) -> Prop<Quat> {
-//         Prop::borrowed("Transform.rotation")
-//     }
+    pub const fn rotation(&self) -> Prop<Quat> {
+        Prop::borrowed("Transform.rotation")
+    }
 
-//     pub const fn scale(&self) -> Prop<Vec3> {
-//         Prop::borrowed("Transform.scale")
-//     }
-// }
+    pub const fn scale(&self) -> Prop<Vec3> {
+        Prop::borrowed("Transform.scale")
+    }
+}
 
-// impl AnimatedProperties for Transform {
-//     type Props = TransformProps;
-
-//     const PROPERTIES: &'static [&'static str] = &[
-//         "Transform.translation",
-//         "Transform.translation.x",
-//         "Transform.translation.y",
-//         "Transform.translation.z",
-//         "Transform.rotation",
-//         "Transform.scale",
-//         // "Transform.scale.x",
-//         // "Transform.scale.y",
-//         // "Transform.scale.z",
-//     ];
-
-//     #[inline(always)]
-//     fn props() -> Self::Props {
-//         TransformProps
-//     }
-// }
+impl AnimatedProperties for Transform {
+    type Props = TransformProps;
+
+    const PROPERTIES: &'static [&'static str] = &[
+        "Transform.translation",
+        "Transform.translation.x",
+        "Transform.translation.y",
+        "Transform.translation.z",
+        "Transform.rotation",
+        "Transform.scale",
+        // "Transform.scale.x",
+        // "Transform.scale.y",
+        // "Transform.scale.z",
+    ];
+
+    #[inline(always)]
+    fn props() -> Self::Props {
+        TransformProps
+    }
+}
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -449,15 +449,15 @@ use bevy_transform::prelude::*;
 //     c: Vec3,
 // }
 
-animated_component! {
-    struct Transform {
-        #[animated(fields(x: f32, y: f32, z: f32))]
-        translation: Vec3,
-        rotation: Quat,
-        #[animated(fields(x: f32, y: f32, z: f32))]
-        scale: Vec3,
-    }
-}
+// animated_component! {
+//     struct Transform {
+//         #[animated(fields(x: f32, y: f32, z: f32))]
+//         translation: Vec3,
+//         rotation: Quat,
+//         #[animated(fields(x: f32, y: f32, z: f32))]
+//         scale: Vec3,
+//     }
+// }
 
 // animated_asset! {
 //     struct StandardMaterial {
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index fdcd4677ec4fd..ac39b4728eb71 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -4,6 +4,7 @@ use bevy_reflect::RegisterTypeBuilder;
 
 mod app;
 mod custom;
+mod reflect;
 //mod experimental;
 mod hierarchy;
 mod impls;
@@ -54,7 +55,7 @@ impl Plugin for AnimationPlugin {
 
         // ! FIXME: Each added animated component or asset will add a bit of overhead in the animation
         // ! system, I have no idea how big this is but I would like to make it pay only for what you use
-        app.register_animated_component::<bevy_transform::prelude::Transform>();
+        app.register_animated::<bevy_transform::prelude::Transform>();
 
         // Skinning
         app.add_asset::<SkinAsset>()
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
new file mode 100644
index 0000000000000..9bca7613c62ea
--- /dev/null
+++ b/crates/bevy_animation/src/reflect.rs
@@ -0,0 +1,217 @@
+//! Generic animation for any type that implements the `Reflect` trait
+//!
+//! This will never be as fast as the code gen approach but it will give
+//! a nice way of provide animation to external types or even to types derived
+//! from scrips!
+
+use std::{any::TypeId, marker::PhantomData};
+
+use bevy_asset::{prelude::*, Asset};
+use bevy_ecs::prelude::*;
+use bevy_math::prelude::*;
+use bevy_reflect::prelude::*;
+
+use crate::{blending::Blend, lerping::Lerp, Animator, AnimatorBlending, Clip};
+
+#[derive(Default)]
+struct AnimatorDescriptorInner {
+    dynamic_properties: Vec<(String, TypeId, isize, u32)>,
+}
+
+// Defines how to animate the reflected type
+pub struct AnimatorDescriptor<T> {
+    inner: Option<AnimatorDescriptorInner>,
+    animator_blending: AnimatorBlending,
+    _marker: PhantomData<T>,
+}
+
+impl<T> Default for AnimatorDescriptor<T> {
+    fn default() -> Self {
+        Self {
+            inner: None,
+            animator_blending: AnimatorBlending::default(),
+            _marker: PhantomData,
+        }
+    }
+}
+
+fn shorten_name(n: &str) -> &str {
+    n.rsplit("::").nth(0).unwrap_or(n)
+}
+
+// fn animate<T: Lerp + Blend + 'static>(
+//     prop_name: &str,
+//     prop_type: &TypeId,
+//     prop_offset: &usize,
+//     prop_mask: &u32,
+// ) {
+//     if *prop_type == TypeId::of::<T>() {
+//         if let Some(curves) = clip
+//             .get(prop_name)
+//             .map(|curve_untyped| curve_untyped.downcast_ref::<T>())
+//             .flatten()
+//         {
+//             for (entity_index, (curve_index, curve)) in curves.iter() {
+//                 let entity_index = entities_map[entity_index as usize] as usize;
+//                 if let Some(ref mut component) = components[entity_index] {
+//                     let kr = &mut keyframes[*curve_index];
+//                     let (k, v) = curve.sample_indexed(*kr, time);
+//                     *kr = k;
+
+//                     let value = unsafe {
+//                         &mut *(((&mut *component) as *mut _ as *mut u8).offset(*prop_offset)
+//                             as *mut T)
+//                     };
+
+//                     value.blend(entity_index, *prop_mask, &mut blend_group, v, w);
+//                 }
+//             }
+//         }
+//         true
+//     } else {
+//         false
+//     }
+// }
+
+pub fn animate_system<T: Struct + Component>(
+    mut descriptor: Local<AnimatorDescriptor<T>>,
+    clips: Res<Assets<Clip>>,
+    animators_query: Query<&Animator>,
+    // assets: Option<ResMut<Assets<T>>>,
+    // handles_query: Query<&mut Handle<T>>,
+    components_query: Query<&mut T>,
+) {
+    // let __span = tracing::info_span!("animator_transform_update_system");
+    // let __guard = __span.enter();
+
+    let mut components = vec![];
+
+    for animator in animators_query.iter() {
+        components.clear();
+
+        // ? NOTE: Lazy get each component is worse than just fetching everything at once
+        // Pre-fetch all transforms to avoid calling get_mut multiple times
+        // SAFETY: each component will be updated one at the time and this function
+        // currently has the mutability over the Transform type, so no race conditions
+        // are possible
+        unsafe {
+            for entity in animator.entities() {
+                components.push(
+                    entity
+                        .map(|entity| components_query.get_unsafe(entity).ok())
+                        .flatten(),
+                );
+            }
+        }
+
+        if let Some(c) = components.iter().find_map(|c| c.as_ref()) {
+            if descriptor.inner.is_none() {
+                let mut inner = AnimatorDescriptorInner::default();
+
+                // Lazy initialize the descriptor
+                let short_name = shorten_name(c.type_name());
+                let origin = (&**c) as *const _ as *const u8;
+                for (i, value) in c.iter_fields().enumerate() {
+                    let mut n = short_name.to_string();
+                    n.push('.');
+                    n.push_str(c.name_at(i).unwrap());
+                    let ty = value.type_id();
+                    // SAFETY: Is be less than size_of::<T>() so it won't be crazy high
+                    let offset =
+                        unsafe { (value.any() as *const _ as *const u8).offset_from(origin) };
+
+                    inner
+                        .dynamic_properties
+                        .push((n, ty, offset, (1 << i) as u32));
+                }
+
+                descriptor.inner = Some(inner);
+            }
+        } else {
+            // No components found skip
+            continue;
+        }
+
+        let descriptor = &mut *descriptor;
+        let descriptor_inner = descriptor.inner.as_ref().unwrap();
+
+        let mut blend_group = descriptor
+            .animator_blending
+            .begin_blending(components.len());
+
+        for (_, layer, clip_handle, entities_map) in animator.animate() {
+            let w = layer.weight;
+            if w < 1.0e-8 {
+                continue;
+            }
+
+            if let Some(clip) = clips.get(clip_handle) {
+                let time = layer.time;
+
+                // SAFETY: Never a different thread will modify or access the same index as this one;
+                // Plus as a nice and crazy feature each property is grouped by name into their own cache line
+                // buckets, this way no cache line will be accessed by the same thread unless the same property
+                // is accessed by two different systems, which is possible but weird and will hit the performance a bit
+                let keyframes = unsafe { layer.keyframes_unsafe() };
+
+                for (prop_name, prop_type, prop_offset, prop_mask) in
+                    &descriptor_inner.dynamic_properties
+                {
+                    if *prop_type == TypeId::of::<Vec3>() {
+                        if let Some(curves) = clip
+                            .get(prop_name)
+                            .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
+                            .flatten()
+                        {
+                            for (entity_index, (curve_index, curve)) in curves.iter() {
+                                let entity_index = entities_map[entity_index as usize] as usize;
+                                if let Some(ref mut component) = components[entity_index] {
+                                    let kr = &mut keyframes[*curve_index];
+                                    let (k, v) = curve.sample_indexed(*kr, time);
+                                    *kr = k;
+
+                                    let value = unsafe {
+                                        &mut *(((&mut **component) as *mut _ as *mut u8)
+                                            .offset(*prop_offset)
+                                            as *mut Vec3)
+                                    };
+
+                                    value.blend(entity_index, *prop_mask, &mut blend_group, v, w);
+                                }
+                            }
+                        }
+                        continue;
+                    }
+
+                    if *prop_type == TypeId::of::<Quat>() {
+                        if let Some(curves) = clip
+                            .get(prop_name)
+                            .map(|curve_untyped| curve_untyped.downcast_ref::<Quat>())
+                            .flatten()
+                        {
+                            for (entity_index, (curve_index, curve)) in curves.iter() {
+                                let entity_index = entities_map[entity_index as usize] as usize;
+                                if let Some(ref mut component) = components[entity_index] {
+                                    let kr = &mut keyframes[*curve_index];
+                                    let (k, v) = curve.sample_indexed(*kr, time);
+                                    *kr = k;
+
+                                    let value = unsafe {
+                                        &mut *(((&mut **component) as *mut _ as *mut u8)
+                                            .offset(*prop_offset)
+                                            as *mut Quat)
+                                    };
+
+                                    value.blend(entity_index, *prop_mask, &mut blend_group, v, w);
+                                }
+                            }
+                        }
+                        continue;
+                    }
+                }
+            }
+        }
+    }
+
+    // std::mem::drop(__guard);
+}

From 87575f75d791546d80e60ffe334a54fd4b3a62a4 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sun, 27 Dec 2020 13:51:02 -0300
Subject: [PATCH 069/153] custom animated types

---
 crates/bevy_animation/src/lib.rs     |   3 +
 crates/bevy_animation/src/reflect.rs | 241 ++++++++++++++++-----------
 2 files changed, 151 insertions(+), 93 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index ac39b4728eb71..b822837c55ab8 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -18,6 +18,7 @@ pub use crate::app::*;
 pub use crate::blending::AnimatorBlending;
 pub use crate::custom::*;
 pub use crate::hierarchy::Hierarchy;
+pub use crate::reflect::AnimatorRegistry;
 pub use crate::skinned_mesh::*;
 
 pub use bevy_animation_derive::*;
@@ -29,6 +30,7 @@ pub mod prelude {
     pub use crate::custom::{AnimatedAsset, AnimatedComponent, Animator, Clip};
     pub use crate::hierarchy::Hierarchy;
     pub use crate::lerping::Lerp;
+    pub use crate::reflect::AnimatorRegistry;
     pub use crate::skinned_mesh::{SkinAsset, SkinComponent, SkinDebugger};
     pub use bevy_animation_derive::*;
 }
@@ -55,6 +57,7 @@ impl Plugin for AnimationPlugin {
 
         // ! FIXME: Each added animated component or asset will add a bit of overhead in the animation
         // ! system, I have no idea how big this is but I would like to make it pay only for what you use
+        app.add_resource(reflect::AnimatorRegistry::default());
         app.register_animated::<bevy_transform::prelude::Transform>();
 
         // Skinning
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index 9bca7613c62ea..7030a86eb7ab4 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -11,11 +11,124 @@ use bevy_ecs::prelude::*;
 use bevy_math::prelude::*;
 use bevy_reflect::prelude::*;
 
-use crate::{blending::Blend, lerping::Lerp, Animator, AnimatorBlending, Clip};
+use crate::{
+    blending::AnimatorBlendGroup, blending::Blend, lerping::Lerp, Animator, AnimatorBlending, Clip,
+};
+
+type AnimateFn = fn(
+    components: &mut dyn Components,
+    entities_map: &[u16],
+    blend_group: &mut AnimatorBlendGroup,
+    keyframes: &mut [u16],
+    clip: &Clip,
+    time: f32,
+    w: f32,
+    prop_name: &str,
+    prop_type: TypeId,
+    prop_offset: isize,
+    prop_mask: u32,
+) -> bool;
+
+/// Register how to animate basic types
+pub struct AnimatorRegistry {
+    animate_functions: Vec<(TypeId, AnimateFn)>,
+}
+
+impl Default for AnimatorRegistry {
+    fn default() -> Self {
+        Self {
+            // Basic types
+            animate_functions: vec![
+                (TypeId::of::<bool>(), animate::<f32>),
+                (TypeId::of::<f32>(), animate::<f32>),
+                (TypeId::of::<Vec2>(), animate::<Vec2>),
+                (TypeId::of::<Vec3>(), animate::<Vec3>),
+                (TypeId::of::<Vec4>(), animate::<Vec4>),
+                // (TypeId::of::<Color>(), animate::<Color>),
+                // (TypeId::of::<HandleUntyped>(), animate::<HandleUntyped>),
+                (TypeId::of::<Quat>(), animate::<Quat>),
+            ],
+        }
+    }
+}
+
+impl AnimatorRegistry {
+    pub fn registry<T: Lerp + Blend + Clone + 'static>(&mut self) {
+        let ty = TypeId::of::<T>();
+        if self
+            .animate_functions
+            .iter()
+            .position(|(other, _)| *other == ty)
+            .is_some()
+        {
+            panic!("type '{}' already registered");
+        }
+
+        self.animate_functions.push((ty, animate::<T>))
+    }
+
+    pub fn index_of(&self, ty: TypeId) -> usize {
+        self.animate_functions
+            .iter()
+            .position(|(other, _)| *other == ty)
+            .unwrap_or(usize::MAX)
+    }
+}
+
+/// Helper trait to fetch components pointers
+trait Components {
+    fn get_mut(&mut self, index: usize) -> Option<*mut u8>;
+}
+
+impl<'a, 's, T: Send + Sync + 'static> Components for &'s mut [Option<Mut<'a, T>>] {
+    #[inline(always)]
+    fn get_mut(&mut self, index: usize) -> Option<*mut u8> {
+        self[index].as_mut().map(|c| &mut **c as *mut T as *mut u8)
+    }
+}
+
+#[inline(always)]
+fn animate<T: Lerp + Blend + Clone + 'static>(
+    components: &mut dyn Components,
+    entities_map: &[u16],
+    blend_group: &mut AnimatorBlendGroup,
+    keyframes: &mut [u16],
+    clip: &Clip,
+    time: f32,
+    w: f32,
+    prop_name: &str,
+    prop_type: TypeId,
+    prop_offset: isize,
+    prop_mask: u32,
+) -> bool {
+    if prop_type == TypeId::of::<T>() {
+        if let Some(curves) = clip
+            .get(prop_name)
+            .map(|curve_untyped| curve_untyped.downcast_ref::<T>())
+            .flatten()
+        {
+            for (entity_index, (curve_index, curve)) in curves.iter() {
+                let entity_index = entities_map[entity_index as usize] as usize;
+                if let Some(ref mut component) = components.get_mut(entity_index) {
+                    let kr = &mut keyframes[*curve_index];
+                    let (k, v) = curve.sample_indexed(*kr, time);
+                    *kr = k;
+
+                    // SAFETY: prop_offset is
+                    let value = unsafe { &mut *(component.offset(prop_offset) as *mut T) };
+                    value.blend(entity_index, prop_mask, blend_group, v, w);
+                }
+            }
+        }
+        true
+    } else {
+        false
+    }
+}
 
 #[derive(Default)]
 struct AnimatorDescriptorInner {
-    dynamic_properties: Vec<(String, TypeId, isize, u32)>,
+    dynamic_properties: Vec<(String, TypeId, usize, isize, u32)>,
 }
 
 // Defines how to animate the reflected type
@@ -39,41 +152,8 @@ fn shorten_name(n: &str) -> &str {
     n.rsplit("::").nth(0).unwrap_or(n)
 }
 
-// fn animate<T: Lerp + Blend + 'static>(
-//     prop_name: &str,
-//     prop_type: &TypeId,
-//     prop_offset: &usize,
-//     prop_mask: &u32,
-// ) {
-//     if *prop_type == TypeId::of::<T>() {
-//         if let Some(curves) = clip
-//             .get(prop_name)
-//             .map(|curve_untyped| curve_untyped.downcast_ref::<T>())
-//             .flatten()
-//         {
-//             for (entity_index, (curve_index, curve)) in curves.iter() {
-//                 let entity_index = entities_map[entity_index as usize] as usize;
-//                 if let Some(ref mut component) = components[entity_index] {
-//                     let kr = &mut keyframes[*curve_index];
-//                     let (k, v) = curve.sample_indexed(*kr, time);
-//                     *kr = k;
-
-//                     let value = unsafe {
-//                         &mut *(((&mut *component) as *mut _ as *mut u8).offset(*prop_offset)
-//                             as *mut T)
-//                     };
-
-//                     value.blend(entity_index, *prop_mask, &mut blend_group, v, w);
-//                 }
-//             }
-//         }
-//         true
-//     } else {
-//         false
-//     }
-// }
-
-pub fn animate_system<T: Struct + Component>(
+pub fn animate_system<T: Struct + Send + Sync + 'static>(
+    registry: Res<AnimatorRegistry>,
     mut descriptor: Local<AnimatorDescriptor<T>>,
     clips: Res<Assets<Clip>>,
     animators_query: Query<&Animator>,
@@ -81,8 +161,8 @@ pub fn animate_system<T: Struct + Component>(
     // handles_query: Query<&mut Handle<T>>,
     components_query: Query<&mut T>,
 ) {
-    // let __span = tracing::info_span!("animator_transform_update_system");
-    // let __guard = __span.enter();
+    let __span = tracing::info_span!("animator_transform_update_system");
+    let __guard = __span.enter();
 
     let mut components = vec![];
 
@@ -112,17 +192,21 @@ pub fn animate_system<T: Struct + Component>(
                 let short_name = shorten_name(c.type_name());
                 let origin = (&**c) as *const _ as *const u8;
                 for (i, value) in c.iter_fields().enumerate() {
-                    let mut n = short_name.to_string();
-                    n.push('.');
-                    n.push_str(c.name_at(i).unwrap());
+                    let mut name = short_name.to_string();
+                    name.push('.');
+                    name.push_str(c.name_at(i).unwrap());
                     let ty = value.type_id();
+
+                    // Find the animate function for the given type
+                    let index = registry.index_of(ty);
+
                     // SAFETY: Is be less than size_of::<T>() so it won't be crazy high
                     let offset =
                         unsafe { (value.any() as *const _ as *const u8).offset_from(origin) };
 
                     inner
                         .dynamic_properties
-                        .push((n, ty, offset, (1 << i) as u32));
+                        .push((name, ty, index, offset, (1 << i) as u32));
                 }
 
                 descriptor.inner = Some(inner);
@@ -139,6 +223,8 @@ pub fn animate_system<T: Struct + Component>(
             .animator_blending
             .begin_blending(components.len());
 
+        let mut components: Box<dyn Components> = Box::new(&mut components[..]);
+
         for (_, layer, clip_handle, entities_map) in animator.animate() {
             let w = layer.weight;
             if w < 1.0e-8 {
@@ -154,64 +240,33 @@ pub fn animate_system<T: Struct + Component>(
                 // is accessed by two different systems, which is possible but weird and will hit the performance a bit
                 let keyframes = unsafe { layer.keyframes_unsafe() };
 
-                for (prop_name, prop_type, prop_offset, prop_mask) in
+                for (prop_name, prop_type, prop_index, prop_offset, prop_mask) in
                     &descriptor_inner.dynamic_properties
                 {
-                    if *prop_type == TypeId::of::<Vec3>() {
-                        if let Some(curves) = clip
-                            .get(prop_name)
-                            .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
-                            .flatten()
-                        {
-                            for (entity_index, (curve_index, curve)) in curves.iter() {
-                                let entity_index = entities_map[entity_index as usize] as usize;
-                                if let Some(ref mut component) = components[entity_index] {
-                                    let kr = &mut keyframes[*curve_index];
-                                    let (k, v) = curve.sample_indexed(*kr, time);
-                                    *kr = k;
-
-                                    let value = unsafe {
-                                        &mut *(((&mut **component) as *mut _ as *mut u8)
-                                            .offset(*prop_offset)
-                                            as *mut Vec3)
-                                    };
-
-                                    value.blend(entity_index, *prop_mask, &mut blend_group, v, w);
-                                }
-                            }
-                        }
+                    if *prop_index == usize::MAX {
+                        // ? NOTE: Fetching missing properties will possible cause some slow down
+                        // // Try to look up the property once again
+                        // *prop_index = registry.index_of(*prop_type);
                         continue;
                     }
 
-                    if *prop_type == TypeId::of::<Quat>() {
-                        if let Some(curves) = clip
-                            .get(prop_name)
-                            .map(|curve_untyped| curve_untyped.downcast_ref::<Quat>())
-                            .flatten()
-                        {
-                            for (entity_index, (curve_index, curve)) in curves.iter() {
-                                let entity_index = entities_map[entity_index as usize] as usize;
-                                if let Some(ref mut component) = components[entity_index] {
-                                    let kr = &mut keyframes[*curve_index];
-                                    let (k, v) = curve.sample_indexed(*kr, time);
-                                    *kr = k;
-
-                                    let value = unsafe {
-                                        &mut *(((&mut **component) as *mut _ as *mut u8)
-                                            .offset(*prop_offset)
-                                            as *mut Quat)
-                                    };
-
-                                    value.blend(entity_index, *prop_mask, &mut blend_group, v, w);
-                                }
-                            }
-                        }
-                        continue;
-                    }
+                    (registry.animate_functions[*prop_index].1)(
+                        &mut *components,
+                        entities_map,
+                        &mut blend_group,
+                        keyframes,
+                        clip,
+                        time,
+                        w,
+                        prop_name,
+                        *prop_type,
+                        *prop_offset,
+                        *prop_mask,
+                    );
                 }
             }
         }
     }
 
-    // std::mem::drop(__guard);
+    std::mem::drop(__guard);
 }

From 91f5787e98e9ad534d035c3d05b76eba91d363b8 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sun, 27 Dec 2020 14:03:45 -0300
Subject: [PATCH 070/153] cleanup

---
 crates/bevy_animation/src/reflect.rs | 59 ++++++++++++----------------
 1 file changed, 26 insertions(+), 33 deletions(-)

diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index 7030a86eb7ab4..44283b35839d1 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -24,12 +24,11 @@ type AnimateFn = fn(
     time: f32,
     w: f32,
     prop_name: &str,
-    prop_type: TypeId,
     prop_offset: isize,
     prop_mask: u32,
-) -> bool;
+);
 
-/// Register how to animate basic types
+/// Register how to animate custom types
 pub struct AnimatorRegistry {
     animate_functions: Vec<(TypeId, AnimateFn)>,
 }
@@ -39,14 +38,15 @@ impl Default for AnimatorRegistry {
         Self {
             // Basic types
             animate_functions: vec![
-                (TypeId::of::<bool>(), animate::<f32>),
+                (TypeId::of::<bool>(), animate::<bool>),
                 (TypeId::of::<f32>(), animate::<f32>),
                 (TypeId::of::<Vec2>(), animate::<Vec2>),
                 (TypeId::of::<Vec3>(), animate::<Vec3>),
                 (TypeId::of::<Vec4>(), animate::<Vec4>),
+                (TypeId::of::<Quat>(), animate::<Quat>),
                 // (TypeId::of::<Color>(), animate::<Color>),
                 // (TypeId::of::<HandleUntyped>(), animate::<HandleUntyped>),
-                (TypeId::of::<Quat>(), animate::<Quat>),
+                // TODO: How to handle generic types like Handle<T> or Option<T>
             ],
         }
     }
@@ -87,7 +87,6 @@ impl<'a, 's, T: Send + Sync + 'static> Components for &'s mut [Option<Mut<'a, T>
     }
 }
 
-#[inline(always)]
 fn animate<T: Lerp + Blend + Clone + 'static>(
     components: &mut dyn Components,
     entities_map: &[u16],
@@ -97,32 +96,26 @@ fn animate<T: Lerp + Blend + Clone + 'static>(
     time: f32,
     w: f32,
     prop_name: &str,
-    prop_type: TypeId,
     prop_offset: isize,
     prop_mask: u32,
-) -> bool {
-    if prop_type == TypeId::of::<T>() {
-        if let Some(curves) = clip
-            .get(prop_name)
-            .map(|curve_untyped| curve_untyped.downcast_ref::<T>())
-            .flatten()
-        {
-            for (entity_index, (curve_index, curve)) in curves.iter() {
-                let entity_index = entities_map[entity_index as usize] as usize;
-                if let Some(ref mut component) = components.get_mut(entity_index) {
-                    let kr = &mut keyframes[*curve_index];
-                    let (k, v) = curve.sample_indexed(*kr, time);
-                    *kr = k;
-
-                    // SAFETY: prop_offset is
-                    let value = unsafe { &mut *(component.offset(prop_offset) as *mut T) };
-                    value.blend(entity_index, prop_mask, blend_group, v, w);
-                }
+) {
+    if let Some(curves) = clip
+        .get(prop_name)
+        .map(|curve_untyped| curve_untyped.downcast_ref::<T>())
+        .flatten()
+    {
+        for (entity_index, (curve_index, curve)) in curves.iter() {
+            let entity_index = entities_map[entity_index as usize] as usize;
+            if let Some(ref mut component) = components.get_mut(entity_index) {
+                let kr = &mut keyframes[*curve_index];
+                let (k, v) = curve.sample_indexed(*kr, time);
+                *kr = k;
+
+                // SAFETY: prop_offset is
+                let value = unsafe { &mut *(component.offset(prop_offset) as *mut T) };
+                value.blend(entity_index, prop_mask, blend_group, v, w);
             }
         }
-        true
-    } else {
-        false
     }
 }
 
@@ -240,17 +233,18 @@ pub fn animate_system<T: Struct + Send + Sync + 'static>(
                 // is accessed by two different systems, which is possible but weird and will hit the performance a bit
                 let keyframes = unsafe { layer.keyframes_unsafe() };
 
-                for (prop_name, prop_type, prop_index, prop_offset, prop_mask) in
+                for (prop_name, _prop_type, prop_index, prop_offset, prop_mask) in
                     &descriptor_inner.dynamic_properties
                 {
-                    if *prop_index == usize::MAX {
+                    let i = *prop_index;
+                    if i == usize::MAX {
                         // ? NOTE: Fetching missing properties will possible cause some slow down
                         // // Try to look up the property once again
                         // *prop_index = registry.index_of(*prop_type);
                         continue;
                     }
 
-                    (registry.animate_functions[*prop_index].1)(
+                    (registry.animate_functions[i].1)(
                         &mut *components,
                         entities_map,
                         &mut blend_group,
@@ -259,10 +253,9 @@ pub fn animate_system<T: Struct + Send + Sync + 'static>(
                         time,
                         w,
                         prop_name,
-                        *prop_type,
                         *prop_offset,
                         *prop_mask,
-                    );
+                    )
                 }
             }
         }

From dd69b75edd75a626614a9651cde8c62085f46cc0 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sun, 27 Dec 2020 14:44:24 -0300
Subject: [PATCH 071/153] cleanup and small changes

---
 crates/bevy_animation/src/reflect.rs | 38 ++++++++++++++++++++++------
 1 file changed, 30 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index 44283b35839d1..8e4e51fd3f5d8 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -6,10 +6,11 @@
 
 use std::{any::TypeId, marker::PhantomData};
 
-use bevy_asset::{prelude::*, Asset};
+use bevy_asset::prelude::*;
 use bevy_ecs::prelude::*;
 use bevy_math::prelude::*;
 use bevy_reflect::prelude::*;
+use tracing::warn;
 
 use crate::{
     blending::AnimatorBlendGroup, blending::Blend, lerping::Lerp, Animator, AnimatorBlending, Clip,
@@ -30,12 +31,14 @@ type AnimateFn = fn(
 
 /// Register how to animate custom types
 pub struct AnimatorRegistry {
+    ver: usize,
     animate_functions: Vec<(TypeId, AnimateFn)>,
 }
 
 impl Default for AnimatorRegistry {
     fn default() -> Self {
         Self {
+            ver: 0,
             // Basic types
             animate_functions: vec![
                 (TypeId::of::<bool>(), animate::<bool>),
@@ -46,6 +49,7 @@ impl Default for AnimatorRegistry {
                 (TypeId::of::<Quat>(), animate::<Quat>),
                 // (TypeId::of::<Color>(), animate::<Color>),
                 // (TypeId::of::<HandleUntyped>(), animate::<HandleUntyped>),
+                // (TypeId::of::<Handle<Mesh>>(), animate::<Handle<Mesh>>),
                 // TODO: How to handle generic types like Handle<T> or Option<T>
             ],
         }
@@ -64,9 +68,15 @@ impl AnimatorRegistry {
             panic!("type '{}' already registered");
         }
 
+        self.ver = self.ver.wrapping_add(1);
         self.animate_functions.push((ty, animate::<T>))
     }
 
+    /// Returns `usize::MAX` if the type wasn't registered,
+    ///
+    /// **NOTE** The index ranges from `0` to `usize::MAX - 1`,
+    /// which makes usize::MAX an invalid index thats why
+    /// this function doesn't return `Option<usize>`
     pub fn index_of(&self, ty: TypeId) -> usize {
         self.animate_functions
             .iter()
@@ -83,6 +93,7 @@ trait Components {
 impl<'a, 's, T: Send + Sync + 'static> Components for &'s mut [Option<Mut<'a, T>>] {
     #[inline(always)]
     fn get_mut(&mut self, index: usize) -> Option<*mut u8> {
+        // NOTE: Will trigger the `Changed` event to the right types
         self[index].as_mut().map(|c| &mut **c as *mut T as *mut u8)
     }
 }
@@ -119,8 +130,8 @@ fn animate<T: Lerp + Blend + Clone + 'static>(
     }
 }
 
-#[derive(Default)]
 struct AnimatorDescriptorInner {
+    ver: usize,
     dynamic_properties: Vec<(String, TypeId, usize, isize, u32)>,
 }
 
@@ -179,7 +190,10 @@ pub fn animate_system<T: Struct + Send + Sync + 'static>(
 
         if let Some(c) = components.iter().find_map(|c| c.as_ref()) {
             if descriptor.inner.is_none() {
-                let mut inner = AnimatorDescriptorInner::default();
+                let mut inner = AnimatorDescriptorInner {
+                    ver: registry.ver,
+                    dynamic_properties: vec![],
+                };
 
                 // Lazy initialize the descriptor
                 let short_name = shorten_name(c.type_name());
@@ -192,6 +206,9 @@ pub fn animate_system<T: Struct + Send + Sync + 'static>(
 
                     // Find the animate function for the given type
                     let index = registry.index_of(ty);
+                    if index == usize::MAX {
+                        warn!("missing animation function for `{}`", &name);
+                    }
 
                     // SAFETY: Is be less than size_of::<T>() so it won't be crazy high
                     let offset =
@@ -200,6 +217,8 @@ pub fn animate_system<T: Struct + Send + Sync + 'static>(
                     inner
                         .dynamic_properties
                         .push((name, ty, index, offset, (1 << i) as u32));
+
+                    // TODO: Expand type if possible
                 }
 
                 descriptor.inner = Some(inner);
@@ -210,12 +229,17 @@ pub fn animate_system<T: Struct + Send + Sync + 'static>(
         }
 
         let descriptor = &mut *descriptor;
-        let descriptor_inner = descriptor.inner.as_ref().unwrap();
+        let descriptor_inner = descriptor.inner.as_mut().unwrap();
+
+        if descriptor_inner.ver != registry.ver {
+            // TODO: Lookup missing animate functions because `AnimatorRegistry` changed
+        }
 
         let mut blend_group = descriptor
             .animator_blending
             .begin_blending(components.len());
 
+        // Alias `T`
         let mut components: Box<dyn Components> = Box::new(&mut components[..]);
 
         for (_, layer, clip_handle, entities_map) in animator.animate() {
@@ -233,14 +257,12 @@ pub fn animate_system<T: Struct + Send + Sync + 'static>(
                 // is accessed by two different systems, which is possible but weird and will hit the performance a bit
                 let keyframes = unsafe { layer.keyframes_unsafe() };
 
-                for (prop_name, _prop_type, prop_index, prop_offset, prop_mask) in
+                for (prop_name, _, prop_index, prop_offset, prop_mask) in
                     &descriptor_inner.dynamic_properties
                 {
                     let i = *prop_index;
                     if i == usize::MAX {
-                        // ? NOTE: Fetching missing properties will possible cause some slow down
-                        // // Try to look up the property once again
-                        // *prop_index = registry.index_of(*prop_type);
+                        // Missing animation function
                         continue;
                     }
 

From b9003d1956260772a680fb34915be6c513493f15 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sun, 27 Dec 2020 20:18:43 -0300
Subject: [PATCH 072/153] evaluating missing functionality

---
 crates/bevy_animation/src/reflect.rs | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index 8e4e51fd3f5d8..985d87fd12799 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -1,8 +1,4 @@
 //! Generic animation for any type that implements the `Reflect` trait
-//!
-//! This will never be as fast as the code gen approach but it will give
-//! a nice way of provide animation to external types or even to types derived
-//! from scrips!
 
 use std::{any::TypeId, marker::PhantomData};
 
@@ -16,6 +12,15 @@ use crate::{
     blending::AnimatorBlendGroup, blending::Blend, lerping::Lerp, Animator, AnimatorBlending, Clip,
 };
 
+// TODO: How to deal with generic types like Handle<T> or Option<T>
+// TODO: How implement safe property path `Transforms::props().translation().x()`
+// TODO: Property validation tells if some property (path and type) is or isn't valid
+// TODO: Animate assets
+// TODO: Make sure properties are within component size bounds
+// TODO: Accept also `TupleStruct` and `Value`
+// TODO: Expand types like Vec2, Vec3, Vec4 and Color
+// ! FIXME: Vec2, Vec3, Vec4 doesn't implement bevy_reflect::Struct so they can't be auto expanded
+
 type AnimateFn = fn(
     components: &mut dyn Components,
     entities_map: &[u16],
@@ -65,7 +70,7 @@ impl AnimatorRegistry {
             .position(|(other, _)| *other == ty)
             .is_some()
         {
-            panic!("type '{}' already registered");
+            panic!("type '{}' already registered", std::any::type_name::<T>());
         }
 
         self.ver = self.ver.wrapping_add(1);
@@ -134,7 +139,6 @@ struct AnimatorDescriptorInner {
     ver: usize,
     dynamic_properties: Vec<(String, TypeId, usize, isize, u32)>,
 }
-
 // Defines how to animate the reflected type
 pub struct AnimatorDescriptor<T> {
     inner: Option<AnimatorDescriptorInner>,
@@ -217,8 +221,6 @@ pub fn animate_system<T: Struct + Send + Sync + 'static>(
                     inner
                         .dynamic_properties
                         .push((name, ty, index, offset, (1 << i) as u32));
-
-                    // TODO: Expand type if possible
                 }
 
                 descriptor.inner = Some(inner);
@@ -232,7 +234,12 @@ pub fn animate_system<T: Struct + Send + Sync + 'static>(
         let descriptor_inner = descriptor.inner.as_mut().unwrap();
 
         if descriptor_inner.ver != registry.ver {
-            // TODO: Lookup missing animate functions because `AnimatorRegistry` changed
+            // Lookup missing animate functions because `AnimatorRegistry` changed
+            for (_, prop_type, prop_index, _, _) in &mut descriptor_inner.dynamic_properties {
+                if *prop_index == usize::MAX {
+                    *prop_index = registry.index_of(*prop_type);
+                }
+            }
         }
 
         let mut blend_group = descriptor

From fd5da144be6729c64d923a0edbc1ea56b5329a45 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Mon, 28 Dec 2020 00:26:17 -0300
Subject: [PATCH 073/153] polishing the reflect implementation

---
 crates/bevy_animation/src/app.rs     |  55 +--
 crates/bevy_animation/src/custom.rs  | 202 +++--------
 crates/bevy_animation/src/impls.rs   | 511 ---------------------------
 crates/bevy_animation/src/lib.rs     |  14 +-
 crates/bevy_animation/src/props.rs   |  54 +++
 crates/bevy_animation/src/reflect.rs | 127 ++++---
 6 files changed, 189 insertions(+), 774 deletions(-)
 delete mode 100644 crates/bevy_animation/src/impls.rs
 create mode 100644 crates/bevy_animation/src/props.rs

diff --git a/crates/bevy_animation/src/app.rs b/crates/bevy_animation/src/app.rs
index 06ac713ea9d21..5b07649404311 100644
--- a/crates/bevy_animation/src/app.rs
+++ b/crates/bevy_animation/src/app.rs
@@ -3,65 +3,36 @@ use bevy_ecs::prelude::*;
 use bevy_reflect::prelude::*;
 use std::{
     any::{type_name, TypeId},
+    borrow::Cow,
     mem::drop,
 };
 
-use crate::{
-    custom::{AnimatedAsset, AnimatedComponent, AnimatorRegistry},
-    reflect, stage,
-};
+use crate::{custom::AnimatorRegistry, reflect, stage};
 
 pub trait AddAnimated {
-    fn register_animated_component<T: AnimatedComponent>(&mut self) -> &mut Self;
-
-    fn register_animated_asset<T: AnimatedAsset>(&mut self) -> &mut Self;
-
-    fn register_animated<T: Struct + Component>(&mut self) -> &mut Self;
+    fn register_animated_component<T: Default + Struct + Component>(&mut self) -> &mut Self;
 }
 
 impl AddAnimated for AppBuilder {
-    fn register_animated_component<T: AnimatedComponent>(&mut self) -> &mut Self {
+    fn register_animated_component<T: Default + Struct + Component>(&mut self) -> &mut Self {
         let mut registry = self
             .resources_mut()
             .get_or_insert_with(AnimatorRegistry::default);
 
         if registry.targets.insert(TypeId::of::<T>()) {
-            registry.static_properties.extend(T::PROPERTIES.iter());
-            drop(registry);
-
-            self.add_system_to_stage(stage::ANIMATE, T::animator_update_system);
-            self
-        } else {
-            panic!("animator already registered for '{}'", type_name::<T>());
-        }
-    }
+            let component = T::default();
+            let descriptor = reflect::AnimatorDescriptor::<T>::from_component(&component);
 
-    fn register_animated_asset<T: AnimatedAsset>(&mut self) -> &mut Self {
-        let mut registry = self
-            .resources_mut()
-            .get_or_insert_with(AnimatorRegistry::default);
+            registry.static_properties.extend(
+                descriptor
+                    .properties()
+                    .map(|(name, type_id)| (Cow::Owned(name.to_string()), type_id)),
+            );
 
-        if registry.targets.insert(TypeId::of::<T>()) {
-            registry.static_properties.extend(T::PROPERTIES.iter());
-            drop(registry);
-
-            self.add_system_to_stage(stage::ANIMATE, T::animator_update_system);
-            self
-        } else {
-            panic!("animator already registered for '{}'", type_name::<T>());
-        }
-    }
-
-    fn register_animated<T: Struct + Component>(&mut self) -> &mut Self {
-        let mut registry = self
-            .resources_mut()
-            .get_or_insert_with(AnimatorRegistry::default);
-
-        if registry.targets.insert(TypeId::of::<T>()) {
-            // registry.static_properties.extend(T::PROPERTIES.iter());
             drop(registry);
 
-            self.add_system_to_stage(stage::ANIMATE, reflect::animate_system::<T>);
+            self.add_resource(descriptor);
+            self.add_system_to_stage(stage::ANIMATE, reflect::animate_component_system::<T>);
             self
         } else {
             panic!("animator already registered for '{}'", type_name::<T>());
diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/custom.rs
index 5cf8bdf5161d2..7493ad9642b01 100644
--- a/crates/bevy_animation/src/custom.rs
+++ b/crates/bevy_animation/src/custom.rs
@@ -1,19 +1,19 @@
+use std::{
+    any::Any,
+    any::TypeId,
+    borrow::Cow,
+    collections::{HashMap, HashSet},
+};
+
 use anyhow::Result;
 use bevy_app::prelude::{EventReader, Events};
-use bevy_asset::{Asset, AssetEvent, Assets, Handle};
+use bevy_asset::{AssetEvent, Assets, Handle};
 use bevy_core::prelude::*;
 use bevy_ecs::prelude::*;
 use bevy_reflect::{Reflect, ReflectComponent, TypeUuid};
 use bevy_transform::prelude::*;
 use fnv::FnvBuildHasher;
 use smallvec::{smallvec, SmallVec};
-use std::{
-    any::Any,
-    any::TypeId,
-    borrow::Cow,
-    collections::{HashMap, HashSet},
-    marker::PhantomData,
-};
 use tracing::warn;
 
 use crate::blending::AnimatorBlending;
@@ -73,6 +73,7 @@ impl<T> Curves<T> {
 pub struct CurvesUntyped {
     /// Cached calculated curves duration
     duration: f32,
+    type_id: TypeId,
     untyped: Box<dyn Any + Send + Sync + 'static>,
 }
 
@@ -80,12 +81,16 @@ impl CurvesUntyped {
     fn new<T: Send + Sync + 'static>(curves: Curves<T>) -> Self {
         CurvesUntyped {
             duration: curves.calculate_duration(),
+            type_id: TypeId::of::<T>(),
             untyped: Box::new(curves),
         }
     }
 
-    #[inline(always)]
-    pub fn duration(&self) -> f32 {
+    pub const fn type_id(&self) -> TypeId {
+        self.type_id
+    }
+
+    pub const fn duration(&self) -> f32 {
         self.duration
     }
 
@@ -164,82 +169,27 @@ impl Default for Clip {
     }
 }
 
-/// A type safe way of referring to properties that can be animated.
-///
-/// If a type implements `AnimatedProperties` each property can be retrieved
-/// by `Transform::props().translation().x()`
-pub struct Prop<CurveType, InnerProps = ()> {
-    pub name: Cow<'static, str>,
-    _marker: PhantomData<(CurveType, InnerProps)>,
-}
-
-impl<CurveType, InnerProps> Prop<CurveType, InnerProps> {
-    pub const fn borrowed(name: &'static str) -> Self {
-        Prop {
-            name: Cow::Borrowed(name),
-            _marker: PhantomData,
-        }
-    }
-
-    pub const fn owned(name: String) -> Self {
-        Prop {
-            name: Cow::Owned(name),
-            _marker: PhantomData,
-        }
-    }
-}
-
-// TODO: How to implement this
-// impl<CurveType, InnerProps> Deref for Prop<CurveType, InnerProps> {
-//     type Target = InnerProps;
-//
-//     fn deref(&self) -> &Self::Target {
-//         todo!()
-//     }
-// }
-
 impl Clip {
-    /// Animates an entity property with a curve.
-    /// Adding the a second curve to the same entity and property will replace the first one;
-    /// This is the preferred method of adding curves into a clip, since it's better future proof than `add_curve_at_path`;
+    /// Property to be animated must be in the following format `"path/to/named_entity@Transform.translation.x"`
+    /// where the left side `@` defines a path to the entity to animate,
+    /// while the right side the path to a property to animate starting from the component.
+    ///
+    /// Please use preferably `add_curve` as it's future proof and type safe;
     ///
     /// **NOTE** This is a expensive function;
     ///
     /// **NOTE** You can safely ignore the return value as it's only used for assertions during tests;
     /// The return value is the assigned curve index in cache line bucket.
-    pub fn add_curve<T, DontCare>(
-        &mut self,
-        entity_path: &str,
-        property_path: Prop<T, DontCare>,
-        curve: Curve<T>,
-    ) -> usize
+    pub fn add_curve_at_path<T>(&mut self, path: &str, mut curve: Curve<T>) -> usize
     where
         T: Lerp + Clone + Send + Sync + 'static,
     {
-        // ? NOTE: DontCare generic will trigger multiple compilations of the `add_prop`
-        // ? function, here convert between types to make it generic only over `T`
-        self.add_curve_generic(
-            entity_path,
-            Prop {
-                name: property_path.name,
-                _marker: PhantomData,
-            },
-            curve,
-        )
-    }
+        // Split in entity and attribute path,
+        // NOTE: use rfind because it's expected the latter to be generally shorter
+        let path = path.split_at(path.rfind('@').expect("property path missing @"));
+        let entity_path = path.0;
+        let property_path = path.1.split_at(1).1;
 
-    // TODO: Can I make it generic over `T` ?
-    /// Used only by `add_prop` function and it's main purpose is prevent
-    /// create multiple versions of this function over the DontCare generic  
-    fn add_curve_generic<T>(
-        &mut self,
-        entity_path: &str, // TODO: Replace to `EntityPath` or something similar to Prop
-        property_path: Prop<T>,
-        mut curve: Curve<T>,
-    ) -> usize
-    where
-        T: Lerp + Clone + Send + Sync + 'static,
-    {
         // Clip an only have some amount of curves and entities
         // this limitation was added to save memory (but you can increase it if you want)
         assert!(
@@ -249,9 +199,7 @@ impl Clip {
 
         let (entity_index, _) = self.hierarchy.get_or_insert_entity(entity_path);
 
-        if let Some((cache_index, curves_untyped)) =
-            self.properties.get_mut(property_path.name.as_ref())
-        {
+        if let Some((cache_index, curves_untyped)) = self.properties.get_mut(property_path) {
             let curves = curves_untyped
                 .downcast_mut::<T>()
                 .expect("properties can't have the same name and different curve types");
@@ -311,10 +259,7 @@ impl Clip {
 
         self.duration = self.duration.max(curve.duration());
         self.properties.insert(
-            match property_path.name {
-                Cow::Borrowed(name) => name.to_string(),
-                Cow::Owned(name) => name,
-            },
+            property_path.to_string(),
             (
                 cache_index,
                 CurvesUntyped::new(Curves {
@@ -327,28 +272,6 @@ impl Clip {
         cache_index
     }
 
-    /// Property to be animated must be in the following format `"path/to/named_entity@Transform.translation.x"`
-    /// where the left side `@` defines a path to the entity to animate,
-    /// while the right side the path to a property to animate starting from the component.
-    ///
-    /// Please use preferably `add_curve` as it's future proof and type safe;
-    ///
-    /// **NOTE** This is a expensive function;
-    ///
-    /// **NOTE** You can safely ignore the return value as it's only used for assertions during tests;
-    /// The return value is the assigned curve index in cache line bucket.
-    pub fn add_curve_at_path<T>(&mut self, path: &str, curve: Curve<T>) -> usize
-    where
-        T: Lerp + Clone + Send + Sync + 'static,
-    {
-        // Split in entity and attribute path,
-        // NOTE: use rfind because it's expected the latter to be generally shorter
-        let path = path.split_at(path.rfind('@').expect("property path missing @"));
-        let property_path = path.1.split_at(1).1;
-
-        self.add_curve::<T, ()>(path.0, Prop::owned(property_path.to_string()), curve)
-    }
-
     /// Number of animated properties in this clip
     #[inline(always)]
     pub fn len(&self) -> usize {
@@ -599,9 +522,8 @@ impl<'a> Iterator for LayerIterator<'a> {
 pub(crate) struct AnimatorRegistry {
     /// Set of registered animators for components and assets
     pub(crate) targets: HashSet<TypeId, FnvBuildHasher>,
-    // TODO: Also include TypeId when it becomes stable in as as const fn
     /// All static properties available
-    pub(crate) static_properties: HashSet<&'static str, FnvBuildHasher>,
+    pub(crate) static_properties: HashSet<(Cow<'static, str>, TypeId), FnvBuildHasher>,
 }
 
 /// State info for the system `animator_binding_system`
@@ -758,14 +680,14 @@ pub(crate) fn animator_update_system(
                 if bind_slot.is_none() {
                     // TODO: Add option to ignore these extra checks (or not)
                     // Check if the clips properties are registered
-                    for (property_name, _) in clip.properties.iter() {
+                    for (property_name, (_, curves)) in clip.properties.iter() {
                         if !animator_registry
                             .static_properties
-                            .contains(property_name.as_str())
+                            .contains(&(Cow::Borrowed(property_name.as_str()), curves.type_id()))
                         {
                             // TODO: Check dynamic properties names using regex
                             // TODO: Include clip name on warning
-                            warn!("property '{}' isn't registered", property_name);
+                            warn!("unregistered property '{}', maybe it's misspelled or the type doesn't match", &property_name);
                         }
                     }
 
@@ -839,44 +761,6 @@ pub(crate) fn animator_update_system(
     std::mem::drop(__guard);
 }
 
-// ! FIXME: Theres no way of free memory used by the `Local<AnimatorBlending>` in each system
-
-/// Provides a type safe way of get all properties that can be animated
-pub trait AnimatedProperties {
-    type Props;
-
-    // TODO: Also include TypeId when it becomes stable in as as const fn
-    /// List of all animated properties, is used to search invalid properties in clips
-    const PROPERTIES: &'static [&'static str];
-    /// Similar to `PROPERTIES` but contains a regex to validate dynamic properties
-    ///
-    /// **NOTE** Use sparelly, as it's more expensive to validate
-    const DYNAMIC_PROPERTIES: &'static [&'static str] = &[];
-
-    /// Type safe animated properties of this component or asset;
-    /// Meant to be used only by code, to be type safe and future proof way of defining properties.
-    fn props() -> Self::Props;
-}
-
-pub trait AnimatedComponent: AnimatedProperties + Component + Sized {
-    fn animator_update_system(
-        clips: Res<Assets<Clip>>,
-        animator_blending: Local<AnimatorBlending>,
-        animators_query: Query<&Animator>,
-        component_query: Query<&mut Self>,
-    );
-}
-
-pub trait AnimatedAsset: AnimatedProperties + Asset + Sized {
-    fn animator_update_system(
-        clips: Res<Assets<Clip>>,
-        animator_blending: Local<AnimatorBlending>,
-        animators_query: Query<&Animator>,
-        assets: ResMut<Assets<Self>>,
-        component_query: Query<&mut Handle<Self>>,
-    );
-}
-
 #[cfg(test)]
 #[allow(dead_code)]
 mod tests {
@@ -916,20 +800,18 @@ mod tests {
             let mut animator = Animator::default();
             {
                 let mut clip_a = Clip::default();
-                clip_a.add_curve(
-                    "",
-                    Transform::props().translation(),
+                clip_a.add_curve_at_path(
+                    "@Transform.translation",
                     Curve::from_linear(0.0, 1.0, Vec3::unit_x(), -Vec3::unit_x()),
                 );
                 let rot = Curve::from_constant(Quat::identity());
-                clip_a.add_curve("", Transform::props().rotation(), rot.clone());
-                clip_a.add_curve("/Node1", Transform::props().rotation(), rot.clone());
-                clip_a.add_curve("/Node1/Node2", Transform::props().rotation(), rot);
+                clip_a.add_curve_at_path("@Transform.rotation", rot.clone());
+                clip_a.add_curve_at_path("/Node1@Transform.rotation", rot.clone());
+                clip_a.add_curve_at_path("/Node1/Node2@Transform.rotation", rot);
 
                 let mut clip_b = Clip::default();
-                clip_b.add_curve(
-                    "",
-                    Transform::props().translation(),
+                clip_b.add_curve_at_path(
+                    "@Transform.translation",
                     Curve::from_constant(Vec3::zero()),
                 );
                 let rot = Curve::from_linear(
@@ -938,9 +820,9 @@ mod tests {
                     Quat::from_axis_angle(Vec3::unit_z(), 0.1),
                     Quat::from_axis_angle(Vec3::unit_z(), -0.1),
                 );
-                clip_b.add_curve("", Transform::props().rotation(), rot.clone());
-                clip_b.add_curve("/Node1", Transform::props().rotation(), rot.clone());
-                clip_b.add_curve("/Node1/Node2", Transform::props().rotation(), rot);
+                clip_b.add_curve_at_path("@Transform.rotation", rot.clone());
+                clip_b.add_curve_at_path("/Node1@Transform.rotation", rot.clone());
+                clip_b.add_curve_at_path("/Node1/Node2@Transform.rotation", rot);
 
                 let mut clips = app_builder
                     .resources_mut()
diff --git a/crates/bevy_animation/src/impls.rs b/crates/bevy_animation/src/impls.rs
deleted file mode 100644
index ca48a04eb0bf6..0000000000000
--- a/crates/bevy_animation/src/impls.rs
+++ /dev/null
@@ -1,511 +0,0 @@
-use crate::{self as bevy_animation};
-use crate::{
-    blending::{AnimatorBlending, Blend},
-    custom::*,
-    lerping::Lerp,
-};
-use bevy_animation_derive::*;
-use bevy_asset::{Assets, Handle};
-use bevy_ecs::prelude::*;
-use bevy_math::prelude::*;
-use bevy_pbr::prelude::{Light, StandardMaterial};
-use bevy_render::{
-    camera::{OrthographicProjection, PerspectiveProjection},
-    mesh::Mesh,
-    prelude::{Color, Texture, Visible},
-};
-use bevy_transform::prelude::*;
-
-pub struct TransformTranslationProps;
-
-impl Prop<Vec3, TransformTranslationProps> {
-    pub const fn x(&self) -> Prop<f32> {
-        Prop::borrowed("Transform.translation.x")
-    }
-
-    pub const fn y(&self) -> Prop<f32> {
-        Prop::borrowed("Transform.translation.y")
-    }
-
-    pub const fn z(&self) -> Prop<f32> {
-        Prop::borrowed("Transform.translation.z")
-    }
-}
-
-impl std::ops::Deref for Prop<Vec3, TransformTranslationProps> {
-    type Target = TransformTranslationProps;
-
-    #[inline(always)]
-    fn deref(&self) -> &Self::Target {
-        &TransformTranslationProps
-    }
-}
-
-pub struct TransformProps;
-
-impl TransformProps {
-    pub const fn translation(&self) -> Prop<Vec3, TransformTranslationProps> {
-        Prop::borrowed("Transform.translation")
-    }
-
-    pub const fn rotation(&self) -> Prop<Quat> {
-        Prop::borrowed("Transform.rotation")
-    }
-
-    pub const fn scale(&self) -> Prop<Vec3> {
-        Prop::borrowed("Transform.scale")
-    }
-}
-
-impl AnimatedProperties for Transform {
-    type Props = TransformProps;
-
-    const PROPERTIES: &'static [&'static str] = &[
-        "Transform.translation",
-        "Transform.translation.x",
-        "Transform.translation.y",
-        "Transform.translation.z",
-        "Transform.rotation",
-        "Transform.scale",
-        // "Transform.scale.x",
-        // "Transform.scale.y",
-        // "Transform.scale.z",
-    ];
-
-    #[inline(always)]
-    fn props() -> Self::Props {
-        TransformProps
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-// impl AnimatedComponent for Transform {
-//     fn animator_update_system(
-//         clips: Res<Assets<Clip>>,
-//         mut animator_blending: Local<AnimatorBlending>,
-//         animators_query: Query<&Animator>,
-//         component_query: Query<&mut Self>,
-//     ) {
-//         let __span = tracing::info_span!("animator_transform_update_system");
-//         let __guard = __span.enter();
-
-//         let mut components = vec![];
-
-//         for animator in animators_query.iter() {
-//             components.clear();
-
-//             // ? NOTE: Lazy get each component is worse than just fetching everything at once
-//             // Pre-fetch all transforms to avoid calling get_mut multiple times
-//             // SAFETY: each component will be updated one at the time and this function
-//             // currently has the mutability over the Transform type, so no race conditions
-//             // are possible
-//             unsafe {
-//                 for entity in animator.entities() {
-//                     components.push(
-//                         entity
-//                             .map(|entity| component_query.get_unsafe(entity).ok())
-//                             .flatten(),
-//                     );
-//                 }
-//             }
-
-//             let mut blend_group = animator_blending.begin_blending(components.len());
-
-//             // Bit fields
-//             const TRANSLATE_X: u32 = 1;
-//             const TRANSLATE_Y: u32 = 2;
-//             const TRANSLATE_Z: u32 = 4;
-//             const ROTATION: u32 = 8;
-//             const SCALE: u32 = 16;
-
-//             for (_, layer, clip_handle, entities_map) in animator.animate() {
-//                 let w = layer.weight;
-//                 if w < 1.0e-8 {
-//                     continue;
-//                 }
-
-//                 if let Some(clip) = clips.get(clip_handle) {
-//                     let time = layer.time;
-
-//                     // SAFETY: Never a different thread will modify or access the same index as this one;
-//                     // Plus as a nice and crazy feature each property is grouped by name into their own cache line
-//                     // buckets, this way no cache line will be accessed by the same thread unless the same property
-//                     // is accessed by two different systems, which is possible but weird and will hit the performance a bit
-//                     let keyframes = unsafe { layer.keyframes_unsafe() };
-
-//                     if let Some(curves) = clip
-//                         .get("Transform.translation")
-//                         .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
-//                         .flatten()
-//                     {
-//                         for (entity_index, (curve_index, curve)) in curves.iter() {
-//                             let entity_index = entities_map[entity_index as usize] as usize;
-//                             if let Some(ref mut component) = components[entity_index] {
-//                                 let kr = &mut keyframes[*curve_index];
-//                                 let (k, v) = curve.sample_indexed(*kr, time);
-//                                 *kr = k;
-//                                 // ? NOTE: Blend must be done for each component in order for it to work
-//                                 component.translation.x.blend(
-//                                     entity_index,
-//                                     TRANSLATE_X,
-//                                     &mut blend_group,
-//                                     v.x,
-//                                     w,
-//                                 );
-//                                 component.translation.y.blend(
-//                                     entity_index,
-//                                     TRANSLATE_Y,
-//                                     &mut blend_group,
-//                                     v.y,
-//                                     w,
-//                                 );
-//                                 component.translation.z.blend(
-//                                     entity_index,
-//                                     TRANSLATE_Z,
-//                                     &mut blend_group,
-//                                     v.z,
-//                                     w,
-//                                 );
-//                             }
-//                         }
-//                     } else {
-//                         if let Some(curves) = clip
-//                             .get("Transform.translation.x")
-//                             .map(|curve_untyped| curve_untyped.downcast_ref::<f32>())
-//                             .flatten()
-//                         {
-//                             for (entity_index, (curve_index, curve)) in curves.iter() {
-//                                 let entity_index = entities_map[entity_index as usize] as usize;
-//                                 if let Some(ref mut component) = components[entity_index] {
-//                                     let kr = &mut keyframes[*curve_index];
-//                                     let (k, v) = curve.sample_indexed(*kr, time);
-//                                     *kr = k;
-//                                     component.translation.x.blend(
-//                                         entity_index,
-//                                         TRANSLATE_X,
-//                                         &mut blend_group,
-//                                         v,
-//                                         w,
-//                                     );
-//                                 }
-//                             }
-//                         }
-
-//                         if let Some(curves) = clip
-//                             .get("Transform.translation.y")
-//                             .map(|curve_untyped| curve_untyped.downcast_ref::<f32>())
-//                             .flatten()
-//                         {
-//                             for (entity_index, (curve_index, curve)) in curves.iter() {
-//                                 let entity_index = entities_map[entity_index as usize] as usize;
-//                                 if let Some(ref mut component) = components[entity_index] {
-//                                     let kr = &mut keyframes[*curve_index];
-//                                     let (k, v) = curve.sample_indexed(*kr, time);
-//                                     *kr = k;
-//                                     component.translation.y.blend(
-//                                         entity_index,
-//                                         TRANSLATE_Y,
-//                                         &mut blend_group,
-//                                         v,
-//                                         w,
-//                                     );
-//                                 }
-//                             }
-//                         }
-
-//                         if let Some(curves) = clip
-//                             .get("Transform.translation.z")
-//                             .map(|curve_untyped| curve_untyped.downcast_ref::<f32>())
-//                             .flatten()
-//                         {
-//                             for (entity_index, (curve_index, curve)) in curves.iter() {
-//                                 let entity_index = entities_map[entity_index as usize] as usize;
-//                                 if let Some(ref mut component) = components[entity_index] {
-//                                     let kr = &mut keyframes[*curve_index];
-//                                     let (k, v) = curve.sample_indexed(*kr, time);
-//                                     *kr = k;
-//                                     component.translation.z.blend(
-//                                         entity_index,
-//                                         TRANSLATE_Z,
-//                                         &mut blend_group,
-//                                         v,
-//                                         w,
-//                                     );
-//                                 }
-//                             }
-//                         }
-//                     }
-
-//                     if let Some(curves) = clip
-//                         .get("Transform.rotation")
-//                         .map(|curve_untyped| curve_untyped.downcast_ref::<Quat>())
-//                         .flatten()
-//                     {
-//                         for (entity_index, (curve_index, curve)) in curves.iter() {
-//                             let entity_index = entities_map[entity_index as usize] as usize;
-//                             if let Some(ref mut component) = components[entity_index] {
-//                                 let kr = &mut keyframes[*curve_index];
-//                                 let (k, v) = curve.sample_indexed(*kr, time);
-//                                 *kr = k;
-//                                 component.rotation.blend(
-//                                     entity_index,
-//                                     ROTATION,
-//                                     &mut blend_group,
-//                                     v,
-//                                     w,
-//                                 );
-//                             }
-//                         }
-//                     }
-
-//                     // TODO: Euler rotation support?
-
-//                     if let Some(curves) = clip
-//                         .get("Transform.scale")
-//                         .map(|curve_untyped| curve_untyped.downcast_ref::<Vec3>())
-//                         .flatten()
-//                     {
-//                         for (entity_index, (curve_index, curve)) in curves.iter() {
-//                             let entity_index = entities_map[entity_index as usize] as usize;
-//                             if let Some(ref mut component) = components[entity_index] {
-//                                 let kr = &mut keyframes[*curve_index];
-//                                 let (k, v) = curve.sample_indexed(*kr, time);
-//                                 *kr = k;
-//                                 component
-//                                     .scale
-//                                     .blend(entity_index, SCALE, &mut blend_group, v, w);
-//                             }
-//                         }
-//                     }
-//                 }
-//             }
-//         }
-
-//         std::mem::drop(__guard);
-//     }
-// }
-
-// ///////////////////////////////////////////////////////////////////////////////
-
-// pub struct StandardMaterialProps;
-
-// impl StandardMaterialProps {
-//     pub const fn albedo(&self) -> Prop<Color> {
-//         Prop::borrowed("Handle<StandardMaterial>.albedo")
-//     }
-
-//     pub const fn albedo_texture(&self) -> Prop<Option<Handle<Texture>>> {
-//         Prop::borrowed("Handle<StandardMaterial>.albedo_texture")
-//     }
-// }
-
-// pub struct HandleStandardMaterialProps;
-
-// impl HandleStandardMaterialProps {
-//     pub const fn handle(&self) -> Prop<Handle<StandardMaterial>> {
-//         Prop::borrowed("Handle<StandardMaterial>")
-//     }
-
-//     pub const fn fields(&self) -> StandardMaterialProps {
-//         StandardMaterialProps
-//     }
-// }
-
-// impl AnimatedProperties for StandardMaterial {
-//     type Props = HandleStandardMaterialProps;
-
-//     const PROPERTIES: &'static [&'static str] = &[];
-
-//     fn props() -> Self::Props {
-//         HandleStandardMaterialProps
-//     }
-// }
-
-// ///////////////////////////////////////////////////////////////////////////////
-
-// impl AnimatedAsset for StandardMaterial {
-//     fn animator_update_system(
-//         clips: Res<Assets<Clip>>,
-//         mut animator_blending: Local<AnimatorBlending>,
-//         animators_query: Query<&Animator>,
-//         mut assets: ResMut<Assets<Self>>,
-//         component_query: Query<&mut Handle<Self>>,
-//     ) {
-//         let __span = tracing::info_span!("animator_standard_material_update_system");
-//         let __guard = __span.enter();
-
-//         let mut components = vec![];
-
-//         for animator in animators_query.iter() {
-//             let mut blend_group = animator_blending.begin_blending();
-
-//             for (_, layer, clip_handle, entities_map) in animator.animate() {
-//                 let w = layer.weight;
-//                 if w < 1.0e-8 {
-//                     continue;
-//                 }
-
-//                 components.clear();
-
-//                 // TODO: Test performance with lazy component fetch
-//                 // SAFETY: each component will be updated one at the time and this function
-//                 // currently has the mutability over the Transform type, so no race conditions
-//                 // are possible
-//                 unsafe {
-//                     for entity in animator.entities() {
-//                         components.push(
-//                             entity
-//                                 .map(|entity| component_query.get_unsafe(entity).ok())
-//                                 .flatten(),
-//                         );
-//                     }
-//                 }
-
-//                 if let Some(clip) = clips.get(clip_handle) {
-//                     let time = layer.time;
-
-//                     // SAFETY: Never a different thread will modify or access the same index as this one;
-//                     // Plus as a nice and crazy feature each property is grouped by name into their own cache line
-//                     // buckets, this way no cache line will be accessed by the same thread unless the same property
-//                     // is accessed by two different systems, which is possible but weird and will hit the performance a bit
-//                     let keyframes = unsafe { layer.keyframes_unsafe() };
-
-//                     // Replace the material handle
-//                     if let Some(curves) = clip
-//                         .get("Handle<StandardMaterial>")
-//                         .map(|curve_untyped| {
-//                             curve_untyped.downcast_ref::<Handle<StandardMaterial>>()
-//                         })
-//                         .flatten()
-//                     {
-//                         for (entity_index, (curve_index, curve)) in curves.iter() {
-//                             let entity_index = entities_map[entity_index as usize];
-
-//                             if let Some(ref mut component) = components[entity_index as usize] {
-//                                 let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
-//                                 keyframes[*curve_index] = k;
-//                                 component.blend(&mut blend_group, v, w);
-//                             }
-//                         }
-//                     }
-
-//                     // Change asset properties
-
-//                     if let Some(curves) = clip
-//                         .get("Handle<StandardMaterial>.albedo")
-//                         .map(|curve_untyped| curve_untyped.downcast_ref::<Color>())
-//                         .flatten()
-//                     {
-//                         for (entity_index, (curve_index, curve)) in curves.iter() {
-//                             let entity_index = entities_map[entity_index as usize];
-
-//                             if let Some(ref component) = components[entity_index as usize] {
-//                                 if let Some(asset) = assets.get_mut(&**component) {
-//                                     let (k, v) =
-//                                         curve.sample_indexed(keyframes[*curve_index], time);
-//                                     keyframes[*curve_index] = k;
-//                                     asset.albedo.blend(&mut blend_group, v, w);
-//                                 }
-//                             }
-//                         }
-//                     }
-
-//                     if let Some(curves) = clip
-//                         .get("Handle<StandardMaterial>.albedo_texture")
-//                         .map(|curve_untyped| {
-//                             curve_untyped.downcast_ref::<Option<Handle<Texture>>>()
-//                         })
-//                         .flatten()
-//                     {
-//                         for (entity_index, (curve_index, curve)) in curves.iter() {
-//                             let entity_index = entities_map[entity_index as usize];
-//                             if let Some(ref component) = components[entity_index as usize] {
-//                                 if let Some(asset) = assets.get_mut(&**component) {
-//                                     let (k, v) =
-//                                         curve.sample_indexed(keyframes[*curve_index], time);
-//                                     keyframes[*curve_index] = k;
-//                                     asset.albedo_texture.blend(&mut blend_group, v, w);
-//                                 }
-//                             }
-//                         }
-//                     }
-//                 }
-//             }
-//         }
-
-//         std::mem::drop(__guard);
-//     }
-// }
-
-///////////////////////////////////////////////////////////////////////////////
-
-// #[derive(Debug, AnimatedComponent)]
-// struct Test {
-//     #[animated(fields { x: f32, y: f32, z: f32 })]
-//     a: Vec3,
-//     b: Vec2,
-//     #[animated(ignore)]
-//     c: Vec3,
-// }
-
-// animated_component! {
-//     struct Transform {
-//         #[animated(fields(x: f32, y: f32, z: f32))]
-//         translation: Vec3,
-//         rotation: Quat,
-//         #[animated(fields(x: f32, y: f32, z: f32))]
-//         scale: Vec3,
-//     }
-// }
-
-// animated_asset! {
-//     struct StandardMaterial {
-//         albedo: Color,
-//         albedo_texture: Option<Handle<Texture>>,
-//     }
-// }
-
-// animated_asset! {
-//     struct Sprite {}
-// }
-
-// animated_asset! {
-//     struct Mesh {}
-// }
-
-// animated_component! {
-//     struct Visible {
-//         is_visible: bool,
-//     }
-// }
-
-// animated_component! {
-//     struct Light {
-//         color: Color,
-//         fov: f32,
-//         #[animated(ignore, fields(start: f32, end: f32))]
-//         depth: Range<f32>,
-//     }
-// }
-
-// animated_component! {
-//     struct PerspectiveProjection {
-//         fov: f32,
-//         aspect_ratio: f32,
-//         near: f32,
-//         far: f32,
-//     }
-// }
-
-// animated_component! {
-//     struct OrthographicProjection {
-//         left: f32,
-//         right: f32,
-//         bottom: f32,
-//         top: f32,
-//         near: f32,
-//         far: f32,
-//         //window_origin: WindowOrigin,
-//     }
-// }
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index b822837c55ab8..bf1340abc7566 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -7,7 +7,6 @@ mod custom;
 mod reflect;
 //mod experimental;
 mod hierarchy;
-mod impls;
 mod skinned_mesh;
 
 pub mod blending;
@@ -18,7 +17,7 @@ pub use crate::app::*;
 pub use crate::blending::AnimatorBlending;
 pub use crate::custom::*;
 pub use crate::hierarchy::Hierarchy;
-pub use crate::reflect::AnimatorRegistry;
+pub use crate::reflect::AnimatorPropertyRegistry;
 pub use crate::skinned_mesh::*;
 
 pub use bevy_animation_derive::*;
@@ -27,10 +26,10 @@ pub mod prelude {
     pub use crate::app::AddAnimated;
     pub use crate::blending::AnimatorBlending;
     pub use crate::curve::Curve;
-    pub use crate::custom::{AnimatedAsset, AnimatedComponent, Animator, Clip};
+    pub use crate::custom::{Animator, Clip};
     pub use crate::hierarchy::Hierarchy;
     pub use crate::lerping::Lerp;
-    pub use crate::reflect::AnimatorRegistry;
+    pub use crate::reflect::AnimatorPropertyRegistry;
     pub use crate::skinned_mesh::{SkinAsset, SkinComponent, SkinDebugger};
     pub use bevy_animation_derive::*;
 }
@@ -49,7 +48,8 @@ impl Plugin for AnimationPlugin {
         app.add_stage_after(stage::UPDATE, stage::ANIMATE);
 
         // Generic animation
-        app.add_asset::<Clip>()
+        app.add_resource(custom::AnimatorRegistry::default())
+            .add_asset::<Clip>()
             //.add_asset_loader(ClipLoader)
             .register_type::<Animator>()
             .add_system_to_stage(stage::ANIMATE, Assets::<Clip>::asset_event_system) // ? NOTE: Fix asset event handle
@@ -57,8 +57,8 @@ impl Plugin for AnimationPlugin {
 
         // ! FIXME: Each added animated component or asset will add a bit of overhead in the animation
         // ! system, I have no idea how big this is but I would like to make it pay only for what you use
-        app.add_resource(reflect::AnimatorRegistry::default());
-        app.register_animated::<bevy_transform::prelude::Transform>();
+        app.add_resource(reflect::AnimatorPropertyRegistry::default());
+        app.register_animated_component::<bevy_transform::prelude::Transform>();
 
         // Skinning
         app.add_asset::<SkinAsset>()
diff --git a/crates/bevy_animation/src/props.rs b/crates/bevy_animation/src/props.rs
new file mode 100644
index 0000000000000..2ef39ce9b623b
--- /dev/null
+++ b/crates/bevy_animation/src/props.rs
@@ -0,0 +1,54 @@
+/// A type safe way of referring to properties that can be animated.
+///
+/// If a type implements `AnimatedProperties` each property can be retrieved
+/// by `Transform::props().translation().x()`
+pub struct Prop<T> {
+    pub name: Cow<'static, str>,
+    _marker: PhantomData<T>,
+}
+
+impl<T> Prop<T> {
+    pub const fn borrowed(name: &'static str) -> Self {
+        Prop {
+            name: Cow::Borrowed(name),
+            _marker: PhantomData,
+        }
+    }
+
+    pub const fn owned(name: String) -> Self {
+        Prop {
+            name: Cow::Owned(name),
+            _marker: PhantomData,
+        }
+    }
+}
+
+// ? NOTE: That upsets me, it should be auto generated path
+impl Prop<Vec3> {
+    pub fn x(&self) -> Prop<f32> {
+        let mut name = self.name.as_ref().to_owned();
+        name.push_str(".x");
+        Prop {
+            name: Cow::Owned(name),
+            _marker: PhantomData,
+        }
+    }
+
+    pub fn y(&self) -> Prop<f32> {
+        let mut name = self.name.as_ref().to_owned();
+        name.push_str(".y");
+        Prop {
+            name: Cow::Owned(name),
+            _marker: PhantomData,
+        }
+    }
+
+    pub fn z(&self) -> Prop<f32> {
+        let mut name = self.name.as_ref().to_owned();
+        name.push_str(".z");
+        Prop {
+            name: Cow::Owned(name),
+            _marker: PhantomData,
+        }
+    }
+}
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index 985d87fd12799..16cc8972793a7 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -1,6 +1,6 @@
 //! Generic animation for any type that implements the `Reflect` trait
 
-use std::{any::TypeId, marker::PhantomData};
+use std::{any::TypeId, marker::PhantomData, num::NonZeroUsize};
 
 use bevy_asset::prelude::*;
 use bevy_ecs::prelude::*;
@@ -13,13 +13,12 @@ use crate::{
 };
 
 // TODO: How to deal with generic types like Handle<T> or Option<T>
-// TODO: How implement safe property path `Transforms::props().translation().x()`
-// TODO: Property validation tells if some property (path and type) is or isn't valid
 // TODO: Animate assets
 // TODO: Make sure properties are within component size bounds
 // TODO: Accept also `TupleStruct` and `Value`
 // TODO: Expand types like Vec2, Vec3, Vec4 and Color
 // ! FIXME: Vec2, Vec3, Vec4 doesn't implement bevy_reflect::Struct so they can't be auto expanded
+// TODO: Implement safe property path like `Transforms::props().translation().x()` using only const, (Property validation is working)
 
 type AnimateFn = fn(
     components: &mut dyn Components,
@@ -35,15 +34,15 @@ type AnimateFn = fn(
 );
 
 /// Register how to animate custom types
-pub struct AnimatorRegistry {
-    ver: usize,
+pub struct AnimatorPropertyRegistry {
+    ver: NonZeroUsize,
     animate_functions: Vec<(TypeId, AnimateFn)>,
 }
 
-impl Default for AnimatorRegistry {
+impl Default for AnimatorPropertyRegistry {
     fn default() -> Self {
         Self {
-            ver: 0,
+            ver: NonZeroUsize::new(1).unwrap(),
             // Basic types
             animate_functions: vec![
                 (TypeId::of::<bool>(), animate::<bool>),
@@ -61,7 +60,7 @@ impl Default for AnimatorRegistry {
     }
 }
 
-impl AnimatorRegistry {
+impl AnimatorPropertyRegistry {
     pub fn registry<T: Lerp + Blend + Clone + 'static>(&mut self) {
         let ty = TypeId::of::<T>();
         if self
@@ -73,7 +72,14 @@ impl AnimatorRegistry {
             panic!("type '{}' already registered", std::any::type_name::<T>());
         }
 
-        self.ver = self.ver.wrapping_add(1);
+        let ver = self.ver.get().wrapping_add(1);
+        self.ver = if ver == 0 {
+            NonZeroUsize::new(1)
+        } else {
+            NonZeroUsize::new(ver)
+        }
+        .unwrap();
+
         self.animate_functions.push((ty, animate::<T>))
     }
 
@@ -139,6 +145,7 @@ struct AnimatorDescriptorInner {
     ver: usize,
     dynamic_properties: Vec<(String, TypeId, usize, isize, u32)>,
 }
+
 // Defines how to animate the reflected type
 pub struct AnimatorDescriptor<T> {
     inner: Option<AnimatorDescriptorInner>,
@@ -156,13 +163,56 @@ impl<T> Default for AnimatorDescriptor<T> {
     }
 }
 
+impl<T> AnimatorDescriptor<T> {
+    #[inline(always)]
+    pub fn properties(&self) -> impl Iterator<Item = (&str, TypeId)> {
+        self.inner.as_ref().into_iter().flat_map(|inner| {
+            inner
+                .dynamic_properties
+                .iter()
+                .map(|(name, type_id, _, _, _)| (name.as_str(), *type_id))
+        })
+    }
+}
+
+impl<T: Struct> AnimatorDescriptor<T> {
+    pub fn from_component(component: &T) -> Self {
+        let mut inner = AnimatorDescriptorInner {
+            ver: 0,
+            dynamic_properties: vec![],
+        };
+
+        // Lazy initialize the descriptor
+        let short_name = shorten_name(component.type_name());
+        let origin = component.any() as *const _ as *const u8;
+        for (i, value) in component.iter_fields().enumerate() {
+            let mut name = short_name.to_string();
+            name.push('.');
+            name.push_str(component.name_at(i).unwrap());
+            let ty = value.type_id();
+
+            // SAFETY: Is be less than size_of::<T>() so it won't be crazy high
+            let offset = unsafe { (value.any() as *const _ as *const u8).offset_from(origin) };
+
+            inner
+                .dynamic_properties
+                .push((name, ty, usize::MAX, offset, (1 << i) as u32));
+        }
+
+        Self {
+            inner: Some(inner),
+            ..Default::default()
+        }
+    }
+}
+
 fn shorten_name(n: &str) -> &str {
     n.rsplit("::").nth(0).unwrap_or(n)
 }
 
-pub fn animate_system<T: Struct + Send + Sync + 'static>(
-    registry: Res<AnimatorRegistry>,
-    mut descriptor: Local<AnimatorDescriptor<T>>,
+pub fn animate_component_system<T: Struct + Send + Sync + 'static>(
+    registry: Res<AnimatorPropertyRegistry>,
+    mut descriptor: ResMut<AnimatorDescriptor<T>>,
     clips: Res<Assets<Clip>>,
     animators_query: Query<&Animator>,
     // assets: Option<ResMut<Assets<T>>>,
@@ -192,54 +242,23 @@ pub fn animate_system<T: Struct + Send + Sync + 'static>(
             }
         }
 
-        if let Some(c) = components.iter().find_map(|c| c.as_ref()) {
-            if descriptor.inner.is_none() {
-                let mut inner = AnimatorDescriptorInner {
-                    ver: registry.ver,
-                    dynamic_properties: vec![],
-                };
-
-                // Lazy initialize the descriptor
-                let short_name = shorten_name(c.type_name());
-                let origin = (&**c) as *const _ as *const u8;
-                for (i, value) in c.iter_fields().enumerate() {
-                    let mut name = short_name.to_string();
-                    name.push('.');
-                    name.push_str(c.name_at(i).unwrap());
-                    let ty = value.type_id();
-
-                    // Find the animate function for the given type
-                    let index = registry.index_of(ty);
-                    if index == usize::MAX {
-                        warn!("missing animation function for `{}`", &name);
-                    }
-
-                    // SAFETY: Is be less than size_of::<T>() so it won't be crazy high
-                    let offset =
-                        unsafe { (value.any() as *const _ as *const u8).offset_from(origin) };
-
-                    inner
-                        .dynamic_properties
-                        .push((name, ty, index, offset, (1 << i) as u32));
-                }
-
-                descriptor.inner = Some(inner);
-            }
-        } else {
-            // No components found skip
-            continue;
-        }
-
         let descriptor = &mut *descriptor;
         let descriptor_inner = descriptor.inner.as_mut().unwrap();
 
-        if descriptor_inner.ver != registry.ver {
+        if descriptor_inner.ver != registry.ver.get() {
             // Lookup missing animate functions because `AnimatorRegistry` changed
-            for (_, prop_type, prop_index, _, _) in &mut descriptor_inner.dynamic_properties {
-                if *prop_index == usize::MAX {
-                    *prop_index = registry.index_of(*prop_type);
+            for (prop_name, prop_type, prop_index, _, _) in &mut descriptor_inner.dynamic_properties
+            {
+                let mut index = *prop_index;
+                if index == usize::MAX {
+                    index = registry.index_of(*prop_type);
+                    if index == usize::MAX {
+                        warn!("missing animation function for `{}`", &prop_name);
+                    }
+                    *prop_index = index;
                 }
             }
+            descriptor_inner.ver = registry.ver.get();
         }
 
         let mut blend_group = descriptor

From c1efd41f1c9e5d278d6fadeb6508c843c291c425 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Mon, 28 Dec 2020 00:29:05 -0300
Subject: [PATCH 074/153] getting rid of the derive crate

---
 crates/bevy_animation/Cargo.toml              |   2 -
 .../bevy_animation_derive/Cargo.toml          |  17 -
 .../src/animated_asset.rs                     | 160 -------
 .../src/animated_component.rs                 | 318 -------------
 .../src/animated_properties.rs                | 426 ------------------
 .../bevy_animation_derive/src/help.rs         |  74 ---
 .../bevy_animation_derive/src/lib.rs          |  39 --
 .../bevy_animation_derive/src/modules.rs      |  60 ---
 .../src/{custom.rs => animator.rs}            |   0
 crates/bevy_animation/src/app.rs              |   2 +-
 crates/bevy_animation/src/lib.rs              |  11 +-
 11 files changed, 5 insertions(+), 1104 deletions(-)
 delete mode 100644 crates/bevy_animation/bevy_animation_derive/Cargo.toml
 delete mode 100644 crates/bevy_animation/bevy_animation_derive/src/animated_asset.rs
 delete mode 100644 crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
 delete mode 100644 crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs
 delete mode 100644 crates/bevy_animation/bevy_animation_derive/src/help.rs
 delete mode 100644 crates/bevy_animation/bevy_animation_derive/src/lib.rs
 delete mode 100644 crates/bevy_animation/bevy_animation_derive/src/modules.rs
 rename crates/bevy_animation/src/{custom.rs => animator.rs} (100%)

diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index bc9a59bb53d54..98b2b482bbd91 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -18,8 +18,6 @@ bevy_tasks = { path = "../bevy_tasks", version = "0.3.0" }
 bevy_transform = { path = "../bevy_transform", version = "0.3.0" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.3.0", features = ["bevy"] }
 
-bevy_animation_derive = { path = "../bevy_animation/bevy_animation_derive", version = "0.3.0" }
-
 # other
 serde = { version = "1.0", features = ["derive"] }
 smallvec = { version = "1.4", features = ["serde"] }
diff --git a/crates/bevy_animation/bevy_animation_derive/Cargo.toml b/crates/bevy_animation/bevy_animation_derive/Cargo.toml
deleted file mode 100644
index 77c72d164f8ab..0000000000000
--- a/crates/bevy_animation/bevy_animation_derive/Cargo.toml
+++ /dev/null
@@ -1,17 +0,0 @@
-[package]
-name = "bevy_animation_derive"
-version = "0.3.0"
-authors = ["Felipe Jorge <felipe.jorge.pereira@gmail.com>"]
-edition = "2018"
-description = "Derive implementations for bevy_animation"
-license = "MIT"
-keywords = ["bevy"]
-
-[lib]
-proc-macro = true
-
-[dependencies]
-find-crate = "0.6"
-syn = "1.0"
-proc-macro2 = "1.0"
-quote = "1.0"
\ No newline at end of file
diff --git a/crates/bevy_animation/bevy_animation_derive/src/animated_asset.rs b/crates/bevy_animation/bevy_animation_derive/src/animated_asset.rs
deleted file mode 100644
index d40db24724a84..0000000000000
--- a/crates/bevy_animation/bevy_animation_derive/src/animated_asset.rs
+++ /dev/null
@@ -1,160 +0,0 @@
-use crate::{
-    animated_properties::derive_animated_properties_for_asset,
-    modules::{get_modules, get_path},
-};
-use proc_macro::TokenStream;
-use proc_macro2::TokenStream as TokenStream2;
-use quote::quote;
-use syn::{parse::ParseStream, parse_macro_input, Data, DataStruct, DeriveInput, Field, Fields};
-
-// TODO: Add extended fields like in animated_component
-
-pub fn derive_animated_asset(input: TokenStream) -> TokenStream {
-    let animated_properties: TokenStream2 =
-        derive_animated_properties_for_asset(input.clone()).into();
-    let ast = parse_macro_input!(input as DeriveInput);
-
-    let fields = match &ast.data {
-        Data::Struct(DataStruct {
-            fields: Fields::Named(fields),
-            ..
-        }) => &fields.named,
-        _ => panic!("Expected a struct with named fields."),
-    };
-
-    // Filter fields
-    let fields = fields
-        .iter()
-        .filter(|field| {
-            field
-                .attrs
-                .iter()
-                .find(|a| *a.path.get_ident().as_ref().unwrap() == "animated")
-                .map_or_else(
-                    || true,
-                    |a| {
-                        syn::custom_keyword!(ignore);
-                        a.parse_args_with(|input: ParseStream| {
-                            if input.parse::<Option<ignore>>()?.is_some() {
-                                Ok(false)
-                            } else {
-                                Ok(true)
-                            }
-                        })
-                        .expect("Invalid 'animated' attribute format.")
-                    },
-                )
-        })
-        .collect::<Vec<&Field>>();
-
-    let modules = get_modules(&ast.attrs);
-    let bevy_animation = get_path(&modules.bevy_animation);
-    let bevy_ecs = get_path(&modules.bevy_ecs);
-    let bevy_asset = get_path(&modules.bevy_asset);
-
-    let struct_name = &ast.ident;
-    let properties = fields
-        .iter()
-        .map(|field| format!("Handle<{}>.{}", struct_name, field.ident.as_ref().unwrap()));
-    let field_types = fields.iter().map(|field| &field.ty);
-    let fields = fields.iter().map(|field| field.ident.as_ref().unwrap());
-    let handle_name = format!("Handle<{}>", struct_name);
-
-    let generics = ast.generics;
-    let (impl_generics, ty_generics, _where_clause) = generics.split_for_impl();
-
-    TokenStream::from(quote! {
-        #animated_properties
-
-        impl #impl_generics #bevy_animation::AnimatedAsset for #struct_name #ty_generics {
-            fn animator_update_system(
-                clips: #bevy_ecs::Res<#bevy_asset::Assets<#bevy_animation::Clip>>,
-                mut animator_blending: #bevy_ecs::Local<#bevy_animation::AnimatorBlending>,
-                animators_query: #bevy_ecs::Query<& #bevy_animation::Animator>,
-                mut assets: #bevy_ecs::ResMut<#bevy_asset::Assets<Self>>,
-                component_query: #bevy_ecs::Query<&mut Handle<Self>>,
-            ) {
-                // let __span = tracing::info_span!("animator_transform_update_system");
-                // let __guard = __span.enter();
-
-                let mut components = vec![];
-
-                for animator in animators_query.iter() {
-                    let mut blend_group = animator_blending.begin_blending();
-
-                    components.clear();
-
-                    // ? NOTE: Lazy get each component is worse than just fetching everything at once
-                    // Pre-fetch all transforms to avoid calling get_mut multiple times
-                    // SAFETY: each component will be updated one at the time and this function
-                    // currently has the mutability over the Transform type, so no race conditions
-                    // are possible
-                    unsafe {
-                        for entity in animator.entities() {
-                            components.push(
-                                entity
-                                    .map(|entity| component_query.get_unsafe(entity).ok())
-                                    .flatten(),
-                            );
-                        }
-                    }
-
-                    for (_, layer, clip_handle, entities_map) in animator.animate() {
-                        let w = layer.weight;
-                        if w < 1.0e-8 {
-                            continue;
-                        }
-
-                        if let Some(clip) = clips.get(clip_handle) {
-                            let time = layer.time;
-
-                            // SAFETY: Never a different thread will modify or access the same index as this one;
-                            // Plus as a nice and crazy feature each property is grouped by name into their own cache line
-                            // buckets, this way no cache line will be accessed by the same thread unless the same property
-                            // is accessed by two different systems, which is possible but weird and will hit the performance a bit
-                            let keyframes = unsafe { layer.keyframes_unsafe() };
-
-                            if let Some(curves) = clip
-                                .get(#handle_name)
-                                .map(|curve_untyped| curve_untyped.downcast_ref::<Handle<Self>>())
-                                .flatten()
-                            {
-                                for (entity_index, (curve_index, curve)) in curves.iter() {
-                                    let entity_index = entities_map[entity_index as usize];
-                                    if let Some(ref mut component) = components[entity_index as usize] {
-                                        let (k, v) = curve.sample_indexed(keyframes[*curve_index], time);
-                                        keyframes[*curve_index] = k;
-                                        component.blend(&mut blend_group, v, w);
-                                    }
-                                }
-                            }
-
-                            #(
-                                if let Some(curves) = clip
-                                    .get(#properties)
-                                    .map(|curve_untyped| curve_untyped.downcast_ref::<#field_types>())
-                                    .flatten()
-                                {
-                                    for (entity_index, (curve_index, curve)) in curves.iter() {
-                                        let entity_index = entities_map[entity_index as usize];
-
-                                        if let Some(ref component) = components[entity_index as usize] {
-                                            if let Some(asset) = assets.get_mut(&**component) {
-                                                let (k, v) =
-                                                    curve.sample_indexed(keyframes[*curve_index], time);
-                                                keyframes[*curve_index] = k;
-                                                asset.#fields.blend(&mut blend_group, v, w);
-                                            }
-                                        }
-                                    }
-                                }
-                            )*
-                        }
-                    }
-                }
-
-                // std::mem::drop(__guard);
-            }
-        }
-    })
-}
diff --git a/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs b/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
deleted file mode 100644
index bea19f37e2bbf..0000000000000
--- a/crates/bevy_animation/bevy_animation_derive/src/animated_component.rs
+++ /dev/null
@@ -1,318 +0,0 @@
-use crate::{
-    animated_properties::{query_prop, query_prop_nested},
-    help::parse_animate_options,
-    modules::{get_modules, get_path},
-};
-use proc_macro::TokenStream;
-use proc_macro2::{Span, TokenStream as TokenStream2};
-use quote::quote;
-use std::collections::{HashMap, HashSet};
-use syn::{
-    parse::{Error as ParseError, Parse, ParseStream, Result as ParserResult},
-    parse_macro_input, parse_quote,
-    punctuated::Punctuated,
-    token::Comma,
-    Data, DataStruct, DeriveInput, Field, Fields, Ident, Type,
-};
-
-fn animate_property(
-    property_bit_masks: &mut HashSet<Ident>,
-    property_map: &mut HashMap<String, usize>,
-    property_name: String,
-    ident: &Ident,
-    nested_fields: Option<&Ident>,
-    ty: &Type,
-) -> TokenStream2 {
-    let mut c = ident.to_string();
-    for n in nested_fields {
-        c.push('_');
-        c.push_str(&n.to_string());
-    }
-    c = c.to_uppercase();
-    let c = Ident::new(&c, Span::call_site());
-    property_bit_masks.insert(c.clone());
-
-    let default_property_index = property_map.len();
-    let property_index = property_map
-        .entry(property_name)
-        .or_insert(default_property_index);
-
-    let nested_fields = nested_fields.into_iter();
-
-    quote! {
-        if let Some(curves) = clip
-            .get(Self::PROPERTIES[#property_index])
-            .map(|curve_untyped| curve_untyped.downcast_ref::<#ty>())
-            .flatten()
-        {
-            for (entity_index, (curve_index, curve)) in curves.iter() {
-                let entity_index = entities_map[entity_index as usize] as usize;
-                if let Some(ref mut component) = components[entity_index] {
-                    let kr = &mut keyframes[*curve_index];
-                    let (k, v) = curve.sample_indexed(*kr, time);
-                    *kr = k;
-                    component.#ident #(. #nested_fields)* .blend(entity_index, #c, &mut blend_group, v, w);
-                }
-            }
-        }
-    }
-}
-
-fn animate_property_extended<'a>(
-    property_bit_masks: &mut HashSet<Ident>,
-    property_map: &mut HashMap<String, usize>,
-    property_name: String,
-    ident: &Ident,
-    nested_fields: impl Iterator<Item = &'a Field>,
-    ty: &Type,
-) -> TokenStream2 {
-    let nested_fields = nested_fields
-        .map(|field| field.ident.as_ref().unwrap())
-        .collect::<Vec<_>>();
-
-    let bit_masks = nested_fields
-        .iter()
-        .map(|field_inner| {
-            let mut c = ident.to_string();
-            c.push('_');
-            c.push_str(&field_inner.to_string());
-            c = c.to_uppercase();
-            let c = Ident::new(&c, Span::call_site());
-            c
-        })
-        .collect::<Vec<_>>();
-
-    for c in &bit_masks {
-        property_bit_masks.insert(c.clone());
-    }
-
-    let default_property_index = property_map.len();
-    let property_index = property_map
-        .entry(property_name)
-        .or_insert(default_property_index);
-
-    quote! {
-        if let Some(curves) = clip
-            .get(Self::PROPERTIES[#property_index])
-            .map(|curve_untyped| curve_untyped.downcast_ref::<#ty>())
-            .flatten()
-        {
-            for (entity_index, (curve_index, curve)) in curves.iter() {
-                let entity_index = entities_map[entity_index as usize] as usize;
-                if let Some(ref mut component) = components[entity_index] {
-                    let kr = &mut keyframes[*curve_index];
-                    let (k, v) = curve.sample_indexed(*kr, time);
-                    *kr = k;
-                    #(component.#ident.#nested_fields.blend(entity_index, #bit_masks, &mut blend_group, v.#nested_fields, w);)*
-                }
-            }
-        }
-    }
-}
-
-pub fn derive_animated_component(input: TokenStream) -> TokenStream {
-    let derive_input = parse_macro_input!(input as DeriveInput);
-    let struct_name = &derive_input.ident;
-
-    // Modules namespaces
-    let modules = get_modules(&derive_input.attrs);
-    let bevy_animation = get_path(&modules.bevy_animation);
-    let bevy_ecs = get_path(&modules.bevy_ecs);
-    let bevy_asset = get_path(&modules.bevy_asset);
-
-    let fields = match &derive_input.data {
-        Data::Struct(DataStruct {
-            fields: Fields::Named(fields),
-            ..
-        }) => &fields.named,
-        _ => panic!("Expected a struct with named fields."),
-    };
-
-    // Animation blocks for each animated property
-    let mut properties_blocks = vec![];
-    let mut property_bit_masks = HashSet::default();
-    let mut property_map = HashMap::default();
-
-    // Filter fields
-    for field in fields.iter() {
-        let ident = field.ident.as_ref().unwrap();
-        let ty = &field.ty;
-        let field_options = field
-            .attrs
-            .iter()
-            .find(|a| *a.path.get_ident().as_ref().unwrap() == "animated")
-            .map(|attr| parse_animate_options(attr).expect("Invalid 'animated' attribute format."));
-
-        if let Some(options) = field_options {
-            // Have some custom options attached
-            let nested_fields = options.fields.unwrap_or_else(Default::default);
-            let nested = nested_fields
-                .iter()
-                .map(|nested_field| {
-                    let nested_ident = nested_field.ident.as_ref().unwrap();
-                    animate_property(
-                        &mut property_bit_masks,
-                        &mut property_map,
-                        format!("{}.{}.{}", struct_name, ident, nested_ident),
-                        ident,
-                        Some(nested_ident),
-                        &nested_field.ty,
-                    )
-                })
-                .collect::<Vec<_>>();
-
-            if options.ignore {
-                if !nested_fields.is_empty() {
-                    // Only expanded properties
-                    properties_blocks.push(quote! { #( #nested )* });
-                }
-                continue;
-            } else {
-                if !nested_fields.is_empty() {
-                    // With expanded attributes
-                    let root = animate_property_extended(
-                        &mut property_bit_masks,
-                        &mut property_map,
-                        format!("{}.{}", struct_name, ident),
-                        ident,
-                        nested_fields.iter(),
-                        &ty,
-                    );
-                    properties_blocks.push(quote! { #root else {  #( #nested )* } });
-                    continue;
-                }
-                // Default behavior
-            }
-        }
-
-        // Default
-        let root = animate_property(
-            &mut property_bit_masks,
-            &mut property_map,
-            format!("{}.{}", struct_name, ident),
-            ident,
-            None,
-            ty,
-        );
-        properties_blocks.push(root);
-    }
-
-    let generics = derive_input.generics;
-    let (impl_generics, ty_generics, _where_clause) = generics.split_for_impl();
-
-    let (constants_values, constants_idents): (Vec<u32>, Vec<&Ident>) = property_bit_masks
-        .iter()
-        .enumerate()
-        .map(|(i, n)| {
-            if i >= 32 {
-                panic!("more than 32 animated fields");
-            }
-
-            ((1 << i) as u32, n)
-        })
-        .unzip();
-
-    let mut properties_names = vec![];
-    properties_names.resize_with(property_map.len(), || String::new());
-    for (k, i) in property_map {
-        properties_names[i] = k;
-    }
-
-    TokenStream::from(quote! {
-
-        // #(
-        //     pub struct #property_ident;
-
-        //     impl #property_ident {
-        //         #(
-        //             pub const fn #property_field_ident(&self) -> #bevy_animation::Prop<#property_ty, #property_nested> {
-        //                 #bevy_animation::Prop::borrowed( #struct_name::PROPERTIES[#property_index] )
-        //             }
-        //         )*
-        //     }
-        // )*
-
-        // #(
-        //     impl std::ops::Deref for #bevy_animation::Prop<#property_ty, #property_nested> {
-        //         type Target = #property_nested;
-
-        //         #[inline(always)]
-        //         fn deref(&self) -> &Self::Target {
-        //             &#property_nested
-        //         }
-        //     }
-        // )*
-
-        impl #impl_generics #bevy_animation::AnimatedProperties for #struct_name #ty_generics {
-            type Props = ();
-
-            const PROPERTIES: &'static [&'static str] = &[ #( #properties_names, )* ];
-
-            #[inline(always)]
-            fn props() -> Self::Props {
-                todo!()
-            }
-        }
-
-        impl #impl_generics #bevy_animation::AnimatedComponent for #struct_name #ty_generics {
-            fn animator_update_system(
-                clips: #bevy_ecs::Res<#bevy_asset::Assets<#bevy_animation::Clip>>,
-                mut animator_blending: #bevy_ecs::Local<#bevy_animation::AnimatorBlending>,
-                animators_query: #bevy_ecs::Query<& #bevy_animation::Animator>,
-                component_query: #bevy_ecs::Query<&mut Self>,
-            ) {
-
-                #(const #constants_idents: u32 = #constants_values;)*
-
-                // TODO: add tracing span
-                // let __span = tracing::info_span!("animator_transform_update_system");
-                // let __guard = __span.enter();
-
-                let mut components = vec![];
-
-                for animator in animators_query.iter() {
-
-                    components.clear();
-
-                    // ? NOTE: Lazy get each component is worse than just fetching everything at once
-                    // Pre-fetch all transforms to avoid calling get_mut multiple times
-                    // SAFETY: each component will be updated one at the time and this function
-                    // currently has the mutability over the Transform type, so no race conditions
-                    // are possible
-                    unsafe {
-                        for entity in animator.entities() {
-                            components.push(
-                                entity
-                                    .map(|entity| component_query.get_unsafe(entity).ok())
-                                    .flatten(),
-                            );
-                        }
-                    }
-
-                    let mut blend_group = animator_blending.begin_blending(components.len());
-
-                    for (_, layer, clip_handle, entities_map) in animator.animate() {
-                        let w = layer.weight;
-                        if w < 1.0e-8 {
-                            continue;
-                        }
-
-                        if let Some(clip) = clips.get(clip_handle) {
-                            let time = layer.time;
-
-                            // SAFETY: Never a different thread will modify or access the same index as this one;
-                            // Plus as a nice and crazy feature each property is grouped by name into their own cache line
-                            // buckets, this way no cache line will be accessed by the same thread unless the same property
-                            // is accessed by two different systems, which is possible but weird and will hit the performance a bit
-                            let keyframes = unsafe { layer.keyframes_unsafe() };
-
-                            #(#properties_blocks)*
-                        }
-                    }
-                }
-
-                // std::mem::drop(__guard);
-            }
-        }
-    })
-}
diff --git a/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs b/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs
deleted file mode 100644
index f1e14732c9bbe..0000000000000
--- a/crates/bevy_animation/bevy_animation_derive/src/animated_properties.rs
+++ /dev/null
@@ -1,426 +0,0 @@
-use crate::{
-    help::snake_to_pascal_case,
-    modules::{get_modules, get_path},
-};
-use proc_macro::TokenStream;
-use proc_macro2::{Span, TokenStream as TokenStream2};
-use quote::{quote, ToTokens, TokenStreamExt};
-use syn::{
-    parse::ParseStream, parse_macro_input, parse_quote, parse_str, punctuated::Punctuated,
-    token::Comma, Data, DataStruct, DeriveInput, Field, Fields, Ident, Path, Type,
-};
-
-// pub struct PropDerive<'a> {
-//     pub namespace: &'a Path,
-//     pub root: &'a Ident,
-//     pub name: Type,
-//     pub field: Vec<Ident>,
-//     pub ty: Vec<Type>,
-//     pub index: Vec<usize>,
-//     pub nested: Vec<Option<PropDerive<'a>>>,
-// }
-
-// impl<'a> ToTokens for PropDerive<'a> {
-//     fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
-//         for (n, ty) in self
-//             .nested
-//             .iter()
-//             .zip(self.ty.iter())
-//             .filter_map(|(n, ty)| n.as_ref().map(|n| (n, ty)))
-//         {
-//             n.to_tokens(tokens);
-
-//             let namespace = &n.namespace;
-//             let name = &n.name;
-
-//             tokens.append_all(quote! {
-//                 impl std::ops::Deref for #namespace::Prop<#ty, #name> {
-//                     type Target = #name;
-
-//                     #[inline(always)]
-//                     fn deref(&self) -> &Self::Target {
-//                         &#name
-//                     }
-//                 }
-//             });
-//         }
-
-//         let unit: Type = parse_str("()").unwrap();
-//         let namespace = &self.namespace;
-//         let root = &self.root;
-//         let name = &self.name;
-//         let field = &self.field;
-//         let ty = &self.ty;
-//         let index = &self.index;
-//         let nested = self.nested.iter().map(|n| n.map_or(&unit, |n| n.name));
-//         tokens.append_all(quote! {
-//             pub struct #name;
-//             impl #name {
-//                 #(pub const fn #field(&self) -> #namespace::Prop<#ty, #nested> {
-//                     #namespace::Prop::borrowed( #root::PROPERTIES[#index] )
-//                 })*
-//             }
-//         });
-//     }
-// }
-
-pub fn query_prop_nested(
-    namespace: &Path,
-    struct_name: &Ident,
-    nested: &Type,
-    root_ty: &Type,
-    field: &[&Ident],
-    ty: &[&Type],
-    index: &[usize],
-) -> TokenStream2 {
-    quote! {
-        pub struct #nested;
-        impl #nested {
-            #(
-                pub const fn #field(&self) -> #namespace::Prop<#ty> {
-                    #namespace::Prop::borrowed( #struct_name::PROPERTIES[#index] )
-                }
-            )*
-        }
-        impl std::ops::Deref for #namespace::Prop<#root_ty, #nested> {
-            type Target = #nested;
-
-            #[inline(always)]
-            fn deref(&self) -> &Self::Target {
-                &#nested
-            }
-        }
-    }
-}
-
-pub fn query_prop(
-    namespace: &Path,
-    struct_name: &Ident,
-    root: &Type,
-    field: &[&Ident],
-    ty: &[&Type],
-    nested: &[&Type],
-    index: &[usize],
-) -> TokenStream2 {
-    quote! {
-        pub struct #root;
-        impl #root {
-            #(
-                pub const fn #field(&self) -> #namespace::Prop<#ty, #nested> {
-                    #namespace::Prop::borrowed( #struct_name::PROPERTIES[#index] )
-                }
-            )*
-        }
-    }
-}
-
-pub fn derive_animated_properties_for_component(input: TokenStream) -> TokenStream {
-    let ast = parse_macro_input!(input as DeriveInput);
-
-    let fields = match &ast.data {
-        Data::Struct(DataStruct {
-            fields: Fields::Named(fields),
-            ..
-        }) => &fields.named,
-        _ => panic!("Expected a struct with named fields."),
-    };
-
-    let mut expanded: Vec<Vec<Field>> = vec![];
-    expanded.resize_with(fields.len(), || vec![]);
-
-    // Filter fields
-    let fields = fields
-        .iter()
-        .enumerate()
-        .filter(|(field_index, field)| {
-            field
-                .attrs
-                .iter()
-                .find(|a| *a.path.get_ident().as_ref().unwrap() == "animated")
-                .map_or_else(
-                    || true,
-                    |a| {
-                        syn::custom_keyword!(ignore);
-                        syn::custom_keyword!(expand);
-                        a.parse_args_with(|input: ParseStream| {
-                            if input.parse::<Option<ignore>>()?.is_some() {
-                                Ok(false)
-                            } else if input.parse::<Option<expand>>()?.is_some() {
-                                let content;
-                                syn::parenthesized!(content in input);
-                                let fields: Punctuated<Field, Comma> =
-                                    content.parse_terminated(Field::parse_named)?;
-                                expanded[*field_index].extend(fields.iter().cloned());
-                                Ok(true)
-                            } else {
-                                Ok(true)
-                            }
-                        })
-                        .expect("Invalid 'animated' attribute format.")
-                    },
-                )
-        })
-        .map(|(_, field)| field)
-        .collect::<Vec<&Field>>();
-
-    let modules = get_modules(&ast.attrs);
-    let bevy_animation = get_path(&modules.bevy_animation);
-
-    let struct_name = &ast.ident;
-    let root_ident = Ident::new(&format!("{}Properties", struct_name), Span::call_site());
-    let mut available_properties = vec![];
-
-    let mut field_ident = vec![];
-    let mut field_inner: Vec<Type> = vec![];
-    let mut field_type = vec![];
-    let mut field_property_index = vec![];
-    let mut field_inner_impls = vec![];
-
-    fields
-        .iter()
-        .zip(expanded.iter())
-        .for_each(|(field, extended_fields)| {
-            let ident = field.ident.as_ref().unwrap();
-            let ty = &field.ty;
-            field_ident.push(ident);
-            field_type.push(ty);
-
-            field_property_index.push(available_properties.len());
-            available_properties.push(format!("{}.{}", struct_name, ident));
-
-            if extended_fields.len() == 0 {
-                field_inner_impls.push(quote! {});
-                field_inner.push(parse_quote!(()));
-            } else {
-                // TODO case style conversion
-                let type_inner: Type = parse_str(&format!(
-                    "{}{}Properties",
-                    struct_name,
-                    snake_to_pascal_case(&ident.to_string())
-                ))
-                .unwrap();
-
-                let mut field_ident = vec![];
-                let mut field_type = vec![];
-                let mut field_property_index = vec![];
-                extended_fields.iter().for_each(|field| {
-                    let inner = field.ident.as_ref().unwrap();
-                    field_ident.push(inner);
-                    field_type.push(&field.ty);
-                    field_property_index.push(available_properties.len());
-                    available_properties.push(format!("{}.{}.{}", struct_name, ident, inner));
-                });
-
-                field_inner_impls.push(quote! {
-                    pub struct #type_inner;
-                    impl #type_inner {
-                        #(
-                            pub const fn #field_ident(&self) -> #bevy_animation::Prop<#field_type> {
-                                #bevy_animation::Prop::borrowed( #struct_name::PROPERTIES[#field_property_index] )
-                            }
-                        )*
-                    }
-                    impl std::ops::Deref for #bevy_animation::Prop<#ty, #type_inner> {
-                        type Target = #type_inner;
-
-                        #[inline(always)]
-                        fn deref(&self) -> &Self::Target {
-                            &#type_inner
-                        }
-                    }
-                });
-                field_inner.push(type_inner);
-            }
-        });
-
-    let generics = ast.generics;
-    let (impl_generics, ty_generics, _where_clause) = generics.split_for_impl();
-
-    TokenStream::from(quote! {
-        #(#field_inner_impls)*
-
-        pub struct #root_ident;
-
-        impl #root_ident {
-            #(
-                pub const fn #field_ident(&self) -> #bevy_animation::Prop<#field_type, #field_inner> {
-                    #bevy_animation::Prop::borrowed( #struct_name::PROPERTIES[#field_property_index] )
-                }
-            )*
-        }
-
-        impl #impl_generics #bevy_animation::AnimatedProperties for #struct_name #ty_generics {
-            type Props = #root_ident;
-
-            const PROPERTIES: &'static [&'static str] = &[ #( #available_properties, )* ];
-
-            #[inline(always)]
-            fn props() -> Self::Props {
-                #root_ident
-            }
-        }
-    })
-}
-
-pub fn derive_animated_properties_for_asset(input: TokenStream) -> TokenStream {
-    let ast = parse_macro_input!(input as DeriveInput);
-
-    let fields = match &ast.data {
-        Data::Struct(DataStruct {
-            fields: Fields::Named(fields),
-            ..
-        }) => &fields.named,
-        _ => panic!("Expected a struct with named fields."),
-    };
-
-    let mut expanded: Vec<Vec<Field>> = vec![];
-    expanded.resize_with(fields.len(), || vec![]);
-
-    // Filter fields
-    let fields = fields
-        .iter()
-        .enumerate()
-        .filter(|(field_index, field)| {
-            field
-                .attrs
-                .iter()
-                .find(|a| *a.path.get_ident().as_ref().unwrap() == "animated")
-                .map_or_else(
-                    || true,
-                    |a| {
-                        syn::custom_keyword!(ignore);
-                        syn::custom_keyword!(expand);
-                        a.parse_args_with(|input: ParseStream| {
-                            if input.parse::<Option<ignore>>()?.is_some() {
-                                Ok(false)
-                            } else if input.parse::<Option<expand>>()?.is_some() {
-                                let content;
-                                syn::parenthesized!(content in input);
-                                let fields: Punctuated<Field, Comma> =
-                                    content.parse_terminated(Field::parse_named)?;
-                                expanded[*field_index].extend(fields.iter().cloned());
-                                Ok(true)
-                            } else {
-                                Ok(true)
-                            }
-                        })
-                        .expect("Invalid 'animated' attribute format.")
-                    },
-                )
-        })
-        .map(|(_, field)| field)
-        .collect::<Vec<&Field>>();
-
-    let modules = get_modules(&ast.attrs);
-    let bevy_animation = get_path(&modules.bevy_animation);
-
-    let struct_name = &ast.ident;
-    let root_ident = Ident::new(&format!("{}Properties", struct_name), Span::call_site());
-    let fields_struct = Ident::new(
-        &format!("{}FieldsProperties", struct_name),
-        Span::call_site(),
-    );
-
-    let mut available_properties = vec![];
-    available_properties.push(format!("Handle<{}>", struct_name));
-
-    let mut field_ident = vec![];
-    let mut field_inner: Vec<Type> = vec![];
-    let mut field_type = vec![];
-    let mut field_property_index = vec![];
-    let mut field_inner_impls = vec![];
-
-    fields
-        .iter()
-        .zip(expanded.iter())
-        .for_each(|(field, extended_fields)| {
-            let ident = field.ident.as_ref().unwrap();
-            let ty = &field.ty;
-            field_ident.push(ident);
-            field_type.push(ty);
-            field_property_index.push(available_properties.len());
-            available_properties.push(format!("Handle<{}>.{}", struct_name, ident));
-
-            if extended_fields.len() == 0 {
-                field_inner_impls.push(quote! {});
-                field_inner.push(parse_quote!(()));
-            } else {
-                // TODO case style conversion
-                let type_inner: Type = parse_str(&format!(
-                    "{}{}Properties",
-                    struct_name,
-                    snake_to_pascal_case(&ident.to_string())
-                ))
-                .unwrap();
-
-                let mut field_ident = vec![];
-                let mut field_type = vec![];
-                let mut field_property_index = vec![];
-                extended_fields.iter().for_each(|field| {
-                    let inner = field.ident.as_ref().unwrap();
-                    field_ident.push(inner);
-                    field_type.push(&field.ty);
-                    field_property_index.push(available_properties.len());
-                    available_properties
-                        .push(format!("Handle<{}>.{}.{}", struct_name, ident, inner));
-                });
-
-                field_inner_impls.push(quote! {
-                    pub struct #type_inner;
-                    impl #type_inner {
-                        #(
-                            pub const fn #field_ident(&self) -> #bevy_animation::Prop<#field_type> {
-                                #bevy_animation::Prop::borrowed(#struct_name::PROPERTIES[#field_property_index])
-                            }
-                        )*
-                    }
-                    impl std::ops::Deref for #bevy_animation::Prop<#ty, #type_inner> {
-                        type Target = #type_inner;
-
-                        #[inline(always)]
-                        fn deref(&self) -> &Self::Target {
-                            &#type_inner
-                        }
-                    }
-                });
-                field_inner.push(type_inner);
-            }
-        });
-
-    let generics = ast.generics;
-    let (impl_generics, ty_generics, _where_clause) = generics.split_for_impl();
-
-    TokenStream::from(quote! {
-        #(#field_inner_impls)*
-
-        pub struct #fields_struct;
-        impl #fields_struct {
-            #(
-                pub const fn #field_ident(&self) -> #bevy_animation::Prop<#field_type, #field_inner> {
-                    #bevy_animation::Prop::borrowed(#struct_name::PROPERTIES[#field_property_index])
-                }
-            )*
-        }
-
-        pub struct #root_ident;
-        impl #root_ident {
-            pub const fn handle(&self) -> #bevy_animation::Prop<Handle<#struct_name>> {
-                #bevy_animation::Prop::borrowed(#struct_name::PROPERTIES[0usize])
-            }
-            pub const fn fields(&self) -> #fields_struct {
-                #fields_struct
-            }
-        }
-
-        impl #impl_generics #bevy_animation::AnimatedProperties for #struct_name #ty_generics {
-            type Props = #root_ident;
-
-            const PROPERTIES: &'static [&'static str] = &[ #( #available_properties, )* ];
-
-            #[inline(always)]
-            fn props() -> Self::Props {
-                #root_ident
-            }
-        }
-    })
-}
diff --git a/crates/bevy_animation/bevy_animation_derive/src/help.rs b/crates/bevy_animation/bevy_animation_derive/src/help.rs
deleted file mode 100644
index 149e137f27e01..0000000000000
--- a/crates/bevy_animation/bevy_animation_derive/src/help.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use proc_macro2::Span;
-use syn::{
-    parse::{Error as ParseError, Parse, ParseStream, Result as ParserResult},
-    punctuated::Punctuated,
-    token::Comma,
-    Attribute, Field,
-};
-
-pub fn snake_to_pascal_case(name: &str) -> String {
-    let mut n = String::new();
-
-    name.split('_').for_each(|s| {
-        s.chars().enumerate().for_each(|(i, c)| {
-            if i == 0 {
-                n.extend(c.to_uppercase());
-            } else {
-                n.push(c);
-            }
-        });
-    });
-
-    n
-}
-
-enum AnimateOptEnum {
-    Ignore(Span),
-    Expand(Span, Punctuated<Field, Comma>),
-}
-
-impl Parse for AnimateOptEnum {
-    fn parse(input: ParseStream) -> ParserResult<Self> {
-        syn::custom_keyword!(ignore);
-        syn::custom_keyword!(fields);
-
-        if let Some(k) = input.parse::<Option<ignore>>()? {
-            Ok(AnimateOptEnum::Ignore(k.span))
-        } else if let Some(k) = input.parse::<Option<fields>>()? {
-            let content;
-            syn::parenthesized!(content in input);
-            Ok(AnimateOptEnum::Expand(
-                k.span,
-                content.parse_terminated(Field::parse_named)?,
-            ))
-        } else {
-            Err(ParseError::new(input.span(), "invalid attribute format"))
-        }
-    }
-}
-
-#[derive(Default)]
-pub struct AnimateOpt {
-    pub ignore: bool,
-    pub fields: Option<Punctuated<Field, Comma>>,
-}
-
-pub fn parse_animate_options(attr: &Attribute) -> ParserResult<AnimateOpt> {
-    let mut opt = AnimateOpt::default();
-    for attr in attr.parse_args_with(|input: ParseStream| {
-        input.parse_terminated::<AnimateOptEnum, Comma>(AnimateOptEnum::parse)
-    })? {
-        match attr {
-            AnimateOptEnum::Ignore(_) => {
-                opt.ignore = true;
-            }
-            AnimateOptEnum::Expand(span, fields) => {
-                if opt.fields.is_some() {
-                    Err(ParseError::new(span, "redefined `expand` attribute"))?;
-                }
-                opt.fields = Some(fields);
-            }
-        }
-    }
-    Ok(opt)
-}
diff --git a/crates/bevy_animation/bevy_animation_derive/src/lib.rs b/crates/bevy_animation/bevy_animation_derive/src/lib.rs
deleted file mode 100644
index 7c4c9d509ad52..0000000000000
--- a/crates/bevy_animation/bevy_animation_derive/src/lib.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-extern crate proc_macro;
-
-mod animated_asset;
-mod animated_component;
-mod animated_properties;
-mod help;
-mod modules;
-
-use proc_macro::TokenStream;
-
-#[proc_macro_derive(AnimatedComponent, attributes(animated))]
-pub fn derive_animated_component(input: TokenStream) -> TokenStream {
-    animated_component::derive_animated_component(input)
-}
-
-/// Used to implement the `AnimatedComponent` for an struct defined externally;
-/// Only useful inside the bevy_animation crate.
-#[doc(hidden)]
-#[proc_macro]
-pub fn animated_component(input: TokenStream) -> TokenStream {
-    animated_component::derive_animated_component(input)
-}
-
-#[proc_macro_derive(AnimatedAsset, attributes(animated))]
-pub fn derive_animated_asset(input: TokenStream) -> TokenStream {
-    animated_asset::derive_animated_asset(input)
-}
-
-/// Used to implement the `AnimatedAsset` for an struct defined externally;
-/// Only useful inside the bevy_animation crate.
-#[doc(hidden)]
-#[proc_macro]
-pub fn animated_asset(input: TokenStream) -> TokenStream {
-    animated_asset::derive_animated_asset(input)
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-// TODO: LerpValue and Blend
diff --git a/crates/bevy_animation/bevy_animation_derive/src/modules.rs b/crates/bevy_animation/bevy_animation_derive/src/modules.rs
deleted file mode 100644
index f2116ff6bb6ab..0000000000000
--- a/crates/bevy_animation/bevy_animation_derive/src/modules.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use find_crate::Manifest;
-use proc_macro::TokenStream;
-use syn::{Attribute, Path};
-
-#[derive(Debug)]
-pub struct Modules {
-    pub bevy_asset: String,
-    pub bevy_ecs: String,
-    pub bevy_animation: String,
-}
-
-impl Modules {
-    pub fn meta(name: &str) -> Modules {
-        Modules {
-            bevy_asset: format!("{}::asset", name),
-            bevy_ecs: format!("{}::ecs", name),
-            bevy_animation: format!("{}::animation", name),
-        }
-    }
-
-    pub fn external() -> Modules {
-        Modules {
-            bevy_asset: "bevy_asset".to_string(),
-            bevy_ecs: "bevy_ecs".to_string(),
-            bevy_animation: "bevy_animation".to_string(),
-        }
-    }
-}
-
-fn get_meta() -> Option<Modules> {
-    let manifest = Manifest::new().unwrap();
-    if let Some(package) = manifest.find(|name| name == "bevy") {
-        Some(Modules::meta(&package.name))
-    } else if let Some(package) = manifest.find(|name| name == "bevy_internal") {
-        Some(Modules::meta(&package.name))
-    } else {
-        None
-    }
-}
-
-//const AS_CRATE_ATTRIBUTE_NAME: &str = "as_crate";
-
-pub fn get_modules(_attributes: &[Attribute]) -> Modules {
-    let modules = get_meta().unwrap_or_else(Modules::external);
-
-    // for attribute in attributes.iter() {
-    //     if *attribute.path.get_ident().as_ref().unwrap() == AS_CRATE_ATTRIBUTE_NAME {
-    //         let value = attribute.tokens.to_string();
-    //         if value[1..value.len() - 1] == modules.bevy_render {
-    //             modules.bevy_render = "crate".to_string();
-    //         }
-    //     }
-    // }
-
-    modules
-}
-
-pub fn get_path(path_str: &str) -> Path {
-    syn::parse(path_str.parse::<TokenStream>().unwrap()).unwrap()
-}
diff --git a/crates/bevy_animation/src/custom.rs b/crates/bevy_animation/src/animator.rs
similarity index 100%
rename from crates/bevy_animation/src/custom.rs
rename to crates/bevy_animation/src/animator.rs
diff --git a/crates/bevy_animation/src/app.rs b/crates/bevy_animation/src/app.rs
index 5b07649404311..6fd57d949facd 100644
--- a/crates/bevy_animation/src/app.rs
+++ b/crates/bevy_animation/src/app.rs
@@ -7,7 +7,7 @@ use std::{
     mem::drop,
 };
 
-use crate::{custom::AnimatorRegistry, reflect, stage};
+use crate::{animator::AnimatorRegistry, reflect, stage};
 
 pub trait AddAnimated {
     fn register_animated_component<T: Default + Struct + Component>(&mut self) -> &mut Self;
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index bf1340abc7566..25420591b2d60 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -2,8 +2,8 @@ use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Assets};
 use bevy_reflect::RegisterTypeBuilder;
 
+mod animator;
 mod app;
-mod custom;
 mod reflect;
 //mod experimental;
 mod hierarchy;
@@ -13,25 +13,22 @@ pub mod blending;
 pub mod curve;
 pub mod lerping;
 
+pub use crate::animator::*;
 pub use crate::app::*;
 pub use crate::blending::AnimatorBlending;
-pub use crate::custom::*;
 pub use crate::hierarchy::Hierarchy;
 pub use crate::reflect::AnimatorPropertyRegistry;
 pub use crate::skinned_mesh::*;
 
-pub use bevy_animation_derive::*;
-
 pub mod prelude {
+    pub use crate::animator::{Animator, Clip};
     pub use crate::app::AddAnimated;
     pub use crate::blending::AnimatorBlending;
     pub use crate::curve::Curve;
-    pub use crate::custom::{Animator, Clip};
     pub use crate::hierarchy::Hierarchy;
     pub use crate::lerping::Lerp;
     pub use crate::reflect::AnimatorPropertyRegistry;
     pub use crate::skinned_mesh::{SkinAsset, SkinComponent, SkinDebugger};
-    pub use bevy_animation_derive::*;
 }
 
 pub mod stage {
@@ -48,7 +45,7 @@ impl Plugin for AnimationPlugin {
         app.add_stage_after(stage::UPDATE, stage::ANIMATE);
 
         // Generic animation
-        app.add_resource(custom::AnimatorRegistry::default())
+        app.add_resource(animator::AnimatorRegistry::default())
             .add_asset::<Clip>()
             //.add_asset_loader(ClipLoader)
             .register_type::<Animator>()

From a039adb5b3c81c5cdaa2168ad4ba6d40a53ea263 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Mon, 28 Dec 2020 00:44:52 -0300
Subject: [PATCH 075/153] better warnings

---
 crates/bevy_animation/src/animator.rs | 51 +++++++++++++++++++++------
 crates/bevy_animation/src/reflect.rs  | 23 ++++++------
 2 files changed, 53 insertions(+), 21 deletions(-)

diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index 7493ad9642b01..8c0a9c3b894af 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -21,6 +21,8 @@ use crate::curve::Curve;
 use crate::hierarchy::Hierarchy;
 use crate::lerping::Lerp;
 
+// TODO: Load Clip name from gltf
+
 // Starting from Intel's Sandy Bridge, spatial prefetcher is now pulling pairs of 64-byte cache
 // lines at a time, so we have to align to 128 bytes rather than 64.
 //
@@ -69,11 +71,34 @@ impl<T> Curves<T> {
     }
 }
 
+pub struct CurveMeta(&'static str, TypeId);
+
+impl CurveMeta {
+    pub fn of<T: 'static>() -> Self {
+        let n = std::any::type_name::<T>();
+        Self(n.rsplit("::").nth(0).unwrap_or(n), TypeId::of::<T>())
+    }
+
+    pub const fn short_name(&self) -> &'static str {
+        self.0
+    }
+
+    pub const fn type_id(&self) -> TypeId {
+        self.1
+    }
+}
+
+impl std::fmt::Debug for CurveMeta {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("CurveMeta").field(&self.0).finish()
+    }
+}
+
 #[derive(Debug)]
 pub struct CurvesUntyped {
     /// Cached calculated curves duration
     duration: f32,
-    type_id: TypeId,
+    meta: CurveMeta,
     untyped: Box<dyn Any + Send + Sync + 'static>,
 }
 
@@ -81,13 +106,13 @@ impl CurvesUntyped {
     fn new<T: Send + Sync + 'static>(curves: Curves<T>) -> Self {
         CurvesUntyped {
             duration: curves.calculate_duration(),
-            type_id: TypeId::of::<T>(),
+            meta: CurveMeta::of::<T>(),
             untyped: Box::new(curves),
         }
     }
 
-    pub const fn type_id(&self) -> TypeId {
-        self.type_id
+    pub const fn meta(&self) -> &CurveMeta {
+        &self.meta
     }
 
     pub const fn duration(&self) -> f32 {
@@ -130,6 +155,7 @@ impl CurvesUntyped {
 #[derive(Debug, TypeUuid)]
 #[uuid = "79e2ea58-8bf7-43af-8219-5898edb02f80"]
 pub struct Clip {
+    pub name: String,
     /// Should this clip loop (warping around) or hold
     ///
     /// **NOTE** Keep in mind that sampling with time greater
@@ -159,6 +185,7 @@ pub struct Clip {
 impl Default for Clip {
     fn default() -> Self {
         Self {
+            name: String::new(),
             warp: true,
             duration: 0.0,
             hierarchy: Hierarchy::default(),
@@ -681,13 +708,17 @@ pub(crate) fn animator_update_system(
                     // TODO: Add option to ignore these extra checks (or not)
                     // Check if the clips properties are registered
                     for (property_name, (_, curves)) in clip.properties.iter() {
-                        if !animator_registry
-                            .static_properties
-                            .contains(&(Cow::Borrowed(property_name.as_str()), curves.type_id()))
-                        {
+                        if !animator_registry.static_properties.contains(&(
+                            Cow::Borrowed(property_name.as_str()),
+                            curves.meta().type_id(),
+                        )) {
                             // TODO: Check dynamic properties names using regex
-                            // TODO: Include clip name on warning
-                            warn!("unregistered property '{}', maybe it's misspelled or the type doesn't match", &property_name);
+                            warn!(
+                                "unregistered property '{}' ({}) of clip '{}', maybe it's misspelled or the type doesn't match",
+                                &property_name,
+                                curves.meta().short_name(),
+                                &clip.name
+                            );
                         }
                     }
 
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index 16cc8972793a7..62cd54329f5d0 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -36,7 +36,7 @@ type AnimateFn = fn(
 /// Register how to animate custom types
 pub struct AnimatorPropertyRegistry {
     ver: NonZeroUsize,
-    animate_functions: Vec<(TypeId, AnimateFn)>,
+    animate_functions: Vec<(&'static str, TypeId, AnimateFn)>,
 }
 
 impl Default for AnimatorPropertyRegistry {
@@ -45,12 +45,12 @@ impl Default for AnimatorPropertyRegistry {
             ver: NonZeroUsize::new(1).unwrap(),
             // Basic types
             animate_functions: vec![
-                (TypeId::of::<bool>(), animate::<bool>),
-                (TypeId::of::<f32>(), animate::<f32>),
-                (TypeId::of::<Vec2>(), animate::<Vec2>),
-                (TypeId::of::<Vec3>(), animate::<Vec3>),
-                (TypeId::of::<Vec4>(), animate::<Vec4>),
-                (TypeId::of::<Quat>(), animate::<Quat>),
+                ("bool", TypeId::of::<bool>(), animate::<bool>),
+                ("f32", TypeId::of::<f32>(), animate::<f32>),
+                ("Vec2", TypeId::of::<Vec2>(), animate::<Vec2>),
+                ("Vec3", TypeId::of::<Vec3>(), animate::<Vec3>),
+                ("Vec4", TypeId::of::<Vec4>(), animate::<Vec4>),
+                ("Quat", TypeId::of::<Quat>(), animate::<Quat>),
                 // (TypeId::of::<Color>(), animate::<Color>),
                 // (TypeId::of::<HandleUntyped>(), animate::<HandleUntyped>),
                 // (TypeId::of::<Handle<Mesh>>(), animate::<Handle<Mesh>>),
@@ -66,7 +66,7 @@ impl AnimatorPropertyRegistry {
         if self
             .animate_functions
             .iter()
-            .position(|(other, _)| *other == ty)
+            .position(|(_, other, _)| *other == ty)
             .is_some()
         {
             panic!("type '{}' already registered", std::any::type_name::<T>());
@@ -80,7 +80,8 @@ impl AnimatorPropertyRegistry {
         }
         .unwrap();
 
-        self.animate_functions.push((ty, animate::<T>))
+        self.animate_functions
+            .push((shorten_name(std::any::type_name::<T>()), ty, animate::<T>))
     }
 
     /// Returns `usize::MAX` if the type wasn't registered,
@@ -91,7 +92,7 @@ impl AnimatorPropertyRegistry {
     pub fn index_of(&self, ty: TypeId) -> usize {
         self.animate_functions
             .iter()
-            .position(|(other, _)| *other == ty)
+            .position(|(_, other, _)| *other == ty)
             .unwrap_or(usize::MAX)
     }
 }
@@ -292,7 +293,7 @@ pub fn animate_component_system<T: Struct + Send + Sync + 'static>(
                         continue;
                     }
 
-                    (registry.animate_functions[i].1)(
+                    (registry.animate_functions[i].2)(
                         &mut *components,
                         entities_map,
                         &mut blend_group,

From 2b304e010cc8e6eaa47205652456cef5f3c56060 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Mon, 28 Dec 2020 00:46:23 -0300
Subject: [PATCH 076/153] moved short_name to a common place

---
 crates/bevy_animation/src/animator.rs | 7 +++++--
 crates/bevy_animation/src/reflect.rs  | 7 ++-----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index 8c0a9c3b894af..986cd9eff69ff 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -71,12 +71,15 @@ impl<T> Curves<T> {
     }
 }
 
+pub(crate) fn shorten_name(n: &str) -> &str {
+    n.rsplit("::").nth(0).unwrap_or(n)
+}
+
 pub struct CurveMeta(&'static str, TypeId);
 
 impl CurveMeta {
     pub fn of<T: 'static>() -> Self {
-        let n = std::any::type_name::<T>();
-        Self(n.rsplit("::").nth(0).unwrap_or(n), TypeId::of::<T>())
+        Self(shorten_name(std::any::type_name::<T>()), TypeId::of::<T>())
     }
 
     pub const fn short_name(&self) -> &'static str {
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index 62cd54329f5d0..05cac6a4b34f6 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -9,7 +9,8 @@ use bevy_reflect::prelude::*;
 use tracing::warn;
 
 use crate::{
-    blending::AnimatorBlendGroup, blending::Blend, lerping::Lerp, Animator, AnimatorBlending, Clip,
+    blending::AnimatorBlendGroup, blending::Blend, lerping::Lerp, shorten_name, Animator,
+    AnimatorBlending, Clip,
 };
 
 // TODO: How to deal with generic types like Handle<T> or Option<T>
@@ -207,10 +208,6 @@ impl<T: Struct> AnimatorDescriptor<T> {
     }
 }
 
-fn shorten_name(n: &str) -> &str {
-    n.rsplit("::").nth(0).unwrap_or(n)
-}
-
 pub fn animate_component_system<T: Struct + Send + Sync + 'static>(
     registry: Res<AnimatorPropertyRegistry>,
     mut descriptor: ResMut<AnimatorDescriptor<T>>,

From 9738c10cfdd04cd04919260c52e0c811a51235a1 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Tue, 29 Dec 2020 01:18:32 -0300
Subject: [PATCH 077/153] better shorten_name supports generics, better error
 messages

---
 crates/bevy_animation/src/animator.rs | 21 +++-------
 crates/bevy_animation/src/app.rs      | 17 +++++++-
 crates/bevy_animation/src/help.rs     | 31 +++++++++++++++
 crates/bevy_animation/src/lib.rs      |  1 +
 crates/bevy_animation/src/reflect.rs  | 57 ++++++++++++++++-----------
 5 files changed, 87 insertions(+), 40 deletions(-)
 create mode 100644 crates/bevy_animation/src/help.rs

diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index 986cd9eff69ff..14e341138b9e7 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -1,6 +1,5 @@
 use std::{
-    any::Any,
-    any::TypeId,
+    any::{type_name, Any, TypeId},
     borrow::Cow,
     collections::{HashMap, HashSet},
 };
@@ -16,10 +15,7 @@ use fnv::FnvBuildHasher;
 use smallvec::{smallvec, SmallVec};
 use tracing::warn;
 
-use crate::blending::AnimatorBlending;
-use crate::curve::Curve;
-use crate::hierarchy::Hierarchy;
-use crate::lerping::Lerp;
+use crate::{blending::AnimatorBlending, curve::Curve, hierarchy::Hierarchy, lerping::Lerp};
 
 // TODO: Load Clip name from gltf
 
@@ -70,19 +66,14 @@ impl<T> Curves<T> {
         self.entity_indexes.iter().copied().zip(self.curves.iter())
     }
 }
-
-pub(crate) fn shorten_name(n: &str) -> &str {
-    n.rsplit("::").nth(0).unwrap_or(n)
-}
-
 pub struct CurveMeta(&'static str, TypeId);
 
 impl CurveMeta {
     pub fn of<T: 'static>() -> Self {
-        Self(shorten_name(std::any::type_name::<T>()), TypeId::of::<T>())
+        Self(type_name::<T>(), TypeId::of::<T>())
     }
 
-    pub const fn short_name(&self) -> &'static str {
+    pub const fn type_name(&self) -> &str {
         self.0
     }
 
@@ -717,9 +708,9 @@ pub(crate) fn animator_update_system(
                         )) {
                             // TODO: Check dynamic properties names using regex
                             warn!(
-                                "unregistered property '{}' ({}) of clip '{}', maybe it's misspelled or the type doesn't match",
+                                "unregistered property '{}' of type `{}` in clip '{}', maybe the property name is misspelled or it's type isn't registered as animated",
                                 &property_name,
-                                curves.meta().short_name(),
+                                curves.meta().type_name(),
                                 &clip.name
                             );
                         }
diff --git a/crates/bevy_animation/src/app.rs b/crates/bevy_animation/src/app.rs
index 6fd57d949facd..43f87ed41cec0 100644
--- a/crates/bevy_animation/src/app.rs
+++ b/crates/bevy_animation/src/app.rs
@@ -7,13 +7,28 @@ use std::{
     mem::drop,
 };
 
-use crate::{animator::AnimatorRegistry, reflect, stage};
+use crate::{
+    animator::AnimatorRegistry, blending::Blend, lerping::Lerp, reflect, stage,
+    AnimatorPropertyRegistry,
+};
 
 pub trait AddAnimated {
+    fn register_animated_property_type<T: Lerp + Blend + Clone + 'static>(&mut self) -> &mut Self;
     fn register_animated_component<T: Default + Struct + Component>(&mut self) -> &mut Self;
 }
 
 impl AddAnimated for AppBuilder {
+    fn register_animated_property_type<T: Lerp + Blend + Clone + 'static>(&mut self) -> &mut Self {
+        let mut property_registry = self
+            .resources_mut()
+            .get_or_insert_with(AnimatorPropertyRegistry::default);
+
+        property_registry.register::<T>();
+        drop(property_registry);
+
+        self
+    }
+
     fn register_animated_component<T: Default + Struct + Component>(&mut self) -> &mut Self {
         let mut registry = self
             .resources_mut()
diff --git a/crates/bevy_animation/src/help.rs b/crates/bevy_animation/src/help.rs
new file mode 100644
index 0000000000000..86e37017a53f9
--- /dev/null
+++ b/crates/bevy_animation/src/help.rs
@@ -0,0 +1,31 @@
+// TODO: Make ShortTypeNames hold a set of dynamic allocated strings parking_lot = "0.11.1" + lazy_static
+// struct ShortTypeNames {
+//     types: Mutex<HashMap<TypeId, String, FnvBuildHasher>>,
+// }
+
+pub(crate) fn shorten_name(input: &str) -> String {
+    // ? NOTE: Right for generic types
+    let mut chars = input.chars().rev();
+    let mut output = String::new();
+    let mut depth = 0usize;
+    let mut k = usize::MAX;
+    while let Some(c) = chars.next() {
+        if c == '>' {
+            output.push('>');
+            depth += 1;
+        } else if c == '<' {
+            output.push('<');
+            depth -= 1;
+        } else if c == ':' {
+            if depth == 0 {
+                break;
+            }
+            chars.next(); // skip next
+            k = depth;
+        } else if k != depth {
+            output.push(c);
+        }
+    }
+    // TODO: Find a better way that doesn't rely on yet another allocation
+    output.chars().rev().collect()
+}
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 25420591b2d60..6973e7d43d836 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -4,6 +4,7 @@ use bevy_reflect::RegisterTypeBuilder;
 
 mod animator;
 mod app;
+mod help;
 mod reflect;
 //mod experimental;
 mod hierarchy;
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index 05cac6a4b34f6..d48cbaa5987f8 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -1,6 +1,6 @@
 //! Generic animation for any type that implements the `Reflect` trait
 
-use std::{any::TypeId, marker::PhantomData, num::NonZeroUsize};
+use std::{any::type_name, any::TypeId, marker::PhantomData, num::NonZeroUsize};
 
 use bevy_asset::prelude::*;
 use bevy_ecs::prelude::*;
@@ -9,7 +9,7 @@ use bevy_reflect::prelude::*;
 use tracing::warn;
 
 use crate::{
-    blending::AnimatorBlendGroup, blending::Blend, lerping::Lerp, shorten_name, Animator,
+    blending::AnimatorBlendGroup, blending::Blend, help::shorten_name, lerping::Lerp, Animator,
     AnimatorBlending, Clip,
 };
 
@@ -37,7 +37,7 @@ type AnimateFn = fn(
 /// Register how to animate custom types
 pub struct AnimatorPropertyRegistry {
     ver: NonZeroUsize,
-    animate_functions: Vec<(&'static str, TypeId, AnimateFn)>,
+    animate_functions: Vec<(TypeId, AnimateFn)>,
 }
 
 impl Default for AnimatorPropertyRegistry {
@@ -46,12 +46,12 @@ impl Default for AnimatorPropertyRegistry {
             ver: NonZeroUsize::new(1).unwrap(),
             // Basic types
             animate_functions: vec![
-                ("bool", TypeId::of::<bool>(), animate::<bool>),
-                ("f32", TypeId::of::<f32>(), animate::<f32>),
-                ("Vec2", TypeId::of::<Vec2>(), animate::<Vec2>),
-                ("Vec3", TypeId::of::<Vec3>(), animate::<Vec3>),
-                ("Vec4", TypeId::of::<Vec4>(), animate::<Vec4>),
-                ("Quat", TypeId::of::<Quat>(), animate::<Quat>),
+                (TypeId::of::<bool>(), animate::<bool>),
+                (TypeId::of::<f32>(), animate::<f32>),
+                (TypeId::of::<Vec2>(), animate::<Vec2>),
+                (TypeId::of::<Vec3>(), animate::<Vec3>),
+                (TypeId::of::<Vec4>(), animate::<Vec4>),
+                (TypeId::of::<Quat>(), animate::<Quat>),
                 // (TypeId::of::<Color>(), animate::<Color>),
                 // (TypeId::of::<HandleUntyped>(), animate::<HandleUntyped>),
                 // (TypeId::of::<Handle<Mesh>>(), animate::<Handle<Mesh>>),
@@ -62,15 +62,15 @@ impl Default for AnimatorPropertyRegistry {
 }
 
 impl AnimatorPropertyRegistry {
-    pub fn registry<T: Lerp + Blend + Clone + 'static>(&mut self) {
+    pub fn register<T: Lerp + Blend + Clone + 'static>(&mut self) {
         let ty = TypeId::of::<T>();
         if self
             .animate_functions
             .iter()
-            .position(|(_, other, _)| *other == ty)
+            .position(|(other, _)| *other == ty)
             .is_some()
         {
-            panic!("type '{}' already registered", std::any::type_name::<T>());
+            panic!("type '{}' already registered", type_name::<T>());
         }
 
         let ver = self.ver.get().wrapping_add(1);
@@ -81,8 +81,7 @@ impl AnimatorPropertyRegistry {
         }
         .unwrap();
 
-        self.animate_functions
-            .push((shorten_name(std::any::type_name::<T>()), ty, animate::<T>))
+        self.animate_functions.push((ty, animate::<T>))
     }
 
     /// Returns `usize::MAX` if the type wasn't registered,
@@ -93,7 +92,7 @@ impl AnimatorPropertyRegistry {
     pub fn index_of(&self, ty: TypeId) -> usize {
         self.animate_functions
             .iter()
-            .position(|(_, other, _)| *other == ty)
+            .position(|(other, _)| *other == ty)
             .unwrap_or(usize::MAX)
     }
 }
@@ -188,17 +187,27 @@ impl<T: Struct> AnimatorDescriptor<T> {
         let short_name = shorten_name(component.type_name());
         let origin = component.any() as *const _ as *const u8;
         for (i, value) in component.iter_fields().enumerate() {
-            let mut name = short_name.to_string();
-            name.push('.');
-            name.push_str(component.name_at(i).unwrap());
-            let ty = value.type_id();
+            let component_name = component.name_at(i).unwrap();
+            // NOTE: Pre calculate all the space needed to make in a single allocation (untested)
+            let mut prop_name = String::with_capacity(short_name.len() + 1 + component_name.len());
+            prop_name.push_str(&short_name);
+            prop_name.push('.');
+            prop_name.push_str(component_name);
+
+            let prop_type = value.type_id();
 
             // SAFETY: Is be less than size_of::<T>() so it won't be crazy high
-            let offset = unsafe { (value.any() as *const _ as *const u8).offset_from(origin) };
+            let prop_offset = unsafe { (value.any() as *const _ as *const u8).offset_from(origin) };
 
-            inner
-                .dynamic_properties
-                .push((name, ty, usize::MAX, offset, (1 << i) as u32));
+            let prop_mask = (1 << i) as u32;
+
+            inner.dynamic_properties.push((
+                prop_name,
+                prop_type,
+                usize::MAX,
+                prop_offset,
+                prop_mask,
+            ));
         }
 
         Self {
@@ -290,7 +299,7 @@ pub fn animate_component_system<T: Struct + Send + Sync + 'static>(
                         continue;
                     }
 
-                    (registry.animate_functions[i].2)(
+                    (registry.animate_functions[i].1)(
                         &mut *components,
                         entities_map,
                         &mut blend_group,

From f371954a942962b02cb789000e3127ce989ddbc5 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Wed, 30 Dec 2020 02:42:06 -0300
Subject: [PATCH 078/153] animate assets (untested) + refactor

---
 crates/bevy_animation/src/app.rs     |  40 +++-
 crates/bevy_animation/src/reflect.rs | 328 ++++++++++++++++++++-------
 2 files changed, 280 insertions(+), 88 deletions(-)

diff --git a/crates/bevy_animation/src/app.rs b/crates/bevy_animation/src/app.rs
index 43f87ed41cec0..856ef6553886c 100644
--- a/crates/bevy_animation/src/app.rs
+++ b/crates/bevy_animation/src/app.rs
@@ -1,4 +1,5 @@
 use bevy_app::AppBuilder;
+use bevy_asset::{Asset, Handle};
 use bevy_ecs::prelude::*;
 use bevy_reflect::prelude::*;
 use std::{
@@ -14,7 +15,8 @@ use crate::{
 
 pub trait AddAnimated {
     fn register_animated_property_type<T: Lerp + Blend + Clone + 'static>(&mut self) -> &mut Self;
-    fn register_animated_component<T: Default + Struct + Component>(&mut self) -> &mut Self;
+    fn register_animated_component<T: Component + Struct + Default>(&mut self) -> &mut Self;
+    fn register_animated_asset<T: Asset + Struct + Default>(&mut self) -> &mut Self;
 }
 
 impl AddAnimated for AppBuilder {
@@ -29,7 +31,7 @@ impl AddAnimated for AppBuilder {
         self
     }
 
-    fn register_animated_component<T: Default + Struct + Component>(&mut self) -> &mut Self {
+    fn register_animated_component<T: Component + Struct + Default>(&mut self) -> &mut Self {
         let mut registry = self
             .resources_mut()
             .get_or_insert_with(AnimatorRegistry::default);
@@ -50,7 +52,39 @@ impl AddAnimated for AppBuilder {
             self.add_system_to_stage(stage::ANIMATE, reflect::animate_component_system::<T>);
             self
         } else {
-            panic!("animator already registered for '{}'", type_name::<T>());
+            panic!(
+                "animated component `{}` already registered",
+                type_name::<T>()
+            );
+        }
+    }
+
+    fn register_animated_asset<T: Asset + Struct + Default>(&mut self) -> &mut Self {
+        let mut registry = self
+            .resources_mut()
+            .get_or_insert_with(AnimatorRegistry::default);
+
+        if registry.targets.insert(TypeId::of::<T>()) {
+            let asset = T::default();
+            let descriptor = reflect::AnimatorDescriptor::<T>::from_asset(&asset);
+
+            registry.static_properties.extend(
+                descriptor
+                    .properties()
+                    .map(|(name, type_id)| (Cow::Owned(name.to_string()), type_id)),
+            );
+
+            drop(registry);
+
+            // Register property animators that might be useful
+            self.register_animated_property_type::<Handle<T>>();
+            self.register_animated_property_type::<Option<Handle<T>>>();
+
+            self.add_resource(descriptor);
+            self.add_system_to_stage(stage::ANIMATE, reflect::animate_asset_system::<T>);
+            self
+        } else {
+            panic!("animated asset `{}` already registered", type_name::<T>());
         }
     }
 }
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index d48cbaa5987f8..f2a78ea51652a 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -2,7 +2,7 @@
 
 use std::{any::type_name, any::TypeId, marker::PhantomData, num::NonZeroUsize};
 
-use bevy_asset::prelude::*;
+use bevy_asset::{prelude::*, Asset};
 use bevy_ecs::prelude::*;
 use bevy_math::prelude::*;
 use bevy_reflect::prelude::*;
@@ -14,15 +14,15 @@ use crate::{
 };
 
 // TODO: How to deal with generic types like Handle<T> or Option<T>
-// TODO: Animate assets
 // TODO: Make sure properties are within component size bounds
+// TODO: Add tracing spans
 // TODO: Accept also `TupleStruct` and `Value`
 // TODO: Expand types like Vec2, Vec3, Vec4 and Color
 // ! FIXME: Vec2, Vec3, Vec4 doesn't implement bevy_reflect::Struct so they can't be auto expanded
 // TODO: Implement safe property path like `Transforms::props().translation().x()` using only const, (Property validation is working)
 
 type AnimateFn = fn(
-    components: &mut dyn Components,
+    get_mut: &mut dyn FnMut(usize) -> Option<*mut u8>,
     entities_map: &[u16],
     blend_group: &mut AnimatorBlendGroup,
     keyframes: &mut [u16],
@@ -37,6 +37,7 @@ type AnimateFn = fn(
 /// Register how to animate custom types
 pub struct AnimatorPropertyRegistry {
     ver: NonZeroUsize,
+    // TODO: Use a hashmap?
     animate_functions: Vec<(TypeId, AnimateFn)>,
 }
 
@@ -54,7 +55,6 @@ impl Default for AnimatorPropertyRegistry {
                 (TypeId::of::<Quat>(), animate::<Quat>),
                 // (TypeId::of::<Color>(), animate::<Color>),
                 // (TypeId::of::<HandleUntyped>(), animate::<HandleUntyped>),
-                // (TypeId::of::<Handle<Mesh>>(), animate::<Handle<Mesh>>),
                 // TODO: How to handle generic types like Handle<T> or Option<T>
             ],
         }
@@ -97,21 +97,8 @@ impl AnimatorPropertyRegistry {
     }
 }
 
-/// Helper trait to fetch components pointers
-trait Components {
-    fn get_mut(&mut self, index: usize) -> Option<*mut u8>;
-}
-
-impl<'a, 's, T: Send + Sync + 'static> Components for &'s mut [Option<Mut<'a, T>>] {
-    #[inline(always)]
-    fn get_mut(&mut self, index: usize) -> Option<*mut u8> {
-        // NOTE: Will trigger the `Changed` event to the right types
-        self[index].as_mut().map(|c| &mut **c as *mut T as *mut u8)
-    }
-}
-
 fn animate<T: Lerp + Blend + Clone + 'static>(
-    components: &mut dyn Components,
+    get_mut: &mut dyn FnMut(usize) -> Option<*mut u8>,
     entities_map: &[u16],
     blend_group: &mut AnimatorBlendGroup,
     keyframes: &mut [u16],
@@ -129,7 +116,7 @@ fn animate<T: Lerp + Blend + Clone + 'static>(
     {
         for (entity_index, (curve_index, curve)) in curves.iter() {
             let entity_index = entities_map[entity_index as usize] as usize;
-            if let Some(ref mut component) = components.get_mut(entity_index) {
+            if let Some(component) = (get_mut)(entity_index) {
                 let kr = &mut keyframes[*curve_index];
                 let (k, v) = curve.sample_indexed(*kr, time);
                 *kr = k;
@@ -142,14 +129,19 @@ fn animate<T: Lerp + Blend + Clone + 'static>(
     }
 }
 
-struct AnimatorDescriptorInner {
-    ver: usize,
-    dynamic_properties: Vec<(String, TypeId, usize, isize, u32)>,
+struct Property {
+    path: String,
+    type_id: TypeId,
+    index: usize,
+    offset: isize,
+    mask: u32,
 }
 
-// Defines how to animate the reflected type
+// Defines how to animate an type
 pub struct AnimatorDescriptor<T> {
-    inner: Option<AnimatorDescriptorInner>,
+    ver: usize,
+    short_name: String,
+    dynamic_properties: Vec<Property>,
     animator_blending: AnimatorBlending,
     _marker: PhantomData<T>,
 }
@@ -157,7 +149,9 @@ pub struct AnimatorDescriptor<T> {
 impl<T> Default for AnimatorDescriptor<T> {
     fn default() -> Self {
         Self {
-            inner: None,
+            ver: 0,
+            short_name: String::new(),
+            dynamic_properties: vec![],
             animator_blending: AnimatorBlending::default(),
             _marker: PhantomData,
         }
@@ -167,70 +161,96 @@ impl<T> Default for AnimatorDescriptor<T> {
 impl<T> AnimatorDescriptor<T> {
     #[inline(always)]
     pub fn properties(&self) -> impl Iterator<Item = (&str, TypeId)> {
-        self.inner.as_ref().into_iter().flat_map(|inner| {
-            inner
-                .dynamic_properties
-                .iter()
-                .map(|(name, type_id, _, _, _)| (name.as_str(), *type_id))
-        })
+        self.dynamic_properties
+            .iter()
+            .map(|Property { path, type_id, .. }| (path.as_str(), *type_id))
     }
 }
 
 impl<T: Struct> AnimatorDescriptor<T> {
     pub fn from_component(component: &T) -> Self {
-        let mut inner = AnimatorDescriptorInner {
-            ver: 0,
-            dynamic_properties: vec![],
-        };
+        let base_path = shorten_name(component.type_name());
+        let mut descriptor = Self::build(component, &base_path);
+        descriptor.short_name = base_path;
+        descriptor
+    }
+
+    pub fn from_asset(asset: &T) -> Self {
+        let mut base_path = shorten_name(asset.type_name());
+        base_path.insert_str(0, "Handle<");
+        base_path.push('>');
+        let mut descriptor = Self::build(asset, &base_path);
+        descriptor.short_name = base_path;
+        descriptor
+    }
+
+    fn build(instance: &T, base_path: &str) -> Self {
+        let mut dynamic_properties = vec![];
 
         // Lazy initialize the descriptor
-        let short_name = shorten_name(component.type_name());
-        let origin = component.any() as *const _ as *const u8;
-        for (i, value) in component.iter_fields().enumerate() {
-            let component_name = component.name_at(i).unwrap();
+        let origin = instance.any() as *const _ as *const u8;
+        for (i, value) in instance.iter_fields().enumerate() {
+            let field_name = instance.name_at(i).unwrap();
             // NOTE: Pre calculate all the space needed to make in a single allocation (untested)
-            let mut prop_name = String::with_capacity(short_name.len() + 1 + component_name.len());
-            prop_name.push_str(&short_name);
-            prop_name.push('.');
-            prop_name.push_str(component_name);
+            let mut path = String::with_capacity(base_path.len() + 1 + field_name.len());
+            path.push_str(&base_path);
+            path.push('.');
+            path.push_str(field_name);
 
-            let prop_type = value.type_id();
+            let type_id = value.type_id();
 
             // SAFETY: Is be less than size_of::<T>() so it won't be crazy high
-            let prop_offset = unsafe { (value.any() as *const _ as *const u8).offset_from(origin) };
-
-            let prop_mask = (1 << i) as u32;
-
-            inner.dynamic_properties.push((
-                prop_name,
-                prop_type,
-                usize::MAX,
-                prop_offset,
-                prop_mask,
-            ));
+            let offset = unsafe { (value.any() as *const _ as *const u8).offset_from(origin) };
+
+            let mask = 1 << i;
+            let index = usize::MAX;
+
+            dynamic_properties.push(Property {
+                path,
+                type_id,
+                index,
+                offset,
+                mask,
+            });
         }
 
         Self {
-            inner: Some(inner),
+            dynamic_properties,
             ..Default::default()
         }
     }
 }
 
-pub fn animate_component_system<T: Struct + Send + Sync + 'static>(
+///////////////////////////////////////////////////////////////////////////////
+
+pub fn animate_component_system<T: Component>(
     registry: Res<AnimatorPropertyRegistry>,
     mut descriptor: ResMut<AnimatorDescriptor<T>>,
     clips: Res<Assets<Clip>>,
     animators_query: Query<&Animator>,
-    // assets: Option<ResMut<Assets<T>>>,
-    // handles_query: Query<&mut Handle<T>>,
     components_query: Query<&mut T>,
 ) {
-    let __span = tracing::info_span!("animator_transform_update_system");
-    let __guard = __span.enter();
+    // let __span = tracing::info_span!("animator_transform_update_system");
+    // let __guard = __span.enter();
 
     let mut components = vec![];
 
+    let descriptor = &mut *descriptor;
+    if descriptor.ver != registry.ver.get() {
+        // Lookup missing animate functions because `AnimatorRegistry` changed
+        for prop in &mut descriptor.dynamic_properties {
+            let mut i = prop.index;
+            if i == usize::MAX {
+                i = registry.index_of(prop.type_id);
+                if i == usize::MAX {
+                    warn!("missing animation function for `{}`", &prop.path);
+                }
+                prop.index = i;
+            }
+        }
+        descriptor.ver = registry.ver.get();
+    }
+
     for animator in animators_query.iter() {
         components.clear();
 
@@ -249,31 +269,113 @@ pub fn animate_component_system<T: Struct + Send + Sync + 'static>(
             }
         }
 
-        let descriptor = &mut *descriptor;
-        let descriptor_inner = descriptor.inner.as_mut().unwrap();
-
-        if descriptor_inner.ver != registry.ver.get() {
-            // Lookup missing animate functions because `AnimatorRegistry` changed
-            for (prop_name, prop_type, prop_index, _, _) in &mut descriptor_inner.dynamic_properties
-            {
-                let mut index = *prop_index;
-                if index == usize::MAX {
-                    index = registry.index_of(*prop_type);
-                    if index == usize::MAX {
-                        warn!("missing animation function for `{}`", &prop_name);
+        let mut blend_group = descriptor
+            .animator_blending
+            .begin_blending(components.len());
+
+        let mut get_mut_components = |index: usize| -> Option<*mut u8> {
+            // NOTE: Will trigger the `Changed` event to the right types
+            components[index]
+                .as_mut()
+                .map(|c| &mut **c as *mut T as *mut u8)
+        };
+
+        for (_, layer, clip_handle, entities_map) in animator.animate() {
+            let w = layer.weight;
+            if w < 1.0e-8 {
+                continue;
+            }
+
+            if let Some(clip) = clips.get(clip_handle) {
+                let time = layer.time;
+
+                // SAFETY: Never a different thread will modify or access the same index as this one;
+                // Plus as a nice and crazy feature each property is grouped by name into their own cache line
+                // buckets, this way no cache line will be accessed by the same thread unless the same property
+                // is accessed by two different systems, which is possible but weird and will hit the performance a bit
+                let keyframes = unsafe { layer.keyframes_unsafe() };
+
+                for prop in &descriptor.dynamic_properties {
+                    let i = prop.index;
+                    if i == usize::MAX {
+                        // Missing animation function
+                        continue;
                     }
-                    *prop_index = index;
+
+                    (registry.animate_functions[i].1)(
+                        &mut get_mut_components,
+                        entities_map,
+                        &mut blend_group,
+                        keyframes,
+                        clip,
+                        time,
+                        w,
+                        &prop.path,
+                        prop.offset,
+                        prop.mask,
+                    )
+                }
+            }
+        }
+    }
+
+    // std::mem::drop(__guard);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub fn animate_asset_system<T: Asset>(
+    registry: Res<AnimatorPropertyRegistry>,
+    mut descriptor: ResMut<AnimatorDescriptor<T>>,
+    clips: Res<Assets<Clip>>,
+    animators_query: Query<&Animator>,
+    mut assets: ResMut<Assets<T>>,
+    components_query: Query<&mut Handle<T>>,
+) {
+    // let __span = tracing::info_span!("animator_transform_update_system");
+    // let __guard = __span.enter();
+
+    let mut components = vec![];
+
+    let descriptor = &mut *descriptor;
+    if descriptor.ver != registry.ver.get() {
+        // Lookup missing animate functions because `AnimatorRegistry` changed
+        for prop in &mut descriptor.dynamic_properties {
+            let mut i = prop.index;
+            if i == usize::MAX {
+                i = registry.index_of(prop.type_id);
+                if i == usize::MAX {
+                    warn!("missing animation function for `{}`", &prop.path);
                 }
+                prop.index = i;
+            }
+        }
+        descriptor.ver = registry.ver.get();
+    }
+
+    for animator in animators_query.iter() {
+        components.clear();
+
+        // ? NOTE: Lazy get each component is worse than just fetching everything at once
+        // Pre-fetch all transforms to avoid calling get_mut multiple times
+        // SAFETY: each component will be updated one at the time and this function
+        // currently has the mutability over the Transform type, so no race conditions
+        // are possible
+        unsafe {
+            for entity in animator.entities() {
+                components.push(
+                    entity
+                        .map(|entity| components_query.get_unsafe(entity).ok())
+                        .flatten(),
+                );
             }
-            descriptor_inner.ver = registry.ver.get();
         }
 
         let mut blend_group = descriptor
             .animator_blending
             .begin_blending(components.len());
 
-        // Alias `T`
-        let mut components: Box<dyn Components> = Box::new(&mut components[..]);
+        // Animate asset handle
 
         for (_, layer, clip_handle, entities_map) in animator.animate() {
             let w = layer.weight;
@@ -281,6 +383,7 @@ pub fn animate_component_system<T: Struct + Send + Sync + 'static>(
                 continue;
             }
 
+            // TODO Should I cache all the clips first hand?
             if let Some(clip) = clips.get(clip_handle) {
                 let time = layer.time;
 
@@ -290,31 +393,86 @@ pub fn animate_component_system<T: Struct + Send + Sync + 'static>(
                 // is accessed by two different systems, which is possible but weird and will hit the performance a bit
                 let keyframes = unsafe { layer.keyframes_unsafe() };
 
-                for (prop_name, _, prop_index, prop_offset, prop_mask) in
-                    &descriptor_inner.dynamic_properties
+                // Handle property is always the first one
+                let prop = &descriptor.dynamic_properties[0];
+                let prop_mask = prop.mask;
+
+                // ? NOTE: Maybe a bit incontinent to have this `animate` function inlined here,
+                // ? but it will make the code more safe and also faster
+                if let Some(curves) = clip
+                    .get(&prop.path)
+                    .map(|curve_untyped| curve_untyped.downcast_ref::<Handle<T>>())
+                    .flatten()
                 {
-                    let i = *prop_index;
+                    for (entity_index, (curve_index, curve)) in curves.iter() {
+                        let entity_index = entities_map[entity_index as usize] as usize;
+                        if let Some(ref mut component) = components[entity_index] {
+                            let kr = &mut keyframes[*curve_index];
+                            let (k, v) = curve.sample_indexed(*kr, time);
+                            *kr = k;
+
+                            let value = &mut **component;
+                            value.blend(entity_index, prop_mask, &mut blend_group, v, w);
+                        }
+                    }
+                }
+            }
+        }
+
+        // ? NOTE Only after all asset handles had been settled that, the assets properties can be animated
+        // Animate asset properties
+
+        if descriptor.dynamic_properties.len() <= 1 {
+            // This assets have no animated properties
+            continue;
+        }
+
+        let mut get_mut_components = |index: usize| -> Option<*mut u8> {
+            // NOTE: Will trigger the `Changed` event to the right assets
+            components[index]
+                .as_ref()
+                .and_then(|c| assets.get_mut(&**c))
+                .map(|a| a as *mut T as *mut u8)
+        };
+
+        for (_, layer, clip_handle, entities_map) in animator.animate() {
+            let w = layer.weight;
+            if w < 1.0e-8 {
+                continue;
+            }
+
+            if let Some(clip) = clips.get(clip_handle) {
+                let time = layer.time;
+
+                // SAFETY: Never a different thread will modify or access the same index as this one;
+                // Plus as a nice and crazy feature each property is grouped by name into their own cache line
+                // buckets, this way no cache line will be accessed by the same thread unless the same property
+                // is accessed by two different systems, which is possible but weird and will hit the performance a bit
+                let keyframes = unsafe { layer.keyframes_unsafe() };
+
+                for prop in &descriptor.dynamic_properties[1..] {
+                    let i = prop.index;
                     if i == usize::MAX {
                         // Missing animation function
                         continue;
                     }
 
                     (registry.animate_functions[i].1)(
-                        &mut *components,
+                        &mut get_mut_components,
                         entities_map,
                         &mut blend_group,
                         keyframes,
                         clip,
                         time,
                         w,
-                        prop_name,
-                        *prop_offset,
-                        *prop_mask,
+                        &prop.path,
+                        prop.offset,
+                        prop.mask,
                     )
                 }
             }
         }
     }
 
-    std::mem::drop(__guard);
+    // std::mem::drop(__guard);
 }

From 10c8f03e96804244379d6f733d18836015462827 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Wed, 30 Dec 2020 11:56:42 -0300
Subject: [PATCH 079/153] fix animate assets + lazly cache assets and clips +
 comments and docs

---
 crates/bevy_animation/src/_custom.rs          |   1 +
 .../src/{experimental.rs => _experimental.rs} |   2 +
 .../src/{props.rs => _props.rs}               |   2 +
 crates/bevy_animation/src/animator.rs         |   4 +-
 crates/bevy_animation/src/app.rs              |   5 +
 crates/bevy_animation/src/lerping.rs          |   1 +
 crates/bevy_animation/src/reflect.rs          | 109 +++++++++++++-----
 7 files changed, 92 insertions(+), 32 deletions(-)
 create mode 100644 crates/bevy_animation/src/_custom.rs
 rename crates/bevy_animation/src/{experimental.rs => _experimental.rs} (98%)
 rename crates/bevy_animation/src/{props.rs => _props.rs} (90%)

diff --git a/crates/bevy_animation/src/_custom.rs b/crates/bevy_animation/src/_custom.rs
new file mode 100644
index 0000000000000..06bb47607b239
--- /dev/null
+++ b/crates/bevy_animation/src/_custom.rs
@@ -0,0 +1 @@
+// TODO: Custom implementations for types that are very common like Transforms!
diff --git a/crates/bevy_animation/src/experimental.rs b/crates/bevy_animation/src/_experimental.rs
similarity index 98%
rename from crates/bevy_animation/src/experimental.rs
rename to crates/bevy_animation/src/_experimental.rs
index deef7cb790974..90ba32c1ec8f4 100644
--- a/crates/bevy_animation/src/experimental.rs
+++ b/crates/bevy_animation/src/_experimental.rs
@@ -1,3 +1,5 @@
+//! Contains unused experimental ideas
+
 #![allow(dead_code)]
 
 use bevy_ecs::prelude::*;
diff --git a/crates/bevy_animation/src/props.rs b/crates/bevy_animation/src/_props.rs
similarity index 90%
rename from crates/bevy_animation/src/props.rs
rename to crates/bevy_animation/src/_props.rs
index 2ef39ce9b623b..cccb453971cd6 100644
--- a/crates/bevy_animation/src/props.rs
+++ b/crates/bevy_animation/src/_props.rs
@@ -1,3 +1,5 @@
+// TODO: Implement safe property path like `Transforms::props().translation().x()` using only const, (Property validation is working at least)
+
 /// A type safe way of referring to properties that can be animated.
 ///
 /// If a type implements `AnimatedProperties` each property can be retrieved
diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index 14e341138b9e7..12872a6b66002 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -440,7 +440,8 @@ pub struct Animator {
     missing_entities: bool,
     #[reflect(ignore)]
     entities: Vec<Option<Entity>>,
-
+    // TODO: Layer groups
+    // TODO: Layer mask (apply a clip animation only in a portion of the tree)
     pub time_scale: f32,
     pub layers: Vec<Layer>,
 }
@@ -539,6 +540,7 @@ impl<'a> Iterator for LayerIterator<'a> {
 
 ///////////////////////////////////////////////////////////////////////////////
 
+/// Used to validate animated properties path and types
 #[derive(Default)]
 pub(crate) struct AnimatorRegistry {
     /// Set of registered animators for components and assets
diff --git a/crates/bevy_animation/src/app.rs b/crates/bevy_animation/src/app.rs
index 856ef6553886c..520f063cd3c99 100644
--- a/crates/bevy_animation/src/app.rs
+++ b/crates/bevy_animation/src/app.rs
@@ -13,6 +13,8 @@ use crate::{
     AnimatorPropertyRegistry,
 };
 
+// TODO: Find a way of lifting the `Default` bound on `register_animated_component` and `register_animated_asset` functions
+
 pub trait AddAnimated {
     fn register_animated_property_type<T: Lerp + Blend + Clone + 'static>(&mut self) -> &mut Self;
     fn register_animated_component<T: Component + Struct + Default>(&mut self) -> &mut Self;
@@ -59,6 +61,9 @@ impl AddAnimated for AppBuilder {
         }
     }
 
+    /// Registry an asset `T` to be animated
+    ///
+    /// **NOTE** `Handle<T>` and `Option<Handle<T>>` are also registered as animated properties
     fn register_animated_asset<T: Asset + Struct + Default>(&mut self) -> &mut Self {
         let mut registry = self
             .resources_mut()
diff --git a/crates/bevy_animation/src/lerping.rs b/crates/bevy_animation/src/lerping.rs
index 29ead00bd02e0..3cf0f617e7e62 100644
--- a/crates/bevy_animation/src/lerping.rs
+++ b/crates/bevy_animation/src/lerping.rs
@@ -2,6 +2,7 @@ use bevy_asset::{Asset, Handle, HandleUntyped};
 use bevy_math::prelude::*;
 use bevy_render::color::Color;
 
+/// Defines how a particular type will be interpolated
 pub trait Lerp {
     fn lerp(a: &Self, b: &Self, t: f32) -> Self;
 }
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index f2a78ea51652a..877d7b81d10ae 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -1,11 +1,12 @@
 //! Generic animation for any type that implements the `Reflect` trait
 
-use std::{any::type_name, any::TypeId, marker::PhantomData, num::NonZeroUsize};
+use std::{any::type_name, any::TypeId, marker::PhantomData, mem::size_of, num::NonZeroUsize};
 
 use bevy_asset::{prelude::*, Asset};
 use bevy_ecs::prelude::*;
 use bevy_math::prelude::*;
 use bevy_reflect::prelude::*;
+use bevy_render::prelude::Color;
 use tracing::warn;
 
 use crate::{
@@ -13,13 +14,21 @@ use crate::{
     AnimatorBlending, Clip,
 };
 
-// TODO: How to deal with generic types like Handle<T> or Option<T>
+// ? NOTE: Generic types like `Option<T>` must be specialized and registered with `register_animated_property_type`
+// ? in order to be animated; `Handle<T>` and `Option<Handle<T>>` are registered automatically upon registering a
+// ? animated asset `T` with `register_animated_asset`
+
 // TODO: Make sure properties are within component size bounds
 // TODO: Add tracing spans
 // TODO: Accept also `TupleStruct` and `Value`
 // TODO: Expand types like Vec2, Vec3, Vec4 and Color
 // ! FIXME: Vec2, Vec3, Vec4 doesn't implement bevy_reflect::Struct so they can't be auto expanded
-// TODO: Implement safe property path like `Transforms::props().translation().x()` using only const, (Property validation is working)
+
+/// Mask size used to blend properties, each bit corresponds to a property
+type Mask = u32;
+
+/// Number of animated properties a type can hold
+const MASK_LIMIT: usize = size_of::<Mask>() * 8;
 
 type AnimateFn = fn(
     get_mut: &mut dyn FnMut(usize) -> Option<*mut u8>,
@@ -53,9 +62,7 @@ impl Default for AnimatorPropertyRegistry {
                 (TypeId::of::<Vec3>(), animate::<Vec3>),
                 (TypeId::of::<Vec4>(), animate::<Vec4>),
                 (TypeId::of::<Quat>(), animate::<Quat>),
-                // (TypeId::of::<Color>(), animate::<Color>),
-                // (TypeId::of::<HandleUntyped>(), animate::<HandleUntyped>),
-                // TODO: How to handle generic types like Handle<T> or Option<T>
+                (TypeId::of::<Color>(), animate::<Color>),
             ],
         }
     }
@@ -107,7 +114,7 @@ fn animate<T: Lerp + Blend + Clone + 'static>(
     w: f32,
     prop_name: &str,
     prop_offset: isize,
-    prop_mask: u32,
+    prop_mask: Mask,
 ) {
     if let Some(curves) = clip
         .get(prop_name)
@@ -134,7 +141,7 @@ struct Property {
     type_id: TypeId,
     index: usize,
     offset: isize,
-    mask: u32,
+    mask: Mask,
 }
 
 // Defines how to animate an type
@@ -190,6 +197,13 @@ impl<T: Struct> AnimatorDescriptor<T> {
         // Lazy initialize the descriptor
         let origin = instance.any() as *const _ as *const u8;
         for (i, value) in instance.iter_fields().enumerate() {
+            if i >= MASK_LIMIT {
+                panic!(
+                    "`{}` reached the limit of {} animated properties",
+                    base_path, MASK_LIMIT
+                );
+            }
+
             let field_name = instance.name_at(i).unwrap();
             // NOTE: Pre calculate all the space needed to make in a single allocation (untested)
             let mut path = String::with_capacity(base_path.len() + 1 + field_name.len());
@@ -233,7 +247,8 @@ pub fn animate_component_system<T: Component>(
     // let __span = tracing::info_span!("animator_transform_update_system");
     // let __guard = __span.enter();
 
-    let mut components = vec![];
+    // TODO: Find a way to reuse these arrays in between system executions
+    let mut cached_components = vec![];
 
     let descriptor = &mut *descriptor;
     if descriptor.ver != registry.ver.get() {
@@ -252,7 +267,7 @@ pub fn animate_component_system<T: Component>(
     }
 
     for animator in animators_query.iter() {
-        components.clear();
+        cached_components.clear();
 
         // ? NOTE: Lazy get each component is worse than just fetching everything at once
         // Pre-fetch all transforms to avoid calling get_mut multiple times
@@ -261,7 +276,7 @@ pub fn animate_component_system<T: Component>(
         // are possible
         unsafe {
             for entity in animator.entities() {
-                components.push(
+                cached_components.push(
                     entity
                         .map(|entity| components_query.get_unsafe(entity).ok())
                         .flatten(),
@@ -271,11 +286,11 @@ pub fn animate_component_system<T: Component>(
 
         let mut blend_group = descriptor
             .animator_blending
-            .begin_blending(components.len());
+            .begin_blending(cached_components.len());
 
         let mut get_mut_components = |index: usize| -> Option<*mut u8> {
             // NOTE: Will trigger the `Changed` event to the right types
-            components[index]
+            cached_components[index]
                 .as_mut()
                 .map(|c| &mut **c as *mut T as *mut u8)
         };
@@ -286,6 +301,7 @@ pub fn animate_component_system<T: Component>(
                 continue;
             }
 
+            // NOTE: It's most likely that two different layers play different clips
             if let Some(clip) = clips.get(clip_handle) {
                 let time = layer.time;
 
@@ -335,7 +351,12 @@ pub fn animate_asset_system<T: Asset>(
     // let __span = tracing::info_span!("animator_transform_update_system");
     // let __guard = __span.enter();
 
-    let mut components = vec![];
+    // TODO: Find a way to reuse these arrays in between system executions
+    let mut cached_components = vec![];
+    // NOTE: Cache assets to avoid multiple hash table queries
+    let mut cached_assets = vec![];
+    // NOTE: Clips are cached here because we need to loop for the animators layers twice
+    let mut cached_clips = vec![];
 
     let descriptor = &mut *descriptor;
     if descriptor.ver != registry.ver.get() {
@@ -354,7 +375,10 @@ pub fn animate_asset_system<T: Asset>(
     }
 
     for animator in animators_query.iter() {
-        components.clear();
+        cached_clips.clear();
+        cached_clips.resize_with(animator.clips().len(), || None);
+
+        cached_components.clear();
 
         // ? NOTE: Lazy get each component is worse than just fetching everything at once
         // Pre-fetch all transforms to avoid calling get_mut multiple times
@@ -363,7 +387,7 @@ pub fn animate_asset_system<T: Asset>(
         // are possible
         unsafe {
             for entity in animator.entities() {
-                components.push(
+                cached_components.push(
                     entity
                         .map(|entity| components_query.get_unsafe(entity).ok())
                         .flatten(),
@@ -371,9 +395,12 @@ pub fn animate_asset_system<T: Asset>(
             }
         }
 
+        cached_assets.clear();
+        cached_assets.resize_with(animator.entities().len(), || None);
+
         let mut blend_group = descriptor
             .animator_blending
-            .begin_blending(components.len());
+            .begin_blending(cached_components.len());
 
         // Animate asset handle
 
@@ -383,8 +410,13 @@ pub fn animate_asset_system<T: Asset>(
                 continue;
             }
 
-            // TODO Should I cache all the clips first hand?
-            if let Some(clip) = clips.get(clip_handle) {
+            // NOTE: `animator.animate()` only yield layers with valid clip indexes
+            let clip = &mut cached_clips[layer.clip];
+            if clip.is_none() {
+                *clip = clips.get(clip_handle);
+            }
+
+            if let Some(clip) = *clip {
                 let time = layer.time;
 
                 // SAFETY: Never a different thread will modify or access the same index as this one;
@@ -394,19 +426,26 @@ pub fn animate_asset_system<T: Asset>(
                 let keyframes = unsafe { layer.keyframes_unsafe() };
 
                 // Handle property is always the first one
-                let prop = &descriptor.dynamic_properties[0];
-                let prop_mask = prop.mask;
+                let prop_name = &descriptor.short_name;
+
+                if descriptor.dynamic_properties.len() == MASK_LIMIT {
+                    panic!(
+                        "`{}` reached the limit of {} animated properties",
+                        prop_name, MASK_LIMIT
+                    );
+                }
+                let prop_mask = 1 << descriptor.dynamic_properties.len();
 
                 // ? NOTE: Maybe a bit incontinent to have this `animate` function inlined here,
                 // ? but it will make the code more safe and also faster
                 if let Some(curves) = clip
-                    .get(&prop.path)
+                    .get(prop_name)
                     .map(|curve_untyped| curve_untyped.downcast_ref::<Handle<T>>())
                     .flatten()
                 {
                     for (entity_index, (curve_index, curve)) in curves.iter() {
                         let entity_index = entities_map[entity_index as usize] as usize;
-                        if let Some(ref mut component) = components[entity_index] {
+                        if let Some(ref mut component) = cached_components[entity_index] {
                             let kr = &mut keyframes[*curve_index];
                             let (k, v) = curve.sample_indexed(*kr, time);
                             *kr = k;
@@ -422,26 +461,34 @@ pub fn animate_asset_system<T: Asset>(
         // ? NOTE Only after all asset handles had been settled that, the assets properties can be animated
         // Animate asset properties
 
-        if descriptor.dynamic_properties.len() <= 1 {
+        if descriptor.dynamic_properties.len() == 0 {
             // This assets have no animated properties
             continue;
         }
 
         let mut get_mut_components = |index: usize| -> Option<*mut u8> {
             // NOTE: Will trigger the `Changed` event to the right assets
-            components[index]
-                .as_ref()
-                .and_then(|c| assets.get_mut(&**c))
-                .map(|a| a as *mut T as *mut u8)
+
+            let asset = &mut cached_assets[index];
+            if asset.is_none() {
+                *asset = cached_components[index]
+                    .as_ref()
+                    .and_then(|c| assets.get_mut(&**c))
+                    .map(|a| a as *mut T as *mut u8)
+            }
+
+            *asset
         };
 
-        for (_, layer, clip_handle, entities_map) in animator.animate() {
+        // TODO: `animator.animate()` doesn't come for free, we might want to cache some info
+        for (_, layer, _, entities_map) in animator.animate() {
             let w = layer.weight;
             if w < 1.0e-8 {
                 continue;
             }
 
-            if let Some(clip) = clips.get(clip_handle) {
+            // NOTE: `animator.animate()` only yield layers with valid clip indexes
+            if let Some(clip) = cached_clips[layer.clip] {
                 let time = layer.time;
 
                 // SAFETY: Never a different thread will modify or access the same index as this one;
@@ -450,7 +497,7 @@ pub fn animate_asset_system<T: Asset>(
                 // is accessed by two different systems, which is possible but weird and will hit the performance a bit
                 let keyframes = unsafe { layer.keyframes_unsafe() };
 
-                for prop in &descriptor.dynamic_properties[1..] {
+                for prop in &descriptor.dynamic_properties {
                     let i = prop.index;
                     if i == usize::MAX {
                         // Missing animation function

From 66adee80a8ce0d49064724eec8b3bd30681b5846 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Wed, 30 Dec 2020 16:40:33 -0300
Subject: [PATCH 080/153] safety rules + docs

---
 crates/bevy_animation/src/app.rs     |  2 +
 crates/bevy_animation/src/reflect.rs | 86 +++++++++++++++-------------
 2 files changed, 48 insertions(+), 40 deletions(-)

diff --git a/crates/bevy_animation/src/app.rs b/crates/bevy_animation/src/app.rs
index 520f063cd3c99..7c56bc8be8a91 100644
--- a/crates/bevy_animation/src/app.rs
+++ b/crates/bevy_animation/src/app.rs
@@ -22,6 +22,7 @@ pub trait AddAnimated {
 }
 
 impl AddAnimated for AppBuilder {
+    /// Registry an property type that can be animated
     fn register_animated_property_type<T: Lerp + Blend + Clone + 'static>(&mut self) -> &mut Self {
         let mut property_registry = self
             .resources_mut()
@@ -33,6 +34,7 @@ impl AddAnimated for AppBuilder {
         self
     }
 
+    /// Registry an component `T` to be animated
     fn register_animated_component<T: Component + Struct + Default>(&mut self) -> &mut Self {
         let mut registry = self
             .resources_mut()
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index 877d7b81d10ae..55bd16b4c87b8 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -30,7 +30,7 @@ type Mask = u32;
 /// Number of animated properties a type can hold
 const MASK_LIMIT: usize = size_of::<Mask>() * 8;
 
-type AnimateFn = fn(
+type AnimateFn = unsafe fn(
     get_mut: &mut dyn FnMut(usize) -> Option<*mut u8>,
     entities_map: &[u16],
     blend_group: &mut AnimatorBlendGroup,
@@ -38,9 +38,7 @@ type AnimateFn = fn(
     clip: &Clip,
     time: f32,
     w: f32,
-    prop_name: &str,
-    prop_offset: isize,
-    prop_mask: u32,
+    prop: &Property,
 );
 
 /// Register how to animate custom types
@@ -104,7 +102,9 @@ impl AnimatorPropertyRegistry {
     }
 }
 
-fn animate<T: Lerp + Blend + Clone + 'static>(
+/// Use need to guarantee that `Property` is valid and is owned by same type
+/// of object returned by `get_mut` function
+unsafe fn animate<T: Lerp + Blend + Clone + 'static>(
     get_mut: &mut dyn FnMut(usize) -> Option<*mut u8>,
     entities_map: &[u16],
     blend_group: &mut AnimatorBlendGroup,
@@ -112,12 +112,12 @@ fn animate<T: Lerp + Blend + Clone + 'static>(
     clip: &Clip,
     time: f32,
     w: f32,
-    prop_name: &str,
-    prop_offset: isize,
-    prop_mask: Mask,
+    prop: &Property,
 ) {
+    assert_eq!(TypeId::of::<T>(), prop.type_id);
+
     if let Some(curves) = clip
-        .get(prop_name)
+        .get(&prop.path)
         .map(|curve_untyped| curve_untyped.downcast_ref::<T>())
         .flatten()
     {
@@ -128,9 +128,9 @@ fn animate<T: Lerp + Blend + Clone + 'static>(
                 let (k, v) = curve.sample_indexed(*kr, time);
                 *kr = k;
 
-                // SAFETY: prop_offset is
-                let value = unsafe { &mut *(component.offset(prop_offset) as *mut T) };
-                value.blend(entity_index, prop_mask, blend_group, v, w);
+                // Unsafe portion
+                let value = &mut *(component.offset(prop.offset) as *mut T);
+                value.blend(entity_index, prop.mask, blend_group, v, w);
             }
         }
     }
@@ -145,7 +145,7 @@ struct Property {
 }
 
 // Defines how to animate an type
-pub struct AnimatorDescriptor<T> {
+pub(crate) struct AnimatorDescriptor<T> {
     ver: usize,
     short_name: String,
     dynamic_properties: Vec<Property>,
@@ -237,7 +237,7 @@ impl<T: Struct> AnimatorDescriptor<T> {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-pub fn animate_component_system<T: Component>(
+pub(crate) fn animate_component_system<T: Component>(
     registry: Res<AnimatorPropertyRegistry>,
     mut descriptor: ResMut<AnimatorDescriptor<T>>,
     clips: Res<Assets<Clip>>,
@@ -318,18 +318,21 @@ pub fn animate_component_system<T: Component>(
                         continue;
                     }
 
-                    (registry.animate_functions[i].1)(
-                        &mut get_mut_components,
-                        entities_map,
-                        &mut blend_group,
-                        keyframes,
-                        clip,
-                        time,
-                        w,
-                        &prop.path,
-                        prop.offset,
-                        prop.mask,
-                    )
+                    // SAFETY: Components type matches with the ones returned by `get_mut_components`
+                    // and each property is generates internally by `AnimatorDescriptor<T>` which was
+                    // it's own checks to guarantee that they are valid
+                    unsafe {
+                        (registry.animate_functions[i].1)(
+                            &mut get_mut_components,
+                            entities_map,
+                            &mut blend_group,
+                            keyframes,
+                            clip,
+                            time,
+                            w,
+                            &prop,
+                        )
+                    }
                 }
             }
         }
@@ -340,7 +343,7 @@ pub fn animate_component_system<T: Component>(
 
 ///////////////////////////////////////////////////////////////////////////////
 
-pub fn animate_asset_system<T: Asset>(
+pub(crate) fn animate_asset_system<T: Asset>(
     registry: Res<AnimatorPropertyRegistry>,
     mut descriptor: ResMut<AnimatorDescriptor<T>>,
     clips: Res<Assets<Clip>>,
@@ -480,7 +483,7 @@ pub fn animate_asset_system<T: Asset>(
             *asset
         };
 
-        // TODO: `animator.animate()` doesn't come for free, we might want to cache some info
+        // TODO: `animator.animate()` doesn't come for free, might want to cache some info
         for (_, layer, _, entities_map) in animator.animate() {
             let w = layer.weight;
             if w < 1.0e-8 {
@@ -504,18 +507,21 @@ pub fn animate_asset_system<T: Asset>(
                         continue;
                     }
 
-                    (registry.animate_functions[i].1)(
-                        &mut get_mut_components,
-                        entities_map,
-                        &mut blend_group,
-                        keyframes,
-                        clip,
-                        time,
-                        w,
-                        &prop.path,
-                        prop.offset,
-                        prop.mask,
-                    )
+                    // SAFETY: Components type matches with the ones returned by `get_mut_components`
+                    // and each property is generates internally by `AnimatorDescriptor<T>` which was
+                    // it's own checks to guarantee that they are valid
+                    unsafe {
+                        (registry.animate_functions[i].1)(
+                            &mut get_mut_components,
+                            entities_map,
+                            &mut blend_group,
+                            keyframes,
+                            clip,
+                            time,
+                            w,
+                            &prop,
+                        )
+                    }
                 }
             }
         }

From 4b055191c522201d9b03c3fe481496089c4c6aae Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Wed, 30 Dec 2020 16:56:31 -0300
Subject: [PATCH 081/153] extra assert

---
 crates/bevy_animation/src/reflect.rs | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index 55bd16b4c87b8..663016545c8df 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -18,7 +18,6 @@ use crate::{
 // ? in order to be animated; `Handle<T>` and `Option<Handle<T>>` are registered automatically upon registering a
 // ? animated asset `T` with `register_animated_asset`
 
-// TODO: Make sure properties are within component size bounds
 // TODO: Add tracing spans
 // TODO: Accept also `TupleStruct` and `Value`
 // TODO: Expand types like Vec2, Vec3, Vec4 and Color
@@ -213,8 +212,18 @@ impl<T: Struct> AnimatorDescriptor<T> {
 
             let type_id = value.type_id();
 
-            // SAFETY: Is be less than size_of::<T>() so it won't be crazy high
-            let offset = unsafe { (value.any() as *const _ as *const u8).offset_from(origin) };
+            // SAFETY: Is less than size_of::<T>() witch is expected to be very low compared to isize::MAX;
+            // the resulted offset is also guaranteed to be inside the component
+            let offset = unsafe {
+                let ptr = value.any() as *const _ as *const u8;
+                assert!(
+                    ptr >= origin && ptr < origin.add(size_of::<T>()),
+                    "property '{}' offset isn't within struct bounds [0; {}]",
+                    path,
+                    size_of::<T>()
+                );
+                ptr.offset_from(origin)
+            };
 
             let mask = 1 << i;
             let index = usize::MAX;

From 07532eed2bdbeb981d2348f5addb6c85fc89468e Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Thu, 31 Dec 2020 19:52:51 -0300
Subject: [PATCH 082/153] organizing a bit

---
 crates/bevy_animation/src/blending.rs | 6 ++++++
 crates/bevy_animation/src/reflect.rs  | 6 ------
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_animation/src/blending.rs b/crates/bevy_animation/src/blending.rs
index 713d1956e460e..04356dccaeb40 100644
--- a/crates/bevy_animation/src/blending.rs
+++ b/crates/bevy_animation/src/blending.rs
@@ -27,6 +27,12 @@ struct Ptr(*const u8);
 unsafe impl Send for Ptr {}
 unsafe impl Sync for Ptr {}
 
+/// Mask size used to blend properties, each bit corresponds to a property
+pub type Mask = u32;
+
+/// Number of animated properties a type can hold
+pub const MASK_LIMIT: usize = size_of::<Mask>() * 8;
+
 #[derive(Default, Debug)]
 pub struct AnimatorBlending {
     bits: Vec<u32>,
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index 663016545c8df..a6c6ac4d9a514 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -23,12 +23,6 @@ use crate::{
 // TODO: Expand types like Vec2, Vec3, Vec4 and Color
 // ! FIXME: Vec2, Vec3, Vec4 doesn't implement bevy_reflect::Struct so they can't be auto expanded
 
-/// Mask size used to blend properties, each bit corresponds to a property
-type Mask = u32;
-
-/// Number of animated properties a type can hold
-const MASK_LIMIT: usize = size_of::<Mask>() * 8;
-
 type AnimateFn = unsafe fn(
     get_mut: &mut dyn FnMut(usize) -> Option<*mut u8>,
     entities_map: &[u16],

From 80b6b87dd5184262cfdb9a4cce158fce68ae84ff Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Thu, 31 Dec 2020 19:53:40 -0300
Subject: [PATCH 083/153] useful curve links + more org

---
 crates/bevy_animation/benches/animator.rs |  9 ++-------
 crates/bevy_animation/src/animator.rs     |  6 +++---
 crates/bevy_animation/src/blending.rs     | 23 ++++++++++++-----------
 crates/bevy_animation/src/curve.rs        | 15 ++++++++++++---
 crates/bevy_animation/src/reflect.rs      | 12 ++++++++----
 5 files changed, 37 insertions(+), 28 deletions(-)

diff --git a/crates/bevy_animation/benches/animator.rs b/crates/bevy_animation/benches/animator.rs
index c4be18fda7307..8ec384fa0fc10 100644
--- a/crates/bevy_animation/benches/animator.rs
+++ b/crates/bevy_animation/benches/animator.rs
@@ -64,12 +64,7 @@ impl AnimtorTestBench {
             let mut clip_a = Clip::default();
             clip_a.add_animated_prop(
                 "@Transform.translation",
-                CurveUntyped::Vec3(Curve::from_linear(
-                    0.0,
-                    1.0,
-                    Vec3::unit_x(),
-                    -Vec3::unit_x(),
-                )),
+                CurveUntyped::Vec3(Curve::from_line(0.0, 1.0, Vec3::unit_x(), -Vec3::unit_x())),
             );
             let rot = CurveUntyped::Quat(Curve::from_constant(Quat::identity()));
             clip_a.add_animated_prop("@Transform.rotation", rot.clone());
@@ -81,7 +76,7 @@ impl AnimtorTestBench {
                 "@Transform.translation",
                 CurveUntyped::Vec3(Curve::from_constant(Vec3::zero())),
             );
-            let rot = CurveUntyped::Quat(Curve::from_linear(
+            let rot = CurveUntyped::Quat(Curve::from_line(
                 0.0,
                 1.0,
                 Quat::from_axis_angle(Vec3::unit_z(), 0.1),
diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index 12872a6b66002..e4d1e6dd80ee8 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -829,7 +829,7 @@ mod tests {
                 let mut clip_a = Clip::default();
                 clip_a.add_curve_at_path(
                     "@Transform.translation",
-                    Curve::from_linear(0.0, 1.0, Vec3::unit_x(), -Vec3::unit_x()),
+                    Curve::from_line(0.0, 1.0, Vec3::unit_x(), -Vec3::unit_x()),
                 );
                 let rot = Curve::from_constant(Quat::identity());
                 clip_a.add_curve_at_path("@Transform.rotation", rot.clone());
@@ -841,7 +841,7 @@ mod tests {
                     "@Transform.translation",
                     Curve::from_constant(Vec3::zero()),
                 );
-                let rot = Curve::from_linear(
+                let rot = Curve::from_line(
                     0.0,
                     1.0,
                     Quat::from_axis_angle(Vec3::unit_z(), 0.1),
@@ -1224,7 +1224,7 @@ mod tests {
             let clip_a = clips.get_mut(clip_a_handle).unwrap();
             clip_a.add_curve_at_path(
                 "/Node3/@Transform.translation",
-                Curve::from_linear(0.0, 1.0, Vec3::unit_z(), -Vec3::unit_z()),
+                Curve::from_line(0.0, 1.0, Vec3::unit_z(), -Vec3::unit_z()),
             );
         }
 
diff --git a/crates/bevy_animation/src/blending.rs b/crates/bevy_animation/src/blending.rs
index 04356dccaeb40..02ff58cbe98ac 100644
--- a/crates/bevy_animation/src/blending.rs
+++ b/crates/bevy_animation/src/blending.rs
@@ -1,11 +1,12 @@
-use crate::lerping::Lerp;
 use bevy_asset::{Asset, Handle, HandleUntyped};
 use bevy_math::prelude::*;
 use bevy_render::color::Color;
 use fnv::FnvBuildHasher;
-use std::collections::HashMap;
+use std::{collections::HashMap, mem::size_of};
+
+use crate::lerping::Lerp;
 
-// pub struct Bit<'a>(&'a mut u32, u32);
+// pub struct Bit<'a>(&'a mut Mask, Mask);
 
 // impl<'a> Bit<'a> {
 //     #[inline(always)]
@@ -35,7 +36,7 @@ pub const MASK_LIMIT: usize = size_of::<Mask>() * 8;
 
 #[derive(Default, Debug)]
 pub struct AnimatorBlending {
-    bits: Vec<u32>,
+    bits: Vec<Mask>,
     // ? NOTE: HashMap is used here to reduce memory waste, it's slower but other wise a lot of memory won't be used
     /// Used for contest blend type
     weights: HashMap<Ptr, f32, FnvBuildHasher>,
@@ -61,7 +62,7 @@ impl<'a> AnimatorBlendGroup<'a> {
     pub fn blend_lerp<T: Lerp>(
         &mut self,
         entity_index: usize,
-        bit_mask: u32,
+        bit_mask: Mask,
         attribute: &mut T,
         value: T,
         weight: f32,
@@ -101,7 +102,7 @@ impl<'a> AnimatorBlendGroup<'a> {
 ///     fn blend(
 ///         &mut self,
 ///         entity_index: usize,
-///         bit_mask: u32,
+///         bit_mask: Mask,
 ///         blend_group: &mut AnimatorBlendGroup,
 ///         value: Self,
 ///         weight: f32,
@@ -116,7 +117,7 @@ pub trait Blend {
     fn blend(
         &mut self,
         entity_index: usize,
-        bit_mask: u32,
+        bit_mask: Mask,
         blend_group: &mut AnimatorBlendGroup,
         value: Self,
         weight: f32,
@@ -130,7 +131,7 @@ macro_rules! lerp {
             fn blend(
                 &mut self,
                 entity_index: usize,
-                bit_mask: u32,
+                bit_mask: Mask,
                 blend_group: &mut AnimatorBlendGroup,
                 value: Self,
                 weight: f32,
@@ -154,7 +155,7 @@ impl<T: Asset + 'static> Blend for Handle<T> {
     fn blend(
         &mut self,
         _: usize,
-        _: u32,
+        _: Mask,
         blend_group: &mut AnimatorBlendGroup,
         value: Self,
         weight: f32,
@@ -168,7 +169,7 @@ impl Blend for HandleUntyped {
     fn blend(
         &mut self,
         _: usize,
-        _: u32,
+        _: Mask,
         blend_group: &mut AnimatorBlendGroup,
         value: Self,
         weight: f32,
@@ -181,7 +182,7 @@ impl<T: Blend> Blend for Option<T> {
     fn blend(
         &mut self,
         entity_index: usize,
-        bit_mask: u32,
+        bit_mask: Mask,
         blend_group: &mut AnimatorBlendGroup,
         value: Self,
         weight: f32,
diff --git a/crates/bevy_animation/src/curve.rs b/crates/bevy_animation/src/curve.rs
index 5c42a4a94c6f2..51af6f322adf4 100644
--- a/crates/bevy_animation/src/curve.rs
+++ b/crates/bevy_animation/src/curve.rs
@@ -1,10 +1,15 @@
 use std::any::TypeId;
 
-use super::lerping::Lerp;
+use crate::lerping::Lerp;
 
 // TODO: Curve/Clip need a validation during deserialization because they are
 // structured as SOA (struct of arrays), so the vec's length must match
 
+// https://github.com/niklasfrykholm/blog
+// https://bitsquid.blogspot.com/search?q=animation
+// http://bitsquid.blogspot.com/2009/11/bitsquid-low-level-animation-system.html
+// http://archive.gamedev.net/archive/reference/articles/article1497.html (bit old)
+
 // TODO: impl Serialize, Deserialize
 #[derive(Default, Debug)]
 pub struct Curve<T> {
@@ -33,7 +38,11 @@ impl<T> Curve<T> {
             "samples and values must have the same length"
         );
 
-        assert!(values.len() <= u16::MAX as usize, "too many keyframes");
+        assert!(
+            values.len() <= u16::MAX as usize,
+            "limit of {} keyframes exceeded",
+            u16::MAX
+        );
 
         assert!(samples.len() > 0, "empty curve");
 
@@ -48,7 +57,7 @@ impl<T> Curve<T> {
         Self { samples, values }
     }
 
-    pub fn from_linear(t0: f32, t1: f32, v0: T, v1: T) -> Self {
+    pub fn from_line(t0: f32, t1: f32, v0: T, v1: T) -> Self {
         Self {
             samples: if t1 >= t0 { vec![t0, t1] } else { vec![t1, t0] },
             values: vec![v0, v1],
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index a6c6ac4d9a514..512204c32bf9f 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -10,8 +10,10 @@ use bevy_render::prelude::Color;
 use tracing::warn;
 
 use crate::{
-    blending::AnimatorBlendGroup, blending::Blend, help::shorten_name, lerping::Lerp, Animator,
-    AnimatorBlending, Clip,
+    blending::{AnimatorBlendGroup, Blend, Mask, MASK_LIMIT},
+    help::shorten_name,
+    lerping::Lerp,
+    Animator, AnimatorBlending, Clip,
 };
 
 // ? NOTE: Generic types like `Option<T>` must be specialized and registered with `register_animated_property_type`
@@ -97,7 +99,7 @@ impl AnimatorPropertyRegistry {
 
 /// Use need to guarantee that `Property` is valid and is owned by same type
 /// of object returned by `get_mut` function
-unsafe fn animate<T: Lerp + Blend + Clone + 'static>(
+unsafe fn animate<T>(
     get_mut: &mut dyn FnMut(usize) -> Option<*mut u8>,
     entities_map: &[u16],
     blend_group: &mut AnimatorBlendGroup,
@@ -106,7 +108,9 @@ unsafe fn animate<T: Lerp + Blend + Clone + 'static>(
     time: f32,
     w: f32,
     prop: &Property,
-) {
+) where
+    T: Lerp + Blend + Clone + 'static,
+{
     assert_eq!(TypeId::of::<T>(), prop.type_id);
 
     if let Some(curves) = clip

From 2be1d5e12f72fa18fe2aa557e2b4c632feeb0bff Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Thu, 31 Dec 2020 20:55:46 -0300
Subject: [PATCH 084/153] remove comments

---
 crates/bevy_animation/src/animator.rs | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index 12872a6b66002..7e8ca10860327 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -162,7 +162,6 @@ pub struct Clip {
     // ! fetching extra components that aren't been used
     hierarchy: Hierarchy,
     // ? NOTE: AHash performed worse than FnvHasher
-    // TODO: Change to Cow<'static, str> since it will be used quit a lot as the common case
     /// Each curve and keyframe cache index mapped by property name
     properties: HashMap<String, (usize, CurvesUntyped), FnvBuildHasher>,
     /// Number of animated properties
@@ -440,8 +439,6 @@ pub struct Animator {
     missing_entities: bool,
     #[reflect(ignore)]
     entities: Vec<Option<Entity>>,
-    // TODO: Layer groups
-    // TODO: Layer mask (apply a clip animation only in a portion of the tree)
     pub time_scale: f32,
     pub layers: Vec<Layer>,
 }
@@ -465,14 +462,13 @@ impl Animator {
         if let Some(i) = self.clips.iter().position(|c| *c == clip) {
             i
         } else {
-            // TODO: assert too many clips ...
             let i = self.clips.len();
             self.clips.push(clip);
             i
         }
     }
 
-    // TODO: remove clip (this operation will be very hard)
+    // TODO: remove clip
 
     pub fn add_layer(&mut self, clip: Handle<Clip>, weight: f32) -> usize {
         let clip = self.add_clip(clip);

From 295f4f2316fd7dd89301e232bc9b0d89ac4ec88e Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Mon, 4 Jan 2021 01:15:40 -0300
Subject: [PATCH 085/153] using quake 3 fast inverse sqrt, removed layers
 weight normalization

---
 crates/bevy_animation/src/animator.rs | 12 ------------
 crates/bevy_animation/src/curve.rs    |  1 -
 crates/bevy_animation/src/lerping.rs  | 19 ++++++++++++++++++-
 crates/bevy_animation/src/reflect.rs  |  6 +++---
 4 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index ba14192d10663..a4736e4004ab4 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -594,18 +594,6 @@ pub(crate) fn animator_update_system(
         // Time scales by component
         let delta_time = time.delta_seconds() * animator.time_scale;
 
-        let w_total = animator
-            .layers
-            .iter()
-            .fold(0.0, |w, layer| w + layer.weight);
-
-        let norm = 1.0 / w_total;
-
-        // Normalize all states weights
-        for layer in &mut animator.layers {
-            layer.weight *= norm;
-        }
-
         // Invalidate entities on parent or name changed events
         for (entity_index, ((parent_index, name), _)) in animator.hierarchy.iter().enumerate() {
             // Ignore the root entity as we don't care about it's parent nor it's name
diff --git a/crates/bevy_animation/src/curve.rs b/crates/bevy_animation/src/curve.rs
index 51af6f322adf4..7f733c1b01dae 100644
--- a/crates/bevy_animation/src/curve.rs
+++ b/crates/bevy_animation/src/curve.rs
@@ -15,7 +15,6 @@ use crate::lerping::Lerp;
 pub struct Curve<T> {
     // TODO: Step / Linear / Spline variants
     samples: Vec<f32>,
-    //tangents: Vec<(f32, f32)>,
     values: Vec<T>,
 }
 
diff --git a/crates/bevy_animation/src/lerping.rs b/crates/bevy_animation/src/lerping.rs
index 3cf0f617e7e62..cff89e72d1f2d 100644
--- a/crates/bevy_animation/src/lerping.rs
+++ b/crates/bevy_animation/src/lerping.rs
@@ -64,10 +64,27 @@ impl Lerp for Quat {
             b = -b;
         }
 
-        Vec4::lerp((*a).into(), b.into(), t).normalize().into()
+        let q = Vec4::lerp((*a).into(), b.into(), t);
+        let d = inv_sqrt(q.dot(q));
+        (q * d).into()
     }
 }
 
+/// Quake 3 fast inverse sqrt
+///
+/// Took this one from piston: https://github.com/PistonDevelopers/skeletal_animation
+fn inv_sqrt(x: f32) -> f32 {
+    let x2: f32 = x * 0.5;
+    let mut y: f32 = x;
+
+    let mut i: i32 = unsafe { std::mem::transmute(y) };
+    i = 0x5f3759df - (i >> 1);
+    y = unsafe { std::mem::transmute(i) };
+
+    y = y * (1.5 - (x2 * y * y));
+    y
+}
+
 impl<T: Asset + 'static> Lerp for Handle<T> {
     #[inline(always)]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index 512204c32bf9f..9d00b5c590df7 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -251,8 +251,8 @@ pub(crate) fn animate_component_system<T: Component>(
     animators_query: Query<&Animator>,
     components_query: Query<&mut T>,
 ) {
-    // let __span = tracing::info_span!("animator_transform_update_system");
-    // let __guard = __span.enter();
+    let __span = tracing::info_span!("animator_transform_update_system");
+    let __guard = __span.enter();
 
     // TODO: Find a way to reuse these arrays in between system executions
     let mut cached_components = vec![];
@@ -345,7 +345,7 @@ pub(crate) fn animate_component_system<T: Component>(
         }
     }
 
-    // std::mem::drop(__guard);
+    std::mem::drop(__guard);
 }
 
 ///////////////////////////////////////////////////////////////////////////////

From 16d6e186a95ddca49f0579d735624d260f0f8c2a Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Tue, 5 Jan 2021 02:14:06 -0300
Subject: [PATCH 086/153] comments

---
 crates/bevy_animation/src/_custom.rs  | 1 +
 crates/bevy_animation/src/animator.rs | 1 +
 crates/bevy_animation/src/blending.rs | 1 +
 crates/bevy_animation/src/curve.rs    | 5 ++++-
 4 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_animation/src/_custom.rs b/crates/bevy_animation/src/_custom.rs
index 06bb47607b239..1a72900d512b2 100644
--- a/crates/bevy_animation/src/_custom.rs
+++ b/crates/bevy_animation/src/_custom.rs
@@ -1 +1,2 @@
 // TODO: Custom implementations for types that are very common like Transforms!
+// TODO: Custom implementation for MorphTargets or something like it
diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index a4736e4004ab4..cd65927104a9d 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -162,6 +162,7 @@ pub struct Clip {
     // ! fetching extra components that aren't been used
     hierarchy: Hierarchy,
     // ? NOTE: AHash performed worse than FnvHasher
+    // TODO: Change to the hashbrown::raw::RawTable and use a `label!()` to make hashes constants
     /// Each curve and keyframe cache index mapped by property name
     properties: HashMap<String, (usize, CurvesUntyped), FnvBuildHasher>,
     /// Number of animated properties
diff --git a/crates/bevy_animation/src/blending.rs b/crates/bevy_animation/src/blending.rs
index 02ff58cbe98ac..0f5db5bf51b56 100644
--- a/crates/bevy_animation/src/blending.rs
+++ b/crates/bevy_animation/src/blending.rs
@@ -38,6 +38,7 @@ pub const MASK_LIMIT: usize = size_of::<Mask>() * 8;
 pub struct AnimatorBlending {
     bits: Vec<Mask>,
     // ? NOTE: HashMap is used here to reduce memory waste, it's slower but other wise a lot of memory won't be used
+    // TODO: Change to the hashbrown::raw::RawTable to use the pointers values as hashes it self
     /// Used for contest blend type
     weights: HashMap<Ptr, f32, FnvBuildHasher>,
 }
diff --git a/crates/bevy_animation/src/curve.rs b/crates/bevy_animation/src/curve.rs
index 7f733c1b01dae..f9656cf08531e 100644
--- a/crates/bevy_animation/src/curve.rs
+++ b/crates/bevy_animation/src/curve.rs
@@ -10,10 +10,13 @@ use crate::lerping::Lerp;
 // http://bitsquid.blogspot.com/2009/11/bitsquid-low-level-animation-system.html
 // http://archive.gamedev.net/archive/reference/articles/article1497.html (bit old)
 
+// http://nfrechette.github.io/2016/12/07/anim_compression_key_reduction/
+// https://github.com/nfrechette/acl
+
 // TODO: impl Serialize, Deserialize
 #[derive(Default, Debug)]
 pub struct Curve<T> {
-    // TODO: Step / Linear / Spline variants
+    // TODO: Change to frame_rate / frame_indexes to reduce memory usage
     samples: Vec<f32>,
     values: Vec<T>,
 }

From 3cb9b07232df38e4c893668a0d88c616170244f5 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Tue, 5 Jan 2021 04:53:03 -0300
Subject: [PATCH 087/153] small fixes for curve clamp

---
 crates/bevy_animation/src/curve.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_animation/src/curve.rs b/crates/bevy_animation/src/curve.rs
index f9656cf08531e..d2e06b9d631c8 100644
--- a/crates/bevy_animation/src/curve.rs
+++ b/crates/bevy_animation/src/curve.rs
@@ -130,7 +130,7 @@ where
             // Forward search
             loop {
                 if index == last_index {
-                    return (last_index, self.values.last().unwrap().clone());
+                    return (last_index, self.values[last_index as usize].clone());
                 }
                 index += 1;
 
@@ -142,7 +142,7 @@ where
             // Backward search
             loop {
                 if index == 0 {
-                    return (0, self.values.last().unwrap().clone());
+                    return (0, self.values[0].clone());
                 }
 
                 let i = index - 1;

From 1dd3c2a3deb8359c7052d39c45203360940981b9 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Wed, 6 Jan 2021 20:34:24 -0300
Subject: [PATCH 088/153] animator bench

---
 Cargo.toml                                    |  4 +
 crates/bevy_animation/Cargo.toml              |  5 +-
 crates/bevy_animation/src/bench.rs            | 76 ++++++++++++++++++
 crates/bevy_animation/src/lib.rs              | 27 ++++---
 crates/bevy_animation/src/reflect.rs          |  4 +-
 .../animations/bench_run_idle_animation.rs    | 79 +++++++++++++++++++
 6 files changed, 179 insertions(+), 16 deletions(-)
 create mode 100644 crates/bevy_animation/src/bench.rs
 create mode 100644 examples/animations/bench_run_idle_animation.rs

diff --git a/Cargo.toml b/Cargo.toml
index 945d62cc7cb57..3b8115d0d4cc9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -368,6 +368,10 @@ path = "examples/android/android.rs"
 name = "run_animation"
 path = "examples/animations/run_animation.rs"
 
+[[example]]
+name = "bench_run_idle_animation"
+path = "examples/animations/bench_run_idle_animation.rs"
+
 [package.metadata.android]
 apk_label = "Bevy Example"
 assets = "assets"
diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index 98b2b482bbd91..d447e378082cd 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -34,7 +34,4 @@ name = "animator"
 harness = false
 
 [features]
-default = []
-
-# Used to enable custom tests designed to profile certain aspects of the animation system
-extra-profiling-tests = []
\ No newline at end of file
+default = []
\ No newline at end of file
diff --git a/crates/bevy_animation/src/bench.rs b/crates/bevy_animation/src/bench.rs
new file mode 100644
index 0000000000000..4dbe18424d987
--- /dev/null
+++ b/crates/bevy_animation/src/bench.rs
@@ -0,0 +1,76 @@
+use crate::{app::AddAnimated, stage::ANIMATE};
+use bevy_app::{App, AppBuilder};
+use bevy_asset::Asset;
+use bevy_ecs::{Component, Schedule};
+use bevy_reflect::Struct;
+use bevy_transform::prelude::*;
+
+/// Bench utility
+pub struct Bench {
+    pub builder: AppBuilder,
+    pub schedule: Schedule,
+}
+
+impl Bench {
+    pub fn build() -> Self {
+        let mut builder = App::build();
+        builder
+            .add_plugin(bevy_reflect::ReflectPlugin::default())
+            .add_plugin(bevy_core::CorePlugin::default())
+            .add_plugin(bevy_app::ScheduleRunnerPlugin::default())
+            .add_plugin(bevy_asset::AssetPlugin::default())
+            .add_plugin(TransformPlugin::default())
+            .add_plugin(crate::AnimationPlugin {
+                headless: true,
+                ..Default::default()
+            });
+
+        let mut schedule = Schedule::default();
+        schedule.add_stage(ANIMATE);
+        schedule.add_system_to_stage(ANIMATE, crate::animator::animator_update_system);
+        schedule.add_system_to_stage(
+            ANIMATE,
+            crate::reflect::animate_component_system::<Transform>,
+        );
+
+        Bench { builder, schedule }
+    }
+
+    pub fn warm(&mut self) {
+        let app = &mut self.builder.app;
+        app.initialize();
+        app.update();
+    }
+
+    // fn register_animated_property_type<T: Lerp + Blend + Clone + 'static>(&mut self) -> &mut Self;
+
+    pub fn register_animated_asset<T: Asset + Struct + Default>(&mut self) -> &mut Self {
+        self.builder.register_animated_asset::<T>();
+        self.schedule
+            .add_system_to_stage(ANIMATE, crate::reflect::animate_asset_system::<T>);
+
+        self
+    }
+
+    pub fn register_animated_component<T: Component + Struct + Default>(&mut self) -> &mut Self {
+        self.builder.register_animated_component::<T>();
+        self.schedule
+            .add_system_to_stage(ANIMATE, crate::reflect::animate_component_system::<T>);
+
+        self
+    }
+
+    /// Runs only animated related systems using a custom schedule
+    pub fn run(&mut self, iterations: usize) -> &mut Self {
+        let app = &mut self.builder.app;
+        let world = &mut app.world;
+        let resources = &mut app.resources;
+
+        self.schedule.initialize(world, resources);
+        for _ in 0..iterations {
+            self.schedule.run(world, resources);
+        }
+
+        self
+    }
+}
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 6973e7d43d836..79c188b49ea66 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -7,6 +7,7 @@ mod app;
 mod help;
 mod reflect;
 //mod experimental;
+mod bench;
 mod hierarchy;
 mod skinned_mesh;
 
@@ -16,10 +17,10 @@ pub mod lerping;
 
 pub use crate::animator::*;
 pub use crate::app::*;
+pub use crate::bench::*;
 pub use crate::blending::AnimatorBlending;
 pub use crate::hierarchy::Hierarchy;
 pub use crate::reflect::AnimatorPropertyRegistry;
-pub use crate::skinned_mesh::*;
 
 pub mod prelude {
     pub use crate::animator::{Animator, Clip};
@@ -39,7 +40,10 @@ pub mod stage {
 }
 
 #[derive(Default)]
-pub struct AnimationPlugin;
+pub struct AnimationPlugin {
+    /// Headless mode (no skinning)
+    pub headless: bool,
+}
 
 impl Plugin for AnimationPlugin {
     fn build(&self, app: &mut AppBuilder) {
@@ -51,7 +55,7 @@ impl Plugin for AnimationPlugin {
             //.add_asset_loader(ClipLoader)
             .register_type::<Animator>()
             .add_system_to_stage(stage::ANIMATE, Assets::<Clip>::asset_event_system) // ? NOTE: Fix asset event handle
-            .add_system_to_stage(stage::ANIMATE, animator_update_system);
+            .add_system_to_stage(stage::ANIMATE, animator::animator_update_system);
 
         // ! FIXME: Each added animated component or asset will add a bit of overhead in the animation
         // ! system, I have no idea how big this is but I would like to make it pay only for what you use
@@ -59,13 +63,16 @@ impl Plugin for AnimationPlugin {
         app.register_animated_component::<bevy_transform::prelude::Transform>();
 
         // Skinning
-        app.add_asset::<SkinAsset>()
-            .add_asset::<SkinInstance>()
-            .register_type::<SkinComponent>()
-            .register_type::<SkinDebugger>()
-            .add_startup_system(skinning_setup)
-            .add_system_to_stage(stage::POST_UPDATE, skinning_update)
-            .add_system_to_stage(stage::POST_UPDATE, skinning_debugger_update);
+        app.add_asset::<skinned_mesh::SkinAsset>()
+            .add_asset::<skinned_mesh::SkinInstance>()
+            .register_type::<skinned_mesh::SkinComponent>()
+            .register_type::<skinned_mesh::SkinDebugger>();
+
+        if !self.headless {
+            app.add_startup_system(skinned_mesh::skinning_setup)
+                .add_system_to_stage(stage::POST_UPDATE, skinned_mesh::skinning_update)
+                .add_system_to_stage(stage::POST_UPDATE, skinned_mesh::skinning_debugger_update);
+        }
     }
 }
 
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index 9d00b5c590df7..8465f3111a10c 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -10,10 +10,10 @@ use bevy_render::prelude::Color;
 use tracing::warn;
 
 use crate::{
-    blending::{AnimatorBlendGroup, Blend, Mask, MASK_LIMIT},
+    animator::{Animator, Clip},
+    blending::{AnimatorBlendGroup, AnimatorBlending, Blend, Mask, MASK_LIMIT},
     help::shorten_name,
     lerping::Lerp,
-    Animator, AnimatorBlending, Clip,
 };
 
 // ? NOTE: Generic types like `Option<T>` must be specialized and registered with `register_animated_property_type`
diff --git a/examples/animations/bench_run_idle_animation.rs b/examples/animations/bench_run_idle_animation.rs
new file mode 100644
index 0000000000000..f73a097569203
--- /dev/null
+++ b/examples/animations/bench_run_idle_animation.rs
@@ -0,0 +1,79 @@
+use std::{mem::drop, process::exit, thread::sleep, time::Duration};
+
+use bevy::{
+    animation::{stage::ANIMATE, Animator, Clip},
+    asset::{AssetServerSettings, LoadState},
+    ecs::Schedule,
+    prelude::*,
+    render::{pipeline::RenderPipelines, render_graph::base::MainPass},
+};
+
+fn main() {
+    let mut pwd = std::env::current_dir()
+        .unwrap()
+        .to_str()
+        .unwrap()
+        .to_owned();
+    pwd.push_str("/assets");
+
+    let mut bench = bevy::animation::Bench::build();
+    bench
+        .builder
+        // Asset folder
+        .add_resource(AssetServerSettings { asset_folder: pwd })
+        // To load
+        .add_plugin(bevy::scene::ScenePlugin::default())
+        .add_plugin(bevy::gltf::GltfPlugin::default())
+        // These are need to load the GLTF
+        .add_asset::<Mesh>()
+        .register_type::<Draw>()
+        .register_type::<MainPass>()
+        .register_type::<Visible>()
+        .register_type::<RenderPipelines>()
+        .add_asset::<StandardMaterial>();
+
+    bench.warm();
+
+    let app = &mut bench.builder.app;
+    let asset_server = app.resources.get::<AssetServer>().unwrap();
+    let scene: Handle<Scene> = asset_server.load("models/character_medium/character_medium.gltf");
+    let idle: Handle<Clip> = asset_server.load("models/character_medium/idle.gltf#Anim0");
+    let run: Handle<Clip> = asset_server.load("models/character_medium/run.gltf#Anim0");
+    drop(asset_server);
+
+    let t = Duration::from_millis(50);
+    for h in &[
+        scene.clone_untyped(),
+        idle.clone_untyped(),
+        run.clone_untyped(),
+    ] {
+        loop {
+            app.update();
+
+            let asset_server = app.resources.get::<AssetServer>().unwrap();
+            let state = asset_server.get_load_state(h);
+            drop(asset_server);
+
+            // println!("{:?}", state);
+            if state == LoadState::Loaded {
+                break;
+            }
+            sleep(t);
+        }
+    }
+
+    let mut spawner = app.resources.get_mut::<SceneSpawner>().unwrap();
+    spawner.spawn(scene);
+    drop(spawner);
+    app.update();
+
+    let mut ok = false;
+    for (mut animator,) in app.world.query_mut::<(&mut Animator,)>() {
+        animator.add_layer(idle.clone(), 0.5);
+        animator.add_layer(run.clone(), 0.5);
+        ok = true;
+    }
+    assert!(ok, "scene not spawned or doesn't contain an animator");
+
+    bench.run(100_000);
+}

From 29b5dffe5f8ac7ff1f4d25062362df4145619bd5 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Wed, 6 Jan 2021 20:40:02 -0300
Subject: [PATCH 089/153] fix bench asset path

---
 crates/bevy_animation/src/bench.rs              | 15 +++++++++++++--
 examples/animations/bench_run_idle_animation.rs | 11 +----------
 2 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/crates/bevy_animation/src/bench.rs b/crates/bevy_animation/src/bench.rs
index 4dbe18424d987..8b2fd24043542 100644
--- a/crates/bevy_animation/src/bench.rs
+++ b/crates/bevy_animation/src/bench.rs
@@ -1,6 +1,6 @@
 use crate::{app::AddAnimated, stage::ANIMATE};
 use bevy_app::{App, AppBuilder};
-use bevy_asset::Asset;
+use bevy_asset::{Asset, AssetServerSettings};
 use bevy_ecs::{Component, Schedule};
 use bevy_reflect::Struct;
 use bevy_transform::prelude::*;
@@ -12,9 +12,20 @@ pub struct Bench {
 }
 
 impl Bench {
-    pub fn build() -> Self {
+    pub fn build(asset_folder: Option<String>) -> Self {
+        let asset_folder = asset_folder.unwrap_or_else(|| {
+            let mut asset_folder = std::env::current_dir()
+                .unwrap()
+                .to_str()
+                .unwrap()
+                .to_owned();
+            asset_folder.push_str("/assets");
+            asset_folder
+        });
+
         let mut builder = App::build();
         builder
+            .add_resource(AssetServerSettings { asset_folder })
             .add_plugin(bevy_reflect::ReflectPlugin::default())
             .add_plugin(bevy_core::CorePlugin::default())
             .add_plugin(bevy_app::ScheduleRunnerPlugin::default())
diff --git a/examples/animations/bench_run_idle_animation.rs b/examples/animations/bench_run_idle_animation.rs
index f73a097569203..e6c04bd6869f8 100644
--- a/examples/animations/bench_run_idle_animation.rs
+++ b/examples/animations/bench_run_idle_animation.rs
@@ -9,18 +9,9 @@ use bevy::{
 };
 
 fn main() {
-    let mut pwd = std::env::current_dir()
-        .unwrap()
-        .to_str()
-        .unwrap()
-        .to_owned();
-    pwd.push_str("/assets");
-
-    let mut bench = bevy::animation::Bench::build();
+    let mut bench = bevy::animation::Bench::build(None);
     bench
         .builder
-        // Asset folder
-        .add_resource(AssetServerSettings { asset_folder: pwd })
         // To load
         .add_plugin(bevy::scene::ScenePlugin::default())
         .add_plugin(bevy::gltf::GltfPlugin::default())

From cf0307d64e430842d5c0de2614f15bfd6750c639 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Thu, 7 Jan 2021 00:53:32 -0300
Subject: [PATCH 090/153] animator bench

---
 benches/Cargo.toml                            |   5 +
 benches/benches/bevy_animation/tick.rs        | 176 ++++++++++++++++++
 crates/bevy_animation/Cargo.toml              |   7 -
 crates/bevy_animation/benches/animator.rs     | 159 ----------------
 .../animations/bench_run_idle_animation.rs    |   7 +-
 5 files changed, 184 insertions(+), 170 deletions(-)
 create mode 100644 benches/benches/bevy_animation/tick.rs
 delete mode 100644 crates/bevy_animation/benches/animator.rs

diff --git a/benches/Cargo.toml b/benches/Cargo.toml
index 5e318eadf3047..a1748fea33922 100644
--- a/benches/Cargo.toml
+++ b/benches/Cargo.toml
@@ -12,3 +12,8 @@ bevy = { path = "../" }
 name = "iter"
 path = "benches/bevy_tasks/iter.rs"
 harness = false
+
+[[bench]]
+name = "animation-tick"
+path = "benches/bevy_animation/tick.rs"
+harness = false
diff --git a/benches/benches/bevy_animation/tick.rs b/benches/benches/bevy_animation/tick.rs
new file mode 100644
index 0000000000000..511c089cb6d28
--- /dev/null
+++ b/benches/benches/bevy_animation/tick.rs
@@ -0,0 +1,176 @@
+use std::{mem::drop, thread::sleep, time::Duration};
+
+use bevy::{
+    animation::{Animator, Clip},
+    asset::LoadState,
+    prelude::*,
+    render::{pipeline::RenderPipelines, render_graph::base::MainPass},
+};
+
+use criterion::{
+    black_box, criterion_group, criterion_main, BatchSize, Criterion, ParameterizedBenchmark,
+};
+
+const LEN: usize = 1_000;
+const TICKS: usize = 1_000;
+const WARM_UP_TIME: Duration = Duration::from_secs(5);
+const MEASUREMENT_TIME: Duration = Duration::from_secs(35);
+
+fn criterion_benchmark(c: &mut Criterion) {
+    c.bench(
+        "animation",
+        ParameterizedBenchmark::new(
+            "tick",
+            |b, _| {
+                b.iter_batched(
+                    run_idle_setup_bench,
+                    |mut value| {
+                        black_box(value.run(black_box(TICKS)));
+                    },
+                    BatchSize::NumIterations(LEN as u64),
+                )
+            },
+            vec![()],
+        )
+        .warm_up_time(WARM_UP_TIME)
+        .measurement_time(MEASUREMENT_TIME),
+    );
+}
+
+fn run_idle_setup_bench() -> bevy::animation::Bench {
+    let mut asset_folder = std::env::current_dir().unwrap();
+    asset_folder.pop();
+    let mut asset_folder = asset_folder.to_str().unwrap().to_owned();
+    asset_folder.push_str("/assets");
+
+    let mut bench = bevy::animation::Bench::build(Some(asset_folder));
+    bench
+        .builder
+        // To load
+        .add_plugin(bevy::scene::ScenePlugin::default())
+        .add_plugin(bevy::gltf::GltfPlugin::default())
+        // These are need to load the GLTF
+        .add_asset::<Mesh>()
+        .register_type::<Draw>()
+        .register_type::<MainPass>()
+        .register_type::<Visible>()
+        .register_type::<RenderPipelines>()
+        .add_asset::<StandardMaterial>();
+
+    bench.warm();
+
+    let app = &mut bench.builder.app;
+    let asset_server = app.resources.get::<AssetServer>().unwrap();
+    let scene: Handle<Scene> = asset_server.load("models/character_medium/character_medium.gltf");
+    let idle: Handle<Clip> = asset_server.load("models/character_medium/idle.gltf#Anim0");
+    let run: Handle<Clip> = asset_server.load("models/character_medium/run.gltf#Anim0");
+    drop(asset_server);
+
+    let t = Duration::from_millis(50);
+    for h in &[
+        scene.clone_untyped(),
+        idle.clone_untyped(),
+        run.clone_untyped(),
+    ] {
+        loop {
+            app.update();
+
+            let asset_server = app.resources.get::<AssetServer>().unwrap();
+            let state = asset_server.get_load_state(h);
+            drop(asset_server);
+
+            // println!("{:?}", state);
+            if state == LoadState::Loaded {
+                break;
+            }
+            sleep(t);
+        }
+    }
+
+    let mut spawner = app.resources.get_mut::<SceneSpawner>().unwrap();
+    spawner.spawn(scene);
+    drop(spawner);
+    app.update();
+
+    let mut ok = false;
+    for (mut animator,) in app.world.query_mut::<(&mut Animator,)>() {
+        animator.add_layer(idle.clone(), 0.5);
+        animator.add_layer(run.clone(), 0.5);
+        ok = true;
+    }
+    assert!(ok, "scene not spawned or doesn't contain an animator");
+
+    bench
+}
+
+// fn simple_setup_bench() -> bevy::animation::Bench {
+//     let mut b = bevy::animation::Bench::build(None);
+
+//     let mut world = World::new();
+//     let mut world_builder = world.build();
+//     let base = (
+//         GlobalTransform::default(),
+//         Transform::from_translation(Vec3::new(0.0, 1.0, 0.0)),
+//     );
+
+//     // Create animator and assign some clips
+//     let mut animator = Animator::default();
+//     {
+//         let mut clip_a = Clip::default();
+//         clip_a.add_curve_at_path(
+//             "@Transform.translation",
+//             Curve::from_line(0.0, 1.0, Vec3::unit_x(), -Vec3::unit_x()),
+//         );
+//         let rot = Curve::from_constant(Quat::identity());
+//         clip_a.add_curve_at_path("@Transform.rotation", rot.clone());
+//         clip_a.add_curve_at_path("/Hode1@Transform.rotation", rot.clone());
+//         clip_a.add_curve_at_path("/Node1/Node2@Transform.rotation", rot);
+
+//         let mut clip_b = Clip::default();
+//         clip_b.add_curve_at_path("@Transform.translation", Curve::from_constant(Vec3::zero()));
+//         let rot = Curve::from_line(
+//             0.0,
+//             1.0,
+//             Quat::from_axis_angle(Vec3::unit_z(), 0.1),
+//             Quat::from_axis_angle(Vec3::unit_z(), -0.1),
+//         );
+//         clip_b.add_curve_at_path("@Transform.rotation", rot.clone());
+//         clip_b.add_curve_at_path("/Hode1@Transform.rotation", rot.clone());
+//         clip_b.add_curve_at_path("/Node1/Node2@Transform.rotation", rot);
+
+//         let mut clips = b.builder.resources_mut().get_mut::<Assets<Clip>>().unwrap();
+//         let clip_a = clips.add(clip_a);
+//         let clip_b = clips.add(clip_b);
+
+//         animator.add_layer(clip_a, 0.5);
+//         animator.add_layer(clip_b, 0.5);
+//     }
+
+//     world_builder
+//         .spawn(base.clone())
+//         .with(Name::from_str("Root"))
+//         .with(animator)
+//         .with_children(|world_builder| {
+//             world_builder
+//                 .spawn(base.clone())
+//                 .with(Name::from_str("Node1"))
+//                 .with_children(|world_builder| {
+//                     world_builder
+//                         .spawn(base.clone())
+//                         .with(Name::from_str("Node2"))
+//                         .with_children(|world_builder| {
+//                             world_builder
+//                                 .spawn(base.clone())
+//                                 .with(Name::from_str("Node3"));
+//                         });
+//                 });
+//         });
+
+//     b.builder.set_world(world);
+//     b.warm();
+
+//     b
+// }
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index d447e378082cd..6b125c88ec2e2 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -26,12 +26,5 @@ float-cmp = "0.8.0"
 fnv = "1.0.7"
 tracing = "0.1.21"
 
-[dev-dependencies]
-criterion = "0.3.3"
-
-[[bench]]
-name = "animator"
-harness = false
-
 [features]
 default = []
\ No newline at end of file
diff --git a/crates/bevy_animation/benches/animator.rs b/crates/bevy_animation/benches/animator.rs
deleted file mode 100644
index 8ec384fa0fc10..0000000000000
--- a/crates/bevy_animation/benches/animator.rs
+++ /dev/null
@@ -1,159 +0,0 @@
-use bevy_animation::prelude::*;
-use bevy_asset::prelude::*;
-use bevy_core::prelude::*;
-use bevy_ecs::prelude::*;
-use bevy_math::prelude::*;
-use bevy_transform::prelude::*;
-use core::time::Duration;
-
-use criterion::{
-    black_box, criterion_group, criterion_main, BatchSize, Criterion, ParameterizedBenchmark,
-};
-
-const LEN: usize = 100_000;
-const TICKS: usize = 100_000;
-const WARM_UP_TIME: Duration = Duration::from_secs(5);
-const MEASUREMENT_TIME: Duration = Duration::from_secs(55);
-
-fn criterion_benchmark(c: &mut Criterion) {
-    c.bench(
-        "animator",
-        ParameterizedBenchmark::new(
-            "update",
-            |b, _| {
-                b.iter_batched(
-                    || AnimtorTestBench::new(),
-                    |mut value| black_box(value.update(black_box(TICKS))),
-                    BatchSize::NumIterations(LEN as u64),
-                )
-            },
-            vec![()],
-        )
-        .warm_up_time(WARM_UP_TIME)
-        .measurement_time(MEASUREMENT_TIME),
-    );
-}
-
-struct AnimtorTestBench {
-    app: bevy_app::App,
-    //binding_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>>,
-    update_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>>,
-}
-
-impl AnimtorTestBench {
-    fn new() -> Self {
-        let mut app_builder = bevy_app::App::build();
-        app_builder
-            .add_plugin(bevy_type_registry::TypeRegistryPlugin::default())
-            .add_plugin(bevy_core::CorePlugin::default())
-            .add_plugin(bevy_app::ScheduleRunnerPlugin::default())
-            .add_plugin(bevy_asset::AssetPlugin)
-            .add_plugin(bevy_transform::TransformPlugin)
-            .add_plugin(bevy_animation::AnimationPlugin);
-
-        let mut world = World::new();
-        let mut world_builder = world.build();
-        let base = (
-            GlobalTransform::default(),
-            Transform::from_translation(Vec3::new(0.0, 1.0, 0.0)),
-        );
-
-        // Create animator and assign some clips
-        let mut animator = Animator::default();
-        {
-            let mut clip_a = Clip::default();
-            clip_a.add_animated_prop(
-                "@Transform.translation",
-                CurveUntyped::Vec3(Curve::from_line(0.0, 1.0, Vec3::unit_x(), -Vec3::unit_x())),
-            );
-            let rot = CurveUntyped::Quat(Curve::from_constant(Quat::identity()));
-            clip_a.add_animated_prop("@Transform.rotation", rot.clone());
-            clip_a.add_animated_prop("/Hode1@Transform.rotation", rot.clone());
-            clip_a.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
-
-            let mut clip_b = Clip::default();
-            clip_b.add_animated_prop(
-                "@Transform.translation",
-                CurveUntyped::Vec3(Curve::from_constant(Vec3::zero())),
-            );
-            let rot = CurveUntyped::Quat(Curve::from_line(
-                0.0,
-                1.0,
-                Quat::from_axis_angle(Vec3::unit_z(), 0.1),
-                Quat::from_axis_angle(Vec3::unit_z(), -0.1),
-            ));
-            clip_b.add_animated_prop("@Transform.rotation", rot.clone());
-            clip_b.add_animated_prop("/Hode1@Transform.rotation", rot.clone());
-            clip_b.add_animated_prop("/Node1/Node2@Transform.rotation", rot);
-
-            let mut clips = app_builder
-                .resources_mut()
-                .get_mut::<Assets<Clip>>()
-                .unwrap();
-            let clip_a = clips.add(clip_a);
-            let clip_b = clips.add(clip_b);
-
-            animator.add_layer(clip_a, 0.5);
-            animator.add_layer(clip_b, 0.5);
-        }
-
-        world_builder
-            .spawn(base.clone())
-            .with(Name::from_str("Root"))
-            .with(animator)
-            .with_children(|world_builder| {
-                world_builder
-                    .spawn(base.clone())
-                    .with(Name::from_str("Node1"))
-                    .with_children(|world_builder| {
-                        world_builder
-                            .spawn(base.clone())
-                            .with(Name::from_str("Node2"))
-                            .with_children(|world_builder| {
-                                world_builder
-                                    .spawn(base.clone())
-                                    .with(Name::from_str("Node3"));
-                            });
-                    });
-            });
-
-        app_builder.set_world(world);
-
-        // let mut parent_update_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>> =
-        //     Box::new(bevy_transform::hierarchy::parent_update_system.system());
-
-        let mut binding_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>> =
-            Box::new(bevy_animation::animator_binding_system.system());
-
-        let update_system: Box<dyn bevy_ecs::System<Input = (), Output = ()>> =
-            Box::new(bevy_animation::animator_update_system.system());
-
-        let mut app = app_builder.app;
-
-        //parent_update_system.run((), &mut app.world, &mut app.resources);
-        binding_system.run_thread_local(&mut app.world, &mut app.resources);
-
-        Self { app, update_system }
-    }
-
-    fn update(&mut self, ticks: usize) {
-        for _ in 0..ticks {
-            // Time tick
-            {
-                let mut time = self.app.resources.get_mut::<Time>().unwrap();
-                time.delta_seconds += 0.016;
-                time.delta_seconds_f64 += 0.016;
-            }
-
-            black_box(
-                self.update_system
-                    .run_thread_local(&mut self.app.world, &mut self.app.resources),
-            );
-
-            //dbg!(app.world.get::<Transform>(root_entity).unwrap());
-        }
-    }
-}
-
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);
diff --git a/examples/animations/bench_run_idle_animation.rs b/examples/animations/bench_run_idle_animation.rs
index e6c04bd6869f8..e89cb68884037 100644
--- a/examples/animations/bench_run_idle_animation.rs
+++ b/examples/animations/bench_run_idle_animation.rs
@@ -1,9 +1,8 @@
-use std::{mem::drop, process::exit, thread::sleep, time::Duration};
+use std::{mem::drop, thread::sleep, time::Duration};
 
 use bevy::{
-    animation::{stage::ANIMATE, Animator, Clip},
-    asset::{AssetServerSettings, LoadState},
-    ecs::Schedule,
+    animation::{Animator, Clip},
+    asset::LoadState,
     prelude::*,
     render::{pipeline::RenderPipelines, render_graph::base::MainPass},
 };

From c9558439a780783ae70f0a7d05e63a7c0f25f641 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Fri, 8 Jan 2021 22:40:03 -0300
Subject: [PATCH 091/153] adding multiple track types

---
 crates/bevy_animation/src/animator.rs         |   2 +-
 crates/bevy_animation/src/app.rs              |   2 +-
 crates/bevy_animation/src/blending.rs         |   2 +-
 crates/bevy_animation/src/curve.rs            |   2 +-
 .../src/interpolate/interpolate.rs            | 160 +++++++++++++
 .../src/{lerping.rs => interpolate/lerp.rs}   |  17 +-
 crates/bevy_animation/src/interpolate/mod.rs  |   6 +
 .../bevy_animation/src/interpolate/utils.rs   |  62 +++++
 crates/bevy_animation/src/lib.rs              |   5 +-
 crates/bevy_animation/src/reflect.rs          |   2 +-
 crates/bevy_animation/src/tracks/fixed.rs     | 117 ++++++++++
 crates/bevy_animation/src/tracks/mod.rs       |  20 ++
 .../src/tracks/variable_interpolated.rs       | 219 ++++++++++++++++++
 .../src/tracks/variable_linear.rs             | 218 +++++++++++++++++
 crates/bevy_log/src/lib.rs                    |  10 +-
 perf.data                                     | Bin 0 -> 866000 bytes
 16 files changed, 817 insertions(+), 27 deletions(-)
 create mode 100644 crates/bevy_animation/src/interpolate/interpolate.rs
 rename crates/bevy_animation/src/{lerping.rs => interpolate/lerp.rs} (87%)
 create mode 100644 crates/bevy_animation/src/interpolate/mod.rs
 create mode 100644 crates/bevy_animation/src/interpolate/utils.rs
 create mode 100644 crates/bevy_animation/src/tracks/fixed.rs
 create mode 100644 crates/bevy_animation/src/tracks/mod.rs
 create mode 100644 crates/bevy_animation/src/tracks/variable_interpolated.rs
 create mode 100644 crates/bevy_animation/src/tracks/variable_linear.rs
 create mode 100644 perf.data

diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index cd65927104a9d..eee40fa1f3da7 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -15,7 +15,7 @@ use fnv::FnvBuildHasher;
 use smallvec::{smallvec, SmallVec};
 use tracing::warn;
 
-use crate::{blending::AnimatorBlending, curve::Curve, hierarchy::Hierarchy, lerping::Lerp};
+use crate::{blending::AnimatorBlending, curve::Curve, hierarchy::Hierarchy, interpolate::Lerp};
 
 // TODO: Load Clip name from gltf
 
diff --git a/crates/bevy_animation/src/app.rs b/crates/bevy_animation/src/app.rs
index 7c56bc8be8a91..5897000c2d4b2 100644
--- a/crates/bevy_animation/src/app.rs
+++ b/crates/bevy_animation/src/app.rs
@@ -9,7 +9,7 @@ use std::{
 };
 
 use crate::{
-    animator::AnimatorRegistry, blending::Blend, lerping::Lerp, reflect, stage,
+    animator::AnimatorRegistry, blending::Blend, interpolate::Lerp, reflect, stage,
     AnimatorPropertyRegistry,
 };
 
diff --git a/crates/bevy_animation/src/blending.rs b/crates/bevy_animation/src/blending.rs
index 0f5db5bf51b56..1ce82d04f6aec 100644
--- a/crates/bevy_animation/src/blending.rs
+++ b/crates/bevy_animation/src/blending.rs
@@ -4,7 +4,7 @@ use bevy_render::color::Color;
 use fnv::FnvBuildHasher;
 use std::{collections::HashMap, mem::size_of};
 
-use crate::lerping::Lerp;
+use crate::interpolate::Lerp;
 
 // pub struct Bit<'a>(&'a mut Mask, Mask);
 
diff --git a/crates/bevy_animation/src/curve.rs b/crates/bevy_animation/src/curve.rs
index d2e06b9d631c8..f6fa5c7552108 100644
--- a/crates/bevy_animation/src/curve.rs
+++ b/crates/bevy_animation/src/curve.rs
@@ -1,6 +1,6 @@
 use std::any::TypeId;
 
-use crate::lerping::Lerp;
+use crate::interpolate::Lerp;
 
 // TODO: Curve/Clip need a validation during deserialization because they are
 // structured as SOA (struct of arrays), so the vec's length must match
diff --git a/crates/bevy_animation/src/interpolate/interpolate.rs b/crates/bevy_animation/src/interpolate/interpolate.rs
new file mode 100644
index 0000000000000..f97850168f065
--- /dev/null
+++ b/crates/bevy_animation/src/interpolate/interpolate.rs
@@ -0,0 +1,160 @@
+//use bevy_asset::{Asset, Handle, HandleUntyped};
+use bevy_math::prelude::*;
+use bevy_render::color::Color;
+
+use super::utils;
+
+// http://archive.gamedev.net/archive/reference/articles/article1497.html (bit old)
+
+pub struct TangentIgnore;
+
+#[derive(Debug)]
+pub enum Interpolation<T> {
+    Step,
+    Linear,
+    /// Right tangent for the current keyframe and left tangent of the next keyframe
+    Smooth {
+        right: T,
+        left: T,
+    },
+}
+
+impl<T: Clone> Clone for Interpolation<T> {
+    fn clone(&self) -> Self {
+        match self {
+            Interpolation::Step => Interpolation::Step,
+            Interpolation::Linear => Interpolation::Linear,
+            Interpolation::Smooth { right, left } => Interpolation::Smooth {
+                right: right.clone(),
+                left: left.clone(),
+            },
+        }
+    }
+}
+
+pub trait Interpolate {
+    type Tangent;
+
+    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self;
+}
+
+impl Interpolate for bool {
+    type Tangent = TangentIgnore;
+
+    #[inline(always)]
+    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
+        let _ = interp;
+        if t > 0.99 {
+            k0.clone()
+        } else {
+            k1.clone()
+        }
+    }
+}
+
+impl Interpolate for f32 {
+    type Tangent = Self;
+
+    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
+        match interp {
+            Interpolation::Step => utils::step(t, k0, k1),
+            Interpolation::Linear => utils::lerp(t, *k0, *k1),
+            Interpolation::Smooth { right, left } => utils::catmull_rom(t, *k0, *right, *k1, *left),
+        }
+    }
+}
+
+impl Interpolate for Vec2 {
+    type Tangent = Self;
+
+    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
+        match interp {
+            Interpolation::Step => utils::step(t, k0, k1),
+            Interpolation::Linear => utils::lerp(t, *k0, *k1),
+            Interpolation::Smooth { right, left } => utils::catmull_rom(t, *k0, *right, *k1, *left),
+        }
+    }
+}
+
+impl Interpolate for Vec3 {
+    type Tangent = Self;
+
+    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
+        match interp {
+            Interpolation::Step => utils::step(t, k0, k1),
+            Interpolation::Linear => utils::lerp(t, *k0, *k1),
+            Interpolation::Smooth { right, left } => utils::catmull_rom(t, *k0, *right, *k1, *left),
+        }
+    }
+}
+
+impl Interpolate for Vec4 {
+    type Tangent = Self;
+
+    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
+        match interp {
+            Interpolation::Step => utils::step(t, k0, k1),
+            Interpolation::Linear => utils::lerp(t, *k0, *k1),
+            Interpolation::Smooth { right, left } => utils::catmull_rom(t, *k0, *right, *k1, *left),
+        }
+    }
+}
+
+impl Interpolate for Color {
+    type Tangent = Self;
+
+    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
+        match interp {
+            Interpolation::Step => utils::step(t, k0, k1),
+            Interpolation::Linear => utils::lerp(t, *k0, *k1),
+            Interpolation::Smooth { right, left } => utils::catmull_rom::<Vec4>(
+                t,
+                (*k0).into(),
+                (*right).into(),
+                (*k1).into(),
+                (*left).into(),
+            )
+            .into(),
+        }
+    }
+}
+
+impl Interpolate for Quat {
+    type Tangent = Self;
+
+    /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
+    /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
+    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
+        match interp {
+            Interpolation::Step => utils::step(t, k0, k1),
+            Interpolation::Linear => {
+                // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
+                let mut k1 = *k1;
+                if k0.dot(k1) < 0.0 {
+                    k1 = -k1;
+                }
+
+                let q = utils::lerp::<Vec4>(t, (*k0).into(), k1.into());
+                let d = utils::inv_sqrt(q.dot(q));
+                (q * d).into()
+            }
+            Interpolation::Smooth { right, left } => {
+                // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
+                let mut k1 = *k1;
+                if k0.dot(k1) < 0.0 {
+                    k1 = -k1;
+                }
+
+                let q = utils::catmull_rom::<Vec4>(
+                    t,
+                    (*k0).into(),
+                    (*right).into(),
+                    k1.into(),
+                    (*left).into(),
+                );
+                let d = utils::inv_sqrt(q.dot(q));
+                (q * d).into()
+            }
+        }
+    }
+}
diff --git a/crates/bevy_animation/src/lerping.rs b/crates/bevy_animation/src/interpolate/lerp.rs
similarity index 87%
rename from crates/bevy_animation/src/lerping.rs
rename to crates/bevy_animation/src/interpolate/lerp.rs
index cff89e72d1f2d..8d9e86bab31b4 100644
--- a/crates/bevy_animation/src/lerping.rs
+++ b/crates/bevy_animation/src/interpolate/lerp.rs
@@ -2,6 +2,8 @@ use bevy_asset::{Asset, Handle, HandleUntyped};
 use bevy_math::prelude::*;
 use bevy_render::color::Color;
 
+use super::utils::*;
+
 /// Defines how a particular type will be interpolated
 pub trait Lerp {
     fn lerp(a: &Self, b: &Self, t: f32) -> Self;
@@ -70,21 +72,6 @@ impl Lerp for Quat {
     }
 }
 
-/// Quake 3 fast inverse sqrt
-///
-/// Took this one from piston: https://github.com/PistonDevelopers/skeletal_animation
-fn inv_sqrt(x: f32) -> f32 {
-    let x2: f32 = x * 0.5;
-    let mut y: f32 = x;
-
-    let mut i: i32 = unsafe { std::mem::transmute(y) };
-    i = 0x5f3759df - (i >> 1);
-    y = unsafe { std::mem::transmute(i) };
-
-    y = y * (1.5 - (x2 * y * y));
-    y
-}
-
 impl<T: Asset + 'static> Lerp for Handle<T> {
     #[inline(always)]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
diff --git a/crates/bevy_animation/src/interpolate/mod.rs b/crates/bevy_animation/src/interpolate/mod.rs
new file mode 100644
index 0000000000000..15525e32003ee
--- /dev/null
+++ b/crates/bevy_animation/src/interpolate/mod.rs
@@ -0,0 +1,6 @@
+mod interpolate;
+mod lerp;
+pub mod utils;
+
+pub use interpolate::*;
+pub use lerp::*;
diff --git a/crates/bevy_animation/src/interpolate/utils.rs b/crates/bevy_animation/src/interpolate/utils.rs
new file mode 100644
index 0000000000000..db0b941cdfac4
--- /dev/null
+++ b/crates/bevy_animation/src/interpolate/utils.rs
@@ -0,0 +1,62 @@
+use std::ops::{Add, Div, Mul, Sub};
+
+/// Quake 3 fast inverse sqrt
+///
+/// Took this one from piston: https://github.com/PistonDevelopers/skeletal_animation
+#[inline(always)]
+pub fn inv_sqrt(x: f32) -> f32 {
+    let x2: f32 = x * 0.5;
+    let mut y: f32 = x;
+
+    let mut i: i32 = unsafe { std::mem::transmute(y) };
+    i = 0x5f3759df - (i >> 1);
+    y = unsafe { std::mem::transmute(i) };
+
+    y = y * (1.5 - (x2 * y * y));
+    y
+}
+
+#[inline(always)]
+pub fn step<T: Clone>(u: f32, k0: &T, k1: &T) -> T {
+    if u > 0.99 {
+        k0.clone()
+    } else {
+        k1.clone()
+    }
+}
+
+#[inline(always)]
+pub fn lerp<T>(u: f32, k0: T, k1: T) -> T
+where
+    T: Add<Output = T> + Mul<f32, Output = T>,
+{
+    k0 * (1.0 - u) + k1 * u
+}
+
+/// Catmull-Rom spline interpolation
+///
+/// Source: http://archive.gamedev.net/archive/reference/articles/article1497.html
+#[inline(always)]
+pub fn catmull_rom<T>(u: f32, k0: T, t0: T, k1: T, t1: T) -> T
+where
+    T: Add<Output = T> + Sub<Output = T> + Mul<f32, Output = T>,
+{
+    let u2 = u * u;
+    let u3 = u2 * u;
+    let _3u2 = 3.0 * u2;
+    let _2u3 = 2.0 * u3;
+
+    k0 * (_2u3 - _3u2 + 1.0) + k1 * (_3u2 - _2u3) + t0 * (u3 - 2.0 * u2 + u) + t1 * (u3 - u2)
+}
+
+/// Finds the tangent gradients for the Catmull-Rom spline
+///
+/// Source: http://archive.gamedev.net/archive/reference/articles/article1497.html
+#[inline(always)]
+pub fn auto_tangent<T>(t0: f32, t1: f32, t2: f32, k0: T, k1: T, k2: T) -> T
+where
+    T: Copy + Add<Output = T> + Sub<Output = T> + Mul<f32, Output = T> + Div<f32, Output = T>,
+{
+    // k'(t) = ½[k(t) - k(t-1)]/δx1 + ½[k(t+1) - k(t)]/δx2
+    ((k1 - k0) / (t1 - t0) + (k2 - k1) / (t2 - t1)) * 0.5
+}
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 79c188b49ea66..fba61996de2da 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -10,10 +10,11 @@ mod reflect;
 mod bench;
 mod hierarchy;
 mod skinned_mesh;
+mod tracks;
 
 pub mod blending;
 pub mod curve;
-pub mod lerping;
+pub mod interpolate;
 
 pub use crate::animator::*;
 pub use crate::app::*;
@@ -28,7 +29,7 @@ pub mod prelude {
     pub use crate::blending::AnimatorBlending;
     pub use crate::curve::Curve;
     pub use crate::hierarchy::Hierarchy;
-    pub use crate::lerping::Lerp;
+    pub use crate::interpolate::Lerp;
     pub use crate::reflect::AnimatorPropertyRegistry;
     pub use crate::skinned_mesh::{SkinAsset, SkinComponent, SkinDebugger};
 }
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index 8465f3111a10c..551b90d7d57de 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -13,7 +13,7 @@ use crate::{
     animator::{Animator, Clip},
     blending::{AnimatorBlendGroup, AnimatorBlending, Blend, Mask, MASK_LIMIT},
     help::shorten_name,
-    lerping::Lerp,
+    interpolate::Lerp,
 };
 
 // ? NOTE: Generic types like `Option<T>` must be specialized and registered with `register_animated_property_type`
diff --git a/crates/bevy_animation/src/tracks/fixed.rs b/crates/bevy_animation/src/tracks/fixed.rs
new file mode 100644
index 0000000000000..5e1f7741af941
--- /dev/null
+++ b/crates/bevy_animation/src/tracks/fixed.rs
@@ -0,0 +1,117 @@
+use std::any::TypeId;
+
+use crate::{interpolate::Lerp, tracks::Track};
+
+// TODO: impl Serialize, Deserialize
+/// Fixed frame rate track
+#[derive(Default, Debug)]
+pub struct TrackFixed<T> {
+    // ? NOTE: Has I learned from benches casting to f32 is quite expensive
+    // ? so frame rate and offset values must be stored as f32
+    frame_rate: f32,
+    /// Negative number of frames before the curve starts
+    negative_offset: f32,
+    keyframes: Vec<T>,
+}
+
+impl<T: Clone> Clone for TrackFixed<T> {
+    fn clone(&self) -> Self {
+        Self {
+            frame_rate: self.frame_rate,
+            negative_offset: self.negative_offset,
+            keyframes: self.keyframes.clone(),
+        }
+    }
+}
+
+impl<T> TrackFixed<T> {
+    pub fn from_keyframes(frame_rate: usize, offset: isize, keyframes: Vec<T>) -> Self {
+        let curve = Self {
+            frame_rate: frame_rate as f32,
+            negative_offset: -(offset as f32),
+            keyframes,
+        };
+
+        curve
+    }
+
+    pub fn from_constant(v: T) -> Self {
+        Self {
+            frame_rate: 30.0,
+            negative_offset: 0.0,
+            keyframes: vec![v],
+        }
+    }
+
+    // pub fn insert(&mut self, time_sample: f32, value: T) {
+    // }
+
+    // pub fn remove(&mut self, index: usize) {
+    //assert!(samples.len() > 1, "curve can't be empty");
+    // }
+
+    pub const fn frame_rate(&self) -> usize {
+        self.frame_rate as usize
+    }
+
+    pub fn offset(&self) -> isize {
+        (-self.negative_offset) as isize
+    }
+
+    // pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
+    //     self.samples.iter().copied().zip(self.keyframes.iter())
+    // }
+
+    // pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
+    //     self.samples.iter().copied().zip(self.keyframes.iter_mut())
+    // }
+}
+
+impl<T> Track for TrackFixed<T>
+where
+    T: Lerp + Clone,
+{
+    type Output = T;
+
+    fn duration(&self) -> f32 {
+        ((self.keyframes.len() as f32 - 1.0 - self.negative_offset) / self.frame_rate).max(0.0)
+    }
+
+    fn sample(&self, time: f32) -> T {
+        // Make sure to have at least one sample
+        assert!(self.keyframes.len() == 0, "curve is empty");
+
+        let t = time.mul_add(self.frame_rate, self.negative_offset);
+        if t.is_sign_negative() {
+            // Underflow clamp
+            return self.keyframes[0].clone();
+        }
+
+        let f = t.trunc();
+        let t = t - f;
+
+        let f = f as usize;
+        let f_n = self.keyframes.len() - 1;
+        if f >= f_n {
+            // Overflow clamp
+            return self.keyframes[f_n].clone();
+        }
+
+        // Lerp the value
+        // SAFETY: bounds checks are performed in the lines above
+        unsafe {
+            T::lerp(
+                self.keyframes.get_unchecked(f),
+                self.keyframes.get_unchecked(f + 1),
+                t,
+            )
+        }
+    }
+
+    /// Same as `sample` function
+    #[inline(always)]
+    fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, T) {
+        let _ = cursor;
+        (0, self.sample(time))
+    }
+}
diff --git a/crates/bevy_animation/src/tracks/mod.rs b/crates/bevy_animation/src/tracks/mod.rs
new file mode 100644
index 0000000000000..075b522d35721
--- /dev/null
+++ b/crates/bevy_animation/src/tracks/mod.rs
@@ -0,0 +1,20 @@
+mod fixed;
+mod variable_interpolated;
+mod variable_linear;
+
+pub trait Track {
+    type Output;
+
+    fn duration(&self) -> f32;
+
+    /// Easer to use sampling method that don't have time restrictions or needs
+    /// the keyframe cursor, but is more expensive always `O(n)`. Which means
+    /// sampling takes longer to evaluate as much as time get closer to curve duration
+    /// and it get worse with more keyframes.
+    fn sample(&self, time: f32) -> Self::Output;
+
+    /// Samples the curve starting from some keyframe cursor, this make the common case `O(1)`
+    ///
+    /// **NOTE** Each keyframe is indexed by a `u16` to reduce memory usage when using the keyframe caching
+    fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, Self::Output);
+}
diff --git a/crates/bevy_animation/src/tracks/variable_interpolated.rs b/crates/bevy_animation/src/tracks/variable_interpolated.rs
new file mode 100644
index 0000000000000..e268b7414e471
--- /dev/null
+++ b/crates/bevy_animation/src/tracks/variable_interpolated.rs
@@ -0,0 +1,219 @@
+use crate::{
+    interpolate::{Interpolate, Interpolation},
+    tracks::Track,
+};
+
+// TODO: Curve/Clip need a validation during deserialization because they are
+// structured as SOA (struct of arrays), so the vec's length must match
+
+// https://github.com/niklasfrykholm/blog
+// https://bitsquid.blogspot.com/search?q=animation
+// http://bitsquid.blogspot.com/2009/11/bitsquid-low-level-animation-system.html
+// http://archive.gamedev.net/archive/reference/articles/article1497.html (bit old)
+
+// http://nfrechette.github.io/2016/12/07/anim_compression_key_reduction/
+// https://github.com/nfrechette/acl
+
+// TODO: impl Serialize, Deserialize
+#[derive(Default, Debug)]
+pub struct TrackVariableInterpolated<T: Interpolate> {
+    time_stamps: Vec<f32>,
+    keyframes: Vec<T>,
+    /// Defines the interpolation for each keyframe pair
+    interpolations: Vec<Interpolation<T::Tangent>>,
+}
+
+impl<T> Clone for TrackVariableInterpolated<T>
+where
+    T: Interpolate + Clone,
+    <T as Interpolate>::Tangent: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            time_stamps: self.time_stamps.clone(),
+            keyframes: self.keyframes.clone(),
+            interpolations: self.interpolations.clone(),
+        }
+    }
+}
+
+// impl<T> TrackVariableInterpolated<T> {
+//     pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
+//         // TODO: Result?
+
+//         // Make sure both have the same length
+//         assert!(
+//             samples.len() == values.len(),
+//             "samples and values must have the same length"
+//         );
+
+//         assert!(
+//             values.len() <= u16::MAX as usize,
+//             "limit of {} keyframes exceeded",
+//             u16::MAX
+//         );
+
+//         assert!(samples.len() > 0, "empty curve");
+
+//         // Make sure the
+//         assert!(
+//             samples
+//                 .iter()
+//                 .zip(samples.iter().skip(1))
+//                 .all(|(a, b)| a < b),
+//             "time samples must be on ascending order"
+//         );
+//         Self {
+//             time_stamps: samples,
+//             keyframes: values,
+//         }
+//     }
+
+//     pub fn from_line(t0: f32, t1: f32, v0: T, v1: T) -> Self {
+//         Self {
+//             time_stamps: if t1 >= t0 { vec![t0, t1] } else { vec![t1, t0] },
+//             keyframes: vec![v0, v1],
+//         }
+//     }
+
+//     pub fn from_constant(v: T) -> Self {
+//         Self {
+//             time_stamps: vec![0.0],
+//             keyframes: vec![v],
+//         }
+//     }
+
+//     // pub fn insert(&mut self, time_sample: f32, value: T) {
+//     // }
+
+//     // pub fn remove(&mut self, index: usize) {
+//     //assert!(samples.len() > 1, "curve can't be empty");
+//     // }
+
+//     pub fn add_offset_time(&mut self, time_offset: f32) {
+//         self.time_stamps.iter_mut().for_each(|t| *t += time_offset);
+//     }
+
+//     pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
+//         self.time_stamps.iter().copied().zip(self.keyframes.iter())
+//     }
+
+//     pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
+//         self.time_stamps
+//             .iter()
+//             .copied()
+//             .zip(self.keyframes.iter_mut())
+//     }
+// }
+
+impl<T> Track for TrackVariableInterpolated<T>
+where
+    T: Interpolate + Clone + 'static,
+{
+    type Output = T;
+
+    fn duration(&self) -> f32 {
+        self.time_stamps.last().copied().unwrap_or(0.0)
+    }
+
+    fn sample(&self, time: f32) -> Self::Output {
+        // Index guessing gives a small search optimization
+        let index = if time < self.duration() * 0.5 {
+            0
+        } else {
+            self.time_stamps.len() - 1
+        };
+
+        self.sample_with_cursor(index as u16, time).1
+    }
+
+    fn sample_with_cursor(&self, mut cursor: u16, time: f32) -> (u16, Self::Output) {
+        // Adjust for the current keyframe cursor
+        let last_cursor = (self.time_stamps.len() - 1) as u16;
+
+        cursor = cursor.max(0).min(last_cursor);
+        if self.time_stamps[cursor as usize] < time {
+            // Forward search
+            loop {
+                if cursor == last_cursor {
+                    return (last_cursor, self.keyframes[last_cursor as usize].clone());
+                }
+                cursor += 1;
+
+                if self.time_stamps[cursor as usize] >= time {
+                    break;
+                }
+            }
+        } else {
+            // Backward search
+            loop {
+                if cursor == 0 {
+                    return (0, self.keyframes[0].clone());
+                }
+
+                let i = cursor - 1;
+                if self.time_stamps[i as usize] <= time {
+                    break;
+                }
+
+                cursor = i;
+            }
+        }
+
+        // Lerp the value
+        let i = cursor - 1;
+        let previous_time = self.time_stamps[i as usize];
+        let t = (time - previous_time) / (self.time_stamps[cursor as usize] - previous_time);
+        debug_assert!(t >= 0.0 && t <= 1.0, "t = {} but should be normalized", t); // Checks if it's required to normalize t
+
+        let value = T::interpolate(
+            &self.keyframes[i as usize],
+            &self.keyframes[cursor as usize],
+            &self.interpolations[i as usize],
+            t,
+        );
+
+        (cursor, value)
+    }
+}
+
+// #[cfg(test)]
+// mod tests {
+//     use super::*;
+
+//     #[test]
+//     fn curve_evaluation() {
+//         let curve = TrackVariableInterpolated::new(
+//             vec![0.0, 0.25, 0.5, 0.75, 1.0],
+//             vec![0.0, 0.5, 1.0, 1.5, 2.0],
+//         );
+//         assert_eq!(curve.sample(0.5), 1.0);
+
+//         let mut i0 = 0;
+//         let mut e0 = 0.0;
+//         for v in &[0.1, 0.3, 0.7, 0.4, 0.2, 0.0, 0.4, 0.85, 1.0] {
+//             let v = *v;
+//             let (i1, e1) = curve.sample_indexed(i0, v);
+//             assert_eq!(e1, 2.0 * v);
+//             if e1 > e0 {
+//                 assert!(i1 >= i0);
+//             } else {
+//                 assert!(i1 <= i0);
+//             }
+//             e0 = e1;
+//             i0 = i1;
+//         }
+//     }
+
+//     #[test]
+//     #[should_panic]
+//     fn curve_bad_length() {
+//         let _ = TrackVariableInterpolated::new(vec![0.0, 0.5, 1.0], vec![0.0, 1.0]);
+//     }
+
+//     #[test]
+//     #[should_panic]
+//     fn curve_time_samples_not_sorted() {
+//         let _ = TrackVariableInterpolated::new(vec![0.0, 1.5, 1.0], vec![0.0, 1.0, 2.0]);
+//     }
+// }
diff --git a/crates/bevy_animation/src/tracks/variable_linear.rs b/crates/bevy_animation/src/tracks/variable_linear.rs
new file mode 100644
index 0000000000000..274966a8f7e8f
--- /dev/null
+++ b/crates/bevy_animation/src/tracks/variable_linear.rs
@@ -0,0 +1,218 @@
+use std::any::TypeId;
+
+use crate::interpolate::Lerp;
+
+// TODO: Curve/Clip need a validation during deserialization because they are
+// structured as SOA (struct of arrays), so the vec's length must match
+
+// TODO: impl Serialize, Deserialize
+#[derive(Default, Debug)]
+pub struct TrackVariableLinear<T> {
+    time_stamps: Vec<f32>,
+    keyframes: Vec<T>,
+}
+
+impl<T: Clone> Clone for TrackVariableLinear<T> {
+    fn clone(&self) -> Self {
+        Self {
+            time_stamps: self.time_stamps.clone(),
+            keyframes: self.keyframes.clone(),
+        }
+    }
+}
+
+impl<T> TrackVariableLinear<T> {
+    pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
+        // TODO: Result?
+
+        // Make sure both have the same length
+        assert!(
+            samples.len() == values.len(),
+            "samples and values must have the same length"
+        );
+
+        assert!(
+            values.len() <= u16::MAX as usize,
+            "limit of {} keyframes exceeded",
+            u16::MAX
+        );
+
+        assert!(samples.len() > 0, "empty curve");
+
+        // Make sure the
+        assert!(
+            samples
+                .iter()
+                .zip(samples.iter().skip(1))
+                .all(|(a, b)| a < b),
+            "time samples must be on ascending order"
+        );
+        Self {
+            time_stamps: samples,
+            keyframes: values,
+        }
+    }
+
+    pub fn from_line(t0: f32, t1: f32, v0: T, v1: T) -> Self {
+        Self {
+            time_stamps: if t1 >= t0 { vec![t0, t1] } else { vec![t1, t0] },
+            keyframes: vec![v0, v1],
+        }
+    }
+
+    pub fn from_constant(v: T) -> Self {
+        Self {
+            time_stamps: vec![0.0],
+            keyframes: vec![v],
+        }
+    }
+
+    // pub fn insert(&mut self, time_sample: f32, value: T) {
+    // }
+
+    // pub fn remove(&mut self, index: usize) {
+    //assert!(samples.len() > 1, "curve can't be empty");
+    // }
+
+    pub fn duration(&self) -> f32 {
+        self.time_stamps.last().copied().unwrap_or(0.0)
+    }
+
+    pub fn add_offset_time(&mut self, time_offset: f32) {
+        self.time_stamps.iter_mut().for_each(|t| *t += time_offset);
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
+        self.time_stamps.iter().copied().zip(self.keyframes.iter())
+    }
+
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
+        self.time_stamps
+            .iter()
+            .copied()
+            .zip(self.keyframes.iter_mut())
+    }
+}
+
+impl<T> TrackVariableLinear<T>
+where
+    T: Lerp + Clone + 'static,
+{
+    // TODO: Profile sample_indexed vs sample, I want to know when use one over the other?
+
+    /// Easer to use sampling method that don't have time restrictions or needs
+    /// the keyframe index, but is more expensive always `O(n)`. Which means
+    /// sampling takes longer to evaluate as much as time get closer to curve duration
+    /// and it get worse with more keyframes.
+    pub fn sample(&self, time: f32) -> T {
+        // Index guessing gives a small search optimization
+        let index = if time < self.duration() * 0.5 {
+            0
+        } else {
+            self.time_stamps.len() - 1
+        };
+
+        self.sample_indexed(index as u16, time).1
+    }
+
+    /// Samples the curve starting from some keyframe index, this make the common case `O(1)`
+    ///
+    /// **NOTE** Each keyframe is indexed by a `u16` to reduce memory usage when using the keyframe caching
+    pub fn sample_indexed(&self, mut index: u16, time: f32) -> (u16, T) {
+        // Adjust for the current keyframe index
+        let last_index = (self.time_stamps.len() - 1) as u16;
+
+        index = index.max(0).min(last_index);
+        if self.time_stamps[index as usize] < time {
+            // Forward search
+            loop {
+                if index == last_index {
+                    return (last_index, self.keyframes[last_index as usize].clone());
+                }
+                index += 1;
+
+                if self.time_stamps[index as usize] >= time {
+                    break;
+                }
+            }
+        } else {
+            // Backward search
+            loop {
+                if index == 0 {
+                    return (0, self.keyframes[0].clone());
+                }
+
+                let i = index - 1;
+                if self.time_stamps[i as usize] <= time {
+                    break;
+                }
+
+                index = i;
+            }
+        }
+
+        // Lerp the value
+        let i = index - 1;
+        let previous_time = self.time_stamps[i as usize];
+        let t = (time - previous_time) / (self.time_stamps[index as usize] - previous_time);
+        debug_assert!(t >= 0.0 && t <= 1.0, "t = {} but should be normalized", t); // Checks if it's required to normalize t
+        let value = T::lerp(
+            &self.keyframes[i as usize],
+            &self.keyframes[index as usize],
+            t,
+        );
+
+        (index, value)
+    }
+
+    #[inline(always)]
+    pub fn value_type(&self) -> TypeId {
+        TypeId::of::<T>()
+    }
+
+    #[inline(always)]
+    pub fn value_size(&self) -> usize {
+        std::mem::size_of::<T>()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn curve_evaluation() {
+        let curve = TrackVariableLinear::new(
+            vec![0.0, 0.25, 0.5, 0.75, 1.0],
+            vec![0.0, 0.5, 1.0, 1.5, 2.0],
+        );
+        assert_eq!(curve.sample(0.5), 1.0);
+
+        let mut i0 = 0;
+        let mut e0 = 0.0;
+        for v in &[0.1, 0.3, 0.7, 0.4, 0.2, 0.0, 0.4, 0.85, 1.0] {
+            let v = *v;
+            let (i1, e1) = curve.sample_indexed(i0, v);
+            assert_eq!(e1, 2.0 * v);
+            if e1 > e0 {
+                assert!(i1 >= i0);
+            } else {
+                assert!(i1 <= i0);
+            }
+            e0 = e1;
+            i0 = i1;
+        }
+    }
+
+    #[test]
+    #[should_panic]
+    fn curve_bad_length() {
+        let _ = TrackVariableLinear::new(vec![0.0, 0.5, 1.0], vec![0.0, 1.0]);
+    }
+
+    #[test]
+    #[should_panic]
+    fn curve_time_samples_not_sorted() {
+        let _ = TrackVariableLinear::new(vec![0.0, 1.5, 1.0], vec![0.0, 1.0, 2.0]);
+    }
+}
diff --git a/crates/bevy_log/src/lib.rs b/crates/bevy_log/src/lib.rs
index 98737d513b58f..0e13a57126494 100644
--- a/crates/bevy_log/src/lib.rs
+++ b/crates/bevy_log/src/lib.rs
@@ -77,11 +77,11 @@ impl Plugin for LogPlugin {
                     .expect("Could not set global default tracing subscriber.");
             }
 
-            #[cfg(not(feature = "tracing-chrome"))]
-            {
-                bevy_utils::tracing::subscriber::set_global_default(subscriber)
-                    .expect("Could not set global default tracing subscriber.");
-            }
+            // #[cfg(not(feature = "tracing-chrome"))]
+            // {
+            //     bevy_utils::tracing::subscriber::set_global_default(subscriber)
+            //         .expect("Could not set global default tracing subscriber.");
+            // }
         }
 
         #[cfg(target_arch = "wasm32")]
diff --git a/perf.data b/perf.data
new file mode 100644
index 0000000000000000000000000000000000000000..050fe27524c263281bebfdd5114ed2fc7a600791
GIT binary patch
literal 866000
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

literal 0
HcmV?d00001


From 5e301851d5533d646a356bc294ea0e7c320c0b82 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sat, 9 Jan 2021 17:30:02 -0300
Subject: [PATCH 092/153] wide track types and benches

---
 benches/.cargo/config.toml                    |  22 ++
 benches/Cargo.toml                            |  10 +-
 .../{tick.rs => tick_run_idle_blend.rs}       |   4 +-
 .../bevy_animation/tracks_narrow_and_wide.rs  | 287 ++++++++++++++++++
 crates/bevy_animation/Cargo.toml              |   3 +
 .../src/interpolate/interpolate.rs            |  36 +--
 crates/bevy_animation/src/interpolate/lerp.rs |  76 ++++-
 .../bevy_animation/src/interpolate/utils.rs   |  57 +++-
 crates/bevy_animation/src/lib.rs              |   9 +-
 crates/bevy_animation/src/tracks/fixed.rs     |   4 +-
 crates/bevy_animation/src/tracks/mod.rs       |  38 ++-
 .../{variable_interpolated.rs => variable.rs} |   6 +-
 12 files changed, 518 insertions(+), 34 deletions(-)
 create mode 100644 benches/.cargo/config.toml
 rename benches/benches/bevy_animation/{tick.rs => tick_run_idle_blend.rs} (99%)
 create mode 100644 benches/benches/bevy_animation/tracks_narrow_and_wide.rs
 rename crates/bevy_animation/src/tracks/{variable_interpolated.rs => variable.rs} (97%)

diff --git a/benches/.cargo/config.toml b/benches/.cargo/config.toml
new file mode 100644
index 0000000000000..889aa660e8f69
--- /dev/null
+++ b/benches/.cargo/config.toml
@@ -0,0 +1,22 @@
+# Rename this file to `config.toml` to enable "fast build" configuration. Please read the notes below.
+
+# NOTE: For maximum performance, build using a nightly compiler
+# If you are using rust stable, remove the "-Zshare-generics=y" below.
+
+[target.x86_64-unknown-linux-gnu]
+linker = "/usr/bin/clang"
+rustflags = ["-Clink-arg=-fuse-ld=lld", "-Ctarget-feature=+sse2,+avx2"]#, "-Zshare-generics=y"]
+
+# NOTE: you must manually install https://github.com/michaeleisel/zld on mac. you can easily do this with the "brew" package manager:
+# `brew install michaeleisel/zld/zld`
+[target.x86_64-apple-darwin]
+rustflags = ["-C", "link-arg=-fuse-ld=/usr/local/bin/zld"]#, "-Zshare-generics=y", "-Zrun-dsymutil=no"]
+
+[target.x86_64-pc-windows-msvc]
+linker = "rust-lld.exe"
+#rustflags = ["-Zshare-generics=y"]
+
+# Optional: Uncommenting the following improves compile times, but reduces the amount of debug info to 'line number tables only'
+# In most cases the gains are negligible, but if you are on macos and have slow compile times you should see significant gains.
+#[profile.dev]
+#debug = 1
diff --git a/benches/Cargo.toml b/benches/Cargo.toml
index a1748fea33922..ce86f58d7464c 100644
--- a/benches/Cargo.toml
+++ b/benches/Cargo.toml
@@ -6,6 +6,7 @@ edition = "2018"
 
 [dev-dependencies]
 criterion = "0.3"
+rand = "0.8.1"
 bevy = { path = "../" }
 
 [[bench]]
@@ -14,6 +15,11 @@ path = "benches/bevy_tasks/iter.rs"
 harness = false
 
 [[bench]]
-name = "animation-tick"
-path = "benches/bevy_animation/tick.rs"
+name = "animation-tick-run-idle-blend"
+path = "benches/bevy_animation/tick_run_idle_blend.rs"
+harness = false
+
+[[bench]]
+name = "animation-tracks-narrow-and-wide"
+path = "benches/bevy_animation/tracks_narrow_and_wide.rs"
 harness = false
diff --git a/benches/benches/bevy_animation/tick.rs b/benches/benches/bevy_animation/tick_run_idle_blend.rs
similarity index 99%
rename from benches/benches/bevy_animation/tick.rs
rename to benches/benches/bevy_animation/tick_run_idle_blend.rs
index 511c089cb6d28..b32d3bda3b563 100644
--- a/benches/benches/bevy_animation/tick.rs
+++ b/benches/benches/bevy_animation/tick_run_idle_blend.rs
@@ -18,9 +18,9 @@ const MEASUREMENT_TIME: Duration = Duration::from_secs(35);
 
 fn criterion_benchmark(c: &mut Criterion) {
     c.bench(
-        "animation",
+        "animation/tick",
         ParameterizedBenchmark::new(
-            "tick",
+            "run-idle-blend",
             |b, _| {
                 b.iter_batched(
                     run_idle_setup_bench,
diff --git a/benches/benches/bevy_animation/tracks_narrow_and_wide.rs b/benches/benches/bevy_animation/tracks_narrow_and_wide.rs
new file mode 100644
index 0000000000000..86e8ad4925366
--- /dev/null
+++ b/benches/benches/bevy_animation/tracks_narrow_and_wide.rs
@@ -0,0 +1,287 @@
+use std::time::Duration;
+
+use bevy::{
+    animation::{
+        interpolate::utils::{Quatx4, Quatx8},
+        tracks::{Track, TrackFixed},
+        wide::{Vec3x4, Vec3x8, Vec4x4, Vec4x8},
+    },
+    prelude::*,
+};
+use rand::prelude::*;
+
+use criterion::{
+    black_box, criterion_group, criterion_main, BatchSize, Criterion, ParameterizedBenchmark,
+};
+
+const LEN: usize = 1_000;
+const TICKS: usize = 1_000;
+const WARM_UP_TIME: Duration = Duration::from_secs(1);
+const MEASUREMENT_TIME: Duration = Duration::from_secs(5);
+
+fn criterion_benchmark(c: &mut Criterion) {
+    c.bench(
+        "animation/tracks",
+        ParameterizedBenchmark::new(
+            "4/narrow",
+            |b, _| {
+                b.iter_batched(
+                    BenchNarrow4::setup,
+                    |value| {
+                        black_box(value.run(black_box(TICKS)));
+                    },
+                    BatchSize::NumIterations(LEN as u64),
+                )
+            },
+            vec![()],
+        )
+        .with_function("4/wide", |b, _| {
+            b.iter_batched(
+                BenchWide4::setup,
+                |value| {
+                    black_box(value.run(black_box(TICKS)));
+                },
+                BatchSize::NumIterations(LEN as u64),
+            )
+        })
+        .with_function("8/narrow", |b, _| {
+            b.iter_batched(
+                BenchNarrow8::setup,
+                |value| {
+                    black_box(value.run(black_box(TICKS)));
+                },
+                BatchSize::NumIterations(LEN as u64),
+            )
+        })
+        .with_function("8/wide", |b, _| {
+            b.iter_batched(
+                BenchWide8::setup,
+                |value| {
+                    black_box(value.run(black_box(TICKS)));
+                },
+                BatchSize::NumIterations(LEN as u64),
+            )
+        })
+        .warm_up_time(WARM_UP_TIME)
+        .measurement_time(MEASUREMENT_TIME),
+    );
+}
+
+struct Bench<P, R> {
+    t: [f32; 64],
+    pos: P,
+    rot: R,
+}
+
+type BenchNarrow4 = Bench<[TrackFixed<Vec3>; 4], [TrackFixed<Quat>; 4]>;
+
+impl BenchNarrow4 {
+    fn setup() -> Self {
+        let mut rng = rand::thread_rng();
+
+        let temp = TrackFixed::<Vec3>::from_keyframes(30, 0, vec![]);
+        let mut pos = [temp.clone(), temp.clone(), temp.clone(), temp.clone()];
+
+        let temp = TrackFixed::<Quat>::from_keyframes(30, 0, vec![]);
+        let mut rot = [temp.clone(), temp.clone(), temp.clone(), temp.clone()];
+
+        for i in 0..4 {
+            let mut p: Vec<Vec3> = (0..16).map(|_| Vec3::zero()).collect();
+            unsafe {
+                rng.fill(std::slice::from_raw_parts_mut(
+                    p.as_mut_ptr() as *mut f32,
+                    p.len() * 3,
+                ));
+            }
+            let mut temp = TrackFixed::from_keyframes(15, 0, p);
+            std::mem::swap(&mut pos[i], &mut temp);
+
+            let mut r: Vec<Quat> = (0..16).map(|_| Quat::identity()).collect();
+            unsafe {
+                rng.fill(std::slice::from_raw_parts_mut(
+                    r.as_mut_ptr() as *mut f32,
+                    r.len() * 4,
+                ));
+            }
+            for x in &mut r {
+                *x = x.normalize();
+            }
+            let mut temp = TrackFixed::from_keyframes(15, 0, r);
+            std::mem::swap(&mut rot[i], &mut temp);
+        }
+
+        let mut t = [0.0; 64];
+        rng.fill(&mut t);
+
+        Self { t, pos, rot }
+    }
+
+    fn run(&self, iterations: usize) {
+        for t in self.t.iter().cycle().take(iterations) {
+            for i in 0..4 {
+                black_box(self.pos[i].sample(black_box(*t)));
+                black_box(self.rot[i].sample(black_box(*t)));
+            }
+        }
+    }
+}
+
+type BenchNarrow8 = Bench<[TrackFixed<Vec3>; 8], [TrackFixed<Quat>; 8]>;
+
+impl BenchNarrow8 {
+    fn setup() -> Self {
+        let mut rng = rand::thread_rng();
+
+        let temp = TrackFixed::<Vec3>::from_keyframes(30, 0, vec![]);
+        let mut pos = [
+            temp.clone(),
+            temp.clone(),
+            temp.clone(),
+            temp.clone(),
+            temp.clone(),
+            temp.clone(),
+            temp.clone(),
+            temp.clone(),
+        ];
+
+        let temp = TrackFixed::<Quat>::from_keyframes(30, 0, vec![]);
+        let mut rot = [
+            temp.clone(),
+            temp.clone(),
+            temp.clone(),
+            temp.clone(),
+            temp.clone(),
+            temp.clone(),
+            temp.clone(),
+            temp.clone(),
+        ];
+
+        for i in 0..8 {
+            let mut p: Vec<Vec3> = (0..16).map(|_| Vec3::zero()).collect();
+            unsafe {
+                rng.fill(std::slice::from_raw_parts_mut(
+                    p.as_mut_ptr() as *mut f32,
+                    p.len() * 3,
+                ));
+            }
+            let mut temp = TrackFixed::from_keyframes(15, 0, p);
+            std::mem::swap(&mut pos[i], &mut temp);
+
+            let mut r: Vec<Quat> = (0..16).map(|_| Quat::identity()).collect();
+            unsafe {
+                rng.fill(std::slice::from_raw_parts_mut(
+                    r.as_mut_ptr() as *mut f32,
+                    r.len() * 4,
+                ));
+            }
+            for x in &mut r {
+                *x = x.normalize();
+            }
+            let mut temp = TrackFixed::from_keyframes(15, 0, r);
+            std::mem::swap(&mut rot[i], &mut temp);
+        }
+
+        let mut t = [0.0; 64];
+        rng.fill(&mut t);
+
+        Self { t, pos, rot }
+    }
+
+    fn run(&self, iterations: usize) {
+        for t in self.t.iter().cycle().take(iterations) {
+            for i in 0..8 {
+                black_box(self.pos[i].sample(black_box(*t)));
+                black_box(self.rot[i].sample(black_box(*t)));
+            }
+        }
+    }
+}
+
+type BenchWide4 = Bench<TrackFixed<Vec3x4>, TrackFixed<Quatx4>>;
+
+impl BenchWide4 {
+    fn setup() -> Self {
+        let mut rng = rand::thread_rng();
+
+        let mut p: Vec<Vec3x4> = (0..16).map(|_| Vec3x4::zero()).collect();
+        unsafe {
+            rng.fill(std::slice::from_raw_parts_mut(
+                p.as_mut_ptr() as *mut f32,
+                p.len() * 3 * 4,
+            ));
+        }
+        let pos = TrackFixed::from_keyframes(15, 0, p);
+
+        let mut r: Vec<Quatx4> = (0..16)
+            .map(|_| Quatx4(Vec4x4::new_splat(0.0, 0.0, 0.0, 1.0)))
+            .collect();
+        unsafe {
+            rng.fill(std::slice::from_raw_parts_mut(
+                r.as_mut_ptr() as *mut f32,
+                r.len() * 4 * 4,
+            ));
+        }
+        for x in &mut r {
+            x.0.normalize();
+        }
+        let rot = TrackFixed::from_keyframes(15, 0, r);
+
+        let mut t = [0.0; 64];
+        rng.fill(&mut t);
+
+        Self { t, pos, rot }
+    }
+
+    fn run(&self, iterations: usize) {
+        for t in self.t.iter().cycle().take(iterations) {
+            black_box(self.pos.sample(black_box(*t)));
+            black_box(self.rot.sample(black_box(*t)));
+        }
+    }
+}
+
+type BenchWide8 = Bench<TrackFixed<Vec3x8>, TrackFixed<Quatx8>>;
+
+impl BenchWide8 {
+    fn setup() -> Self {
+        let mut rng = rand::thread_rng();
+
+        let mut p: Vec<Vec3x8> = (0..16).map(|_| Vec3x8::zero()).collect();
+        unsafe {
+            rng.fill(std::slice::from_raw_parts_mut(
+                p.as_mut_ptr() as *mut f32,
+                p.len() * 3 * 8,
+            ));
+        }
+        let pos = TrackFixed::from_keyframes(15, 0, p);
+
+        let mut r: Vec<Quatx8> = (0..16)
+            .map(|_| Quatx8(Vec4x8::new_splat(0.0, 0.0, 0.0, 1.0)))
+            .collect();
+        unsafe {
+            rng.fill(std::slice::from_raw_parts_mut(
+                r.as_mut_ptr() as *mut f32,
+                r.len() * 4 * 8,
+            ));
+        }
+        for x in &mut r {
+            x.0.normalize();
+        }
+        let rot = TrackFixed::from_keyframes(15, 0, r);
+
+        let mut t = [0.0; 64];
+        rng.fill(&mut t);
+
+        Self { t, pos, rot }
+    }
+
+    fn run(&self, iterations: usize) {
+        for t in self.t.iter().cycle().take(iterations) {
+            black_box(self.pos.sample(black_box(*t)));
+            black_box(self.rot.sample(black_box(*t)));
+        }
+    }
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index 6b125c88ec2e2..af3e251effe2f 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -26,5 +26,8 @@ float-cmp = "0.8.0"
 fnv = "1.0.7"
 tracing = "0.1.21"
 
+ultraviolet = "0.7.5"
+wide = "0.5.5" # not the latest version of wide but maches the one used by ultravilet
+
 [features]
 default = []
\ No newline at end of file
diff --git a/crates/bevy_animation/src/interpolate/interpolate.rs b/crates/bevy_animation/src/interpolate/interpolate.rs
index f97850168f065..915b668820695 100644
--- a/crates/bevy_animation/src/interpolate/interpolate.rs
+++ b/crates/bevy_animation/src/interpolate/interpolate.rs
@@ -57,9 +57,9 @@ impl Interpolate for f32 {
 
     fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
         match interp {
-            Interpolation::Step => utils::step(t, k0, k1),
-            Interpolation::Linear => utils::lerp(t, *k0, *k1),
-            Interpolation::Smooth { right, left } => utils::catmull_rom(t, *k0, *right, *k1, *left),
+            Interpolation::Step => utils::step(k0, k1, t),
+            Interpolation::Linear => utils::lerp(t * k0, *k1, t),
+            Interpolation::Smooth { right, left } => utils::catmull_rom(*k0, *right, *k1, *left, t),
         }
     }
 }
@@ -69,9 +69,9 @@ impl Interpolate for Vec2 {
 
     fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
         match interp {
-            Interpolation::Step => utils::step(t, k0, k1),
-            Interpolation::Linear => utils::lerp(t, *k0, *k1),
-            Interpolation::Smooth { right, left } => utils::catmull_rom(t, *k0, *right, *k1, *left),
+            Interpolation::Step => utils::step(k0, k1, t),
+            Interpolation::Linear => utils::lerp(*k0, *k1, t),
+            Interpolation::Smooth { right, left } => utils::catmull_rom(*k0, *right, *k1, *left, t),
         }
     }
 }
@@ -81,9 +81,9 @@ impl Interpolate for Vec3 {
 
     fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
         match interp {
-            Interpolation::Step => utils::step(t, k0, k1),
-            Interpolation::Linear => utils::lerp(t, *k0, *k1),
-            Interpolation::Smooth { right, left } => utils::catmull_rom(t, *k0, *right, *k1, *left),
+            Interpolation::Step => utils::step(k0, k1, t),
+            Interpolation::Linear => utils::lerp(*k0, *k1, t),
+            Interpolation::Smooth { right, left } => utils::catmull_rom(*k0, *right, *k1, *left, t),
         }
     }
 }
@@ -93,9 +93,9 @@ impl Interpolate for Vec4 {
 
     fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
         match interp {
-            Interpolation::Step => utils::step(t, k0, k1),
-            Interpolation::Linear => utils::lerp(t, *k0, *k1),
-            Interpolation::Smooth { right, left } => utils::catmull_rom(t, *k0, *right, *k1, *left),
+            Interpolation::Step => utils::step(k0, k1, t),
+            Interpolation::Linear => utils::lerp(*k0, *k1, t),
+            Interpolation::Smooth { right, left } => utils::catmull_rom(*k0, *right, *k1, *left, t),
         }
     }
 }
@@ -105,14 +105,14 @@ impl Interpolate for Color {
 
     fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
         match interp {
-            Interpolation::Step => utils::step(t, k0, k1),
-            Interpolation::Linear => utils::lerp(t, *k0, *k1),
+            Interpolation::Step => utils::step(k0, k1, t),
+            Interpolation::Linear => utils::lerp(*k0, *k1, t),
             Interpolation::Smooth { right, left } => utils::catmull_rom::<Vec4>(
-                t,
                 (*k0).into(),
                 (*right).into(),
                 (*k1).into(),
                 (*left).into(),
+                t,
             )
             .into(),
         }
@@ -126,7 +126,7 @@ impl Interpolate for Quat {
     /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
     fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
         match interp {
-            Interpolation::Step => utils::step(t, k0, k1),
+            Interpolation::Step => utils::step(k0, k1, t),
             Interpolation::Linear => {
                 // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
                 let mut k1 = *k1;
@@ -134,7 +134,7 @@ impl Interpolate for Quat {
                     k1 = -k1;
                 }
 
-                let q = utils::lerp::<Vec4>(t, (*k0).into(), k1.into());
+                let q = utils::lerp::<Vec4>((*k0).into(), k1.into(), t);
                 let d = utils::inv_sqrt(q.dot(q));
                 (q * d).into()
             }
@@ -146,11 +146,11 @@ impl Interpolate for Quat {
                 }
 
                 let q = utils::catmull_rom::<Vec4>(
-                    t,
                     (*k0).into(),
                     (*right).into(),
                     k1.into(),
                     (*left).into(),
+                    t,
                 );
                 let d = utils::inv_sqrt(q.dot(q));
                 (q * d).into()
diff --git a/crates/bevy_animation/src/interpolate/lerp.rs b/crates/bevy_animation/src/interpolate/lerp.rs
index 8d9e86bab31b4..07a5efd659491 100644
--- a/crates/bevy_animation/src/interpolate/lerp.rs
+++ b/crates/bevy_animation/src/interpolate/lerp.rs
@@ -1,9 +1,12 @@
 use bevy_asset::{Asset, Handle, HandleUntyped};
 use bevy_math::prelude::*;
 use bevy_render::color::Color;
+use ultraviolet::{f32x4, f32x8, Vec3x4, Vec3x8, Vec4x4, Vec4x8};
 
 use super::utils::*;
 
+// TODO: add Rotors
+
 /// Defines how a particular type will be interpolated
 pub trait Lerp {
     fn lerp(a: &Self, b: &Self, t: f32) -> Self;
@@ -41,6 +44,20 @@ impl Lerp for Vec3 {
     }
 }
 
+impl Lerp for Vec3x4 {
+    #[inline(always)]
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        (*a) * f32x4::splat(1.0 - t) + (*b) * f32x4::splat(t)
+    }
+}
+
+impl Lerp for Vec3x8 {
+    #[inline(always)]
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        (*a) * f32x8::splat(1.0 - t) + (*b) * f32x8::splat(t)
+    }
+}
+
 impl Lerp for Vec4 {
     #[inline(always)]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
@@ -48,6 +65,20 @@ impl Lerp for Vec4 {
     }
 }
 
+impl Lerp for Vec4x4 {
+    #[inline(always)]
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        (*a) * f32x4::splat(1.0 - t) + (*b) * f32x4::splat(t)
+    }
+}
+
+impl Lerp for Vec4x8 {
+    #[inline(always)]
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        (*a) * f32x8::splat(1.0 - t) + (*b) * f32x8::splat(t)
+    }
+}
+
 impl Lerp for Color {
     #[inline(always)]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
@@ -60,8 +91,9 @@ impl Lerp for Quat {
     /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
     #[inline(always)]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
         let mut b = *b;
+
+        // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
         if a.dot(b) < 0.0 {
             b = -b;
         }
@@ -72,6 +104,48 @@ impl Lerp for Quat {
     }
 }
 
+impl Lerp for Quatx4 {
+    /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
+    /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
+    #[inline(always)]
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        let mut b = b.0;
+
+        // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
+        // Flip b sing if dot product was negative
+        let sign: f32x4 = a.0.dot(b) & f32x4::splat(-0.0);
+        b.x = b.x ^ sign;
+        b.y = b.y ^ sign;
+        b.z = b.z ^ sign;
+        b.w = b.w ^ sign;
+
+        let q = Vec4x4::lerp(&a.0, &b, t);
+        let d = inv_sqrt4(q.dot(q));
+        Quatx4(q * d)
+    }
+}
+
+impl Lerp for Quatx8 {
+    /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
+    /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
+    #[inline(always)]
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        let mut b = b.0;
+
+        // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
+        // Flip b sing if dot product was negative
+        let sign: f32x8 = a.0.dot(b) & f32x8::splat(-0.0);
+        b.x = b.x ^ sign;
+        b.y = b.y ^ sign;
+        b.z = b.z ^ sign;
+        b.w = b.w ^ sign;
+
+        let q = Vec4x8::lerp(&a.0, &b, t);
+        let d = inv_sqrt8(q.dot(q));
+        Quatx8(q * d)
+    }
+}
+
 impl<T: Asset + 'static> Lerp for Handle<T> {
     #[inline(always)]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
diff --git a/crates/bevy_animation/src/interpolate/utils.rs b/crates/bevy_animation/src/interpolate/utils.rs
index db0b941cdfac4..737beabeaab10 100644
--- a/crates/bevy_animation/src/interpolate/utils.rs
+++ b/crates/bevy_animation/src/interpolate/utils.rs
@@ -1,4 +1,27 @@
 use std::ops::{Add, Div, Mul, Sub};
+use ultraviolet::{f32x4, f32x8, Vec4x4, Vec4x8};
+use wide::{i32x4, i32x8};
+
+/// Wide quaternion
+#[derive(Debug, Clone)]
+pub struct Quatx4(pub Vec4x4);
+
+/// Wide quaternion
+#[derive(Debug, Clone)]
+pub struct Quatx8(pub Vec4x8);
+
+// macro_rules! wide_quat {
+//     ($t:tt, $) => {
+//         impl $t {
+//             pub fn identity() -> $t {
+//                 $t::splat(Vec4::new(0.0, 0.0, 0.0, 0.1))
+//             }
+//         }
+//     };
+// }
+
+// wide_quat!(Quat4);
+// wide_quat!(Quat8);
 
 /// Quake 3 fast inverse sqrt
 ///
@@ -16,8 +39,36 @@ pub fn inv_sqrt(x: f32) -> f32 {
     y
 }
 
+/// Quake 3 fast inverse sqrt for `f32x4`
+#[inline(always)]
+pub fn inv_sqrt4(x: f32x4) -> f32x4 {
+    let x2: f32x4 = x * 0.5;
+    let mut y: f32x4 = x;
+
+    let mut i: i32x4 = unsafe { std::mem::transmute(y) };
+    i = i32x4::splat(0x5f3759df) - (i >> 1);
+    y = unsafe { std::mem::transmute(i) };
+
+    y = y * (f32x4::splat(1.5) - (x2 * y * y));
+    y
+}
+
+/// Quake 3 fast inverse sqrt for `f32x8`
+#[inline(always)]
+pub fn inv_sqrt8(x: f32x8) -> f32x8 {
+    let x2: f32x8 = x * 0.5;
+    let mut y: f32x8 = x;
+
+    let mut i: i32x8 = unsafe { std::mem::transmute(y) };
+    i = i32x8::splat(0x5f3759df) - (i >> 1);
+    y = unsafe { std::mem::transmute(i) };
+
+    y = y * (f32x8::splat(1.5) - (x2 * y * y));
+    y
+}
+
 #[inline(always)]
-pub fn step<T: Clone>(u: f32, k0: &T, k1: &T) -> T {
+pub fn step<T: Clone>(k0: &T, k1: &T, u: f32) -> T {
     if u > 0.99 {
         k0.clone()
     } else {
@@ -26,7 +77,7 @@ pub fn step<T: Clone>(u: f32, k0: &T, k1: &T) -> T {
 }
 
 #[inline(always)]
-pub fn lerp<T>(u: f32, k0: T, k1: T) -> T
+pub fn lerp<T>(k0: T, k1: T, u: f32) -> T
 where
     T: Add<Output = T> + Mul<f32, Output = T>,
 {
@@ -37,7 +88,7 @@ where
 ///
 /// Source: http://archive.gamedev.net/archive/reference/articles/article1497.html
 #[inline(always)]
-pub fn catmull_rom<T>(u: f32, k0: T, t0: T, k1: T, t1: T) -> T
+pub fn catmull_rom<T>(k0: T, t0: T, k1: T, t1: T, u: f32) -> T
 where
     T: Add<Output = T> + Sub<Output = T> + Mul<f32, Output = T>,
 {
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index fba61996de2da..603b69b6aa183 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -10,11 +10,11 @@ mod reflect;
 mod bench;
 mod hierarchy;
 mod skinned_mesh;
-mod tracks;
 
 pub mod blending;
 pub mod curve;
 pub mod interpolate;
+pub mod tracks;
 
 pub use crate::animator::*;
 pub use crate::app::*;
@@ -34,6 +34,13 @@ pub mod prelude {
     pub use crate::skinned_mesh::{SkinAsset, SkinComponent, SkinDebugger};
 }
 
+/// Exports wide types
+pub mod wide {
+    pub use crate::interpolate::utils::{Quatx4, Quatx8};
+    pub use ultraviolet::vec::*;
+    pub use wide::*;
+}
+
 pub mod stage {
     pub const ANIMATE: &'static str = "animate";
     pub use bevy_app::stage::POST_UPDATE;
diff --git a/crates/bevy_animation/src/tracks/fixed.rs b/crates/bevy_animation/src/tracks/fixed.rs
index 5e1f7741af941..7e1f2f14477ba 100644
--- a/crates/bevy_animation/src/tracks/fixed.rs
+++ b/crates/bevy_animation/src/tracks/fixed.rs
@@ -1,5 +1,3 @@
-use std::any::TypeId;
-
 use crate::{interpolate::Lerp, tracks::Track};
 
 // TODO: impl Serialize, Deserialize
@@ -79,7 +77,7 @@ where
 
     fn sample(&self, time: f32) -> T {
         // Make sure to have at least one sample
-        assert!(self.keyframes.len() == 0, "curve is empty");
+        assert!(self.keyframes.len() > 0, "curve is empty");
 
         let t = time.mul_add(self.frame_rate, self.negative_offset);
         if t.is_sign_negative() {
diff --git a/crates/bevy_animation/src/tracks/mod.rs b/crates/bevy_animation/src/tracks/mod.rs
index 075b522d35721..5404f9be3784a 100644
--- a/crates/bevy_animation/src/tracks/mod.rs
+++ b/crates/bevy_animation/src/tracks/mod.rs
@@ -1,7 +1,15 @@
+// use std::any::Any;
+
 mod fixed;
-mod variable_interpolated;
+mod variable;
 mod variable_linear;
 
+pub use fixed::*;
+pub use variable::*;
+pub use variable_linear::*;
+
+//use crate::interpolate::Interpolate;
+
 pub trait Track {
     type Output;
 
@@ -18,3 +26,31 @@ pub trait Track {
     /// **NOTE** Each keyframe is indexed by a `u16` to reduce memory usage when using the keyframe caching
     fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, Self::Output);
 }
+
+// struct TrackUntypedRaw<T>(Box<dyn Track<Output = T> + Send + Sync + 'static>);
+
+// pub struct TrackUntyped {
+//     untyped: Box<dyn Any + Send + Sync + 'static>,
+// }
+
+// impl TrackUntyped {
+//     pub fn new<T>(track: T) -> Self
+//     where
+//         T: Track + Send + Sync + 'static,
+//         <T as Track>::Output: Send + Sync + 'static,
+//     {
+//         TrackUntyped {
+//             // duration: curves.calculate_duration(),
+//             // meta: CurveMeta::of::<T>(),
+//             untyped: Box::new(TrackUntypedRaw(Box::new(track))),
+//         }
+//     }
+// }
+
+// pub enum TrackEnum<T: Interpolate> {
+//     Fixed([u16; 1], TrackFixed<T>),
+//     Wide4([u16; 4], TrackFixed<T>),
+//     Wide8([u16; 8], TrackFixed<T>),
+//     VarLinear([u16; 1], TrackVariableLinear<T>),
+//     Var([u16; 1], TrackVariable<T>),
+// }
diff --git a/crates/bevy_animation/src/tracks/variable_interpolated.rs b/crates/bevy_animation/src/tracks/variable.rs
similarity index 97%
rename from crates/bevy_animation/src/tracks/variable_interpolated.rs
rename to crates/bevy_animation/src/tracks/variable.rs
index e268b7414e471..44b546ed7d010 100644
--- a/crates/bevy_animation/src/tracks/variable_interpolated.rs
+++ b/crates/bevy_animation/src/tracks/variable.rs
@@ -16,14 +16,14 @@ use crate::{
 
 // TODO: impl Serialize, Deserialize
 #[derive(Default, Debug)]
-pub struct TrackVariableInterpolated<T: Interpolate> {
+pub struct TrackVariable<T: Interpolate> {
     time_stamps: Vec<f32>,
     keyframes: Vec<T>,
     /// Defines the interpolation for each keyframe pair
     interpolations: Vec<Interpolation<T::Tangent>>,
 }
 
-impl<T> Clone for TrackVariableInterpolated<T>
+impl<T> Clone for TrackVariable<T>
 where
     T: Interpolate + Clone,
     <T as Interpolate>::Tangent: Clone,
@@ -106,7 +106,7 @@ where
 //     }
 // }
 
-impl<T> Track for TrackVariableInterpolated<T>
+impl<T> Track for TrackVariable<T>
 where
     T: Interpolate + Clone + 'static,
 {

From 1f432204c54aa4a1684c99df5e297e6735c18977 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Wed, 20 Jan 2021 21:34:49 -0300
Subject: [PATCH 093/153] sampler, clean up and first pr draft

---
 crates/bevy_animation/prdraft.md              | 154 +++++++++++++
 crates/bevy_animation/src/blending.rs         |  20 +-
 crates/bevy_animation/src/lib.rs              |   3 +-
 crates/bevy_animation/src/sampler.rs          | 209 ++++++++++++++++++
 crates/bevy_animation/src/tracks/fixed.rs     |   2 +-
 crates/bevy_animation/src/tracks/mod.rs       |  38 +---
 crates/bevy_animation/src/tracks/variable.rs  |   6 +-
 .../src/tracks/variable_linear.rs             |  68 +++---
 .../animations/bench_run_idle_animation.rs    |  69 ------
 examples/animations/run_animation.rs          |   6 +-
 10 files changed, 406 insertions(+), 169 deletions(-)
 create mode 100644 crates/bevy_animation/prdraft.md
 create mode 100644 crates/bevy_animation/src/sampler.rs
 delete mode 100644 examples/animations/bench_run_idle_animation.rs

diff --git a/crates/bevy_animation/prdraft.md b/crates/bevy_animation/prdraft.md
new file mode 100644
index 0000000000000..9296812419f4d
--- /dev/null
+++ b/crates/bevy_animation/prdraft.md
@@ -0,0 +1,154 @@
+Property based Animation PR (draft)
+
+Any type that implements `bevy_reflect::Struct` can have their attributes animated.
+
+Has a safety restriction only attributes that are within the struct memory limits can be addressed and animated,
+this means you can't animate items behind a `Vec`, array types could be animated but nested properties implementation
+is missing.
+
+The system main goal is to provide an low level api to play and blend animations.
+That been said an animation state machine should be built by the user or provided by a external crate.
+
+## Features
+
+1. Property based animation
+
+```rust
+let mut clip = Clip::default();
+/// A property is defined by the entity path followed by the component property
+clip.add_curve_at_path("/Node1/Node2@Transform.translation", track_data);
+```
+
+2. Animate any type using bevy_reflect
+
+```rust
+#[derive(Debug, Reflect)]
+#[reflect(Component)]
+struct CustomComponent {
+    value: f32,
+    point: Vec3,
+    #[reflect(ignore)]
+    non_animated: Vec3,
+}
+
+// During app startup
+app_builder.register_animated_component::<bevy_transform::prelude::Transform>();
+
+let mut clip = Clip::default();
+clip.add_curve_at_path("@CustomComponent.value", ...);
+clip.add_curve_at_path("@CustomComponent.point", ...);
+```
+
+4. Animate assets by swapping handles or animate their properties
+
+```rust
+// During app startup
+app_builder.register_animated_asset::<bevy_pbr::prelude::StandardMaterial>();
+
+let mut clip = Clip::default();
+// Swap material with
+clip.add_curve_at_path("@Handle<StandardMaterial>", ...);
+// Change the current material properties
+clip.add_curve_at_path("@Handle<StandardMaterial>.albedo", ...);
+clip.add_curve_at_path("@Handle<StandardMaterial>.albedo_texture", ...);
+```
+
+5. GLTF support
+
+You can load any animation clips embedded within a GLTF file
+
+```rust
+// Loads the skinned mesh ready to be animated with all of its clips (if any)
+let char_scene_handle = asset_server.load("models/character_medium/character_medium.gltf");
+// Returns a single clip from the GLTF
+let clip_handle = asset_server.load("models/character_medium/idle.gltf#Anim0");
+```
+
+6. Animation Blending
+
+It's possible to blend `bool`, `f32`, `Vec2`, `Vec3`, `Vec4`, `Quat`, `Handle<T>`, `Option<T>` when `T` can also be blended, and more.
+
+7. Animation clips defined by a named hierarchy
+
+Each `Animator` can only animate children entities, this is similar to other engines like Unity;
+
+Each clip have it's own hierarchy space, this allows clips to be reused for different setups that
+share some similarities. 
+
+Note that this isn't a humanoid retargeting system, but it could give you some good results is some particular situations;
+
+8. Mostly safe :p
+
+This crate uses a couple `unsafe`'s blocks, the safety rules of these blocks should be guaranteed
+at within the scope of a function or file (in the worst case) this way changes can be more easily
+made without the fear braking random safety conditions, as a bonus they should be asserted
+by code whenever possible;
+
+**The unsafe code still needs a review** 
+
+9. Fast TM
+
+a) Each component animation runs in parallel from each other
+b) Keyframe cursor, allows for faster sample rates by remembering the last keyframe it was last frame
+c) NLerp only and you wont notice the difference, hopefully ...
+
+10. Skinned Mesh support out of the box
+
+Simple and naive implementation, replaces the vertex shader from the `bevy_pbr::prelude::StandardMaterial`.
+Further work should done along side with the rendering, but hey it works!  
+
+## Missing Features
+
+1. Nested properties
+
+Right now only the top most properties of each struct can be animated,
+this means `"@CustomComponent.point.x"` isn't valid;
+
+2. Additive Blending
+
+3. Masks
+
+4. Animation events (simple and interval)
+
+5. Morph Targets
+
+6. Dedicated `Transform` animator system
+
+`Transform` is the most common animated component in any game, its the only animated component registered
+by default and it should receive a custom animator system to squeeze every single us that is possible,
+this custom system should be also be capable of performing SIMD blending;
+
+7. SIMD support
+
+The sampler do support wide types from the `ultraviolet` crate, but it's isn't fully integrated yet;
+SIMD blending will be a challenge to implement, and probably wont ever land; 
+
+## Terminology and Internals
+
+A clip is where all the animation data is stored, it's made out of a hierarchy of entities
+and a list of animated properties, each property is defined by path (`Transform.translation`) and type (`Vec3`)
+and contains a list of all the samplers paired with their respective output entities or channels;
+
+A sampler evaluates the state of a property at any given time. The `Track` is the only sampler currently implemented
+and comes in 3 flavors.
+
+1. `TrackFixed` performant in any operation range, requires a keyframe for every frame of the animation duration;
+
+2. `TrackVariableLinear`, can be used with linear keyframe reduction technique to save memory at runtime,
+most performant when sampled at a higher fps than the track sample rate. 
+
+3. `TrackVariable` very similar to `TrackVariableLinear` but beyond linear it supports step and catmull-rom as interpolations methods,
+because of that it will have a lower performance and require and extra runtime memory to store the keyframes tangents;
+This track is similar to `AnimationCurve` from Unity engine;
+
+## Safety status
+
+Assume that `bevy_reflect::Struct` was correctly implemented
+
+For that to happen unsafe blocks are used, but their safety constrains should be
+self contained within the same file or even with the same function block, with one
+single exception.
+
+Asside from that an animator system can be implemented with only safe code for any
+type that you may want, its a lot of code but mostly is boiler plates. Optionally you can
+add two extra unsafe blocks to improve performance (with very little safety conditions);
\ No newline at end of file
diff --git a/crates/bevy_animation/src/blending.rs b/crates/bevy_animation/src/blending.rs
index 1ce82d04f6aec..6d86dcf2004d0 100644
--- a/crates/bevy_animation/src/blending.rs
+++ b/crates/bevy_animation/src/blending.rs
@@ -6,19 +6,11 @@ use std::{collections::HashMap, mem::size_of};
 
 use crate::interpolate::Lerp;
 
-// pub struct Bit<'a>(&'a mut Mask, Mask);
-
-// impl<'a> Bit<'a> {
-//     #[inline(always)]
-//     pub fn set(&mut self) -> bool {
-//         if (*self.0 & self.1) != 0 {
-//             *self.0 |= self.1;
-//             true
-//         } else {
-//             false
-//         }
-//     }
-// }
+// TODO: Remove pointers and use indexes to handle context blending
+// this way begin_blending will take the entity_count and context size
+// with a bit extra work I can define if a type needs or not a slot for context blending
+
+// TODO: Additive blending
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 struct Ptr(*const u8);
@@ -28,7 +20,7 @@ struct Ptr(*const u8);
 unsafe impl Send for Ptr {}
 unsafe impl Sync for Ptr {}
 
-/// Mask size used to blend properties, each bit corresponds to a property
+/// Mask size used to blend properties, each bit corresponds to a single property
 pub type Mask = u32;
 
 /// Number of animated properties a type can hold
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 603b69b6aa183..ad946336491f9 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -14,6 +14,7 @@ mod skinned_mesh;
 pub mod blending;
 pub mod curve;
 pub mod interpolate;
+pub mod sampler;
 pub mod tracks;
 
 pub use crate::animator::*;
@@ -37,7 +38,7 @@ pub mod prelude {
 /// Exports wide types
 pub mod wide {
     pub use crate::interpolate::utils::{Quatx4, Quatx8};
-    pub use ultraviolet::vec::*;
+    pub use ultraviolet::vec::{Vec2x4, Vec2x8, Vec3x4, Vec3x8, Vec4x4, Vec4x8};
     pub use wide::*;
 }
 
diff --git a/crates/bevy_animation/src/sampler.rs b/crates/bevy_animation/src/sampler.rs
new file mode 100644
index 0000000000000..be01437096447
--- /dev/null
+++ b/crates/bevy_animation/src/sampler.rs
@@ -0,0 +1,209 @@
+use std::mem::transmute;
+
+use bevy_math::prelude::*;
+use bevy_render::prelude::Color;
+use smallvec::Array;
+
+use crate::{tracks::Track, wide::*};
+
+/// Defines a sampler value output;
+///
+/// Required because wide types outputs to many different channels at the same time
+pub trait SamplerValue {
+    /// The result value ready to be assign to each channel;
+    ///
+    /// Are defined as `Self` for simpler types like `f32` or `Vec3` etc, and arrays for wide types like `Vec3x4`;
+    type Out;
+
+    /// Defines how many channels needed be indexed in oder to assign all of this output
+    type Indexes: Array<Item = u16>;
+
+    fn output(self) -> Self::Out;
+}
+
+/// Defines a sampler and it's target channels
+pub trait Sampler {
+    /// Channel type
+    type Out;
+
+    /// Evaluates the sampler while assign each outputs to their respective channel
+    fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Out)) -> u16;
+}
+
+/// Defines how to sample an track and output it's results
+pub struct TrackSampler<V: SamplerValue, T: Track> {
+    /// These indexes are usually entity indexes within the clip space, a fully defined channel is
+    /// made by a property name plus some index, each track will be sorted by property
+    pub channels: V::Indexes,
+    /// Only applicable when `channels.len() > 0`, defines how many of the output lanes are actually assigned;
+    /// In the case of `len == 0` this track doesn't output anything and should be deleted to preserve performance
+    pub len: u16,
+    pub track: T,
+}
+
+// /// Base sampler type
+// pub struct SamplerBase<T>(Box<dyn Sampler<Out = T> + Send + Sync + 'static>);
+
+// impl<T> Sampler for SamplerBase<T> {
+//     type Out = T;
+
+//     #[inline(always)]
+//     fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Out)) -> u16 {
+//         self.0.sample(cursor, time, assign)
+//     }
+// }
+
+// pub struct SamplerUntyped(Box<dyn Any + Send + Sync + 'static>);
+
+// impl SamplerUntyped {
+//     pub fn new<S>(sampler: S) -> Self
+//     where
+//         S: Sampler + Send + Sync + 'static,
+//     {
+//         SamplerUntyped(Box::new(SamplerBase(Box::new(sampler))))
+//     }
+
+//     #[inline(always)]
+//     pub fn downcast_ref<T: 'static>(&self) -> Option<&SamplerBase<T>> {
+//         self.0.downcast_ref()
+//     }
+
+//     #[inline(always)]
+//     pub fn downcast_mut<T: 'static>(&mut self) -> Option<&mut SamplerBase<T>> {
+//         self.0.downcast_mut()
+//     }
+// }
+
+macro_rules! output1x1 {
+    ($t:ty) => {
+        impl SamplerValue for $t {
+            type Out = $t;
+            type Indexes = [u16; 1];
+
+            #[inline(always)]
+            fn output(self) -> Self::Out {
+                self
+            }
+        }
+
+        impl<T: Track<Out = $t>> Sampler for TrackSampler<$t, T> {
+            type Out = $t;
+
+            fn sample(
+                &self,
+                cursor: u16,
+                time: f32,
+                assign: &mut dyn FnMut(u16, Self::Out),
+            ) -> u16 {
+                let (cursor, x) = self.track.sample_with_cursor(cursor, time);
+                (assign)(self.channels[0], x);
+                cursor
+            }
+        }
+    };
+}
+
+output1x1!(bool);
+output1x1!(u8);
+output1x1!(u16);
+output1x1!(u32);
+output1x1!(u64);
+output1x1!(usize);
+output1x1!(i8);
+output1x1!(i16);
+output1x1!(i32);
+output1x1!(i64);
+output1x1!(isize);
+output1x1!(f32);
+output1x1!(f64);
+
+output1x1!(Vec2);
+output1x1!(Vec3);
+output1x1!(Vec4);
+output1x1!(Color);
+output1x1!(Quat);
+
+macro_rules! output1xn {
+    ($t:ty, $i:ty, $o:ty, $s:tt) => {
+        impl SamplerValue for $t {
+            type Out = [$o; $s];
+            type Indexes = [u16; $s];
+
+            #[inline(always)]
+            fn output(self) -> Self::Out {
+                unsafe { transmute::<[$i; $s], _>(self.into()) }
+            }
+        }
+
+        impl<T: Track<Out = $t>> Sampler for TrackSampler<$t, T> {
+            type Out = $o;
+
+            fn sample(
+                &self,
+                cursor: u16,
+                time: f32,
+                assign: &mut dyn FnMut(u16, Self::Out),
+            ) -> u16 {
+                let (cursor, x) = self.track.sample_with_cursor(cursor, time);
+                let x = x.output();
+                for i in 0..(self.len as usize).min($s - 1) {
+                    (assign)(self.channels[i], x[i]);
+                }
+                cursor
+            }
+        }
+    };
+}
+
+output1xn!(f32x4, f32, f32, 4);
+output1xn!(f32x8, f32, f32, 8);
+output1xn!(Vec3x4, ultraviolet::Vec3, Vec3, 4);
+output1xn!(Vec3x8, ultraviolet::Vec3, Vec3, 8);
+output1xn!(Vec4x4, ultraviolet::Vec4, Vec4, 4);
+output1xn!(Vec4x8, ultraviolet::Vec4, Vec4, 8);
+
+impl SamplerValue for Quatx4 {
+    type Out = [Quat; 4];
+    type Indexes = [u16; 4];
+
+    #[inline(always)]
+    fn output(self) -> Self::Out {
+        unsafe { transmute::<[ultraviolet::Vec4; 4], _>(self.0.into()) }
+    }
+}
+
+impl<T: Track<Out = Quatx4>> Sampler for TrackSampler<Quatx4, T> {
+    type Out = Quat;
+
+    fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Out)) -> u16 {
+        let (cursor, x) = self.track.sample_with_cursor(cursor, time);
+        let x = x.output();
+        for i in 0..(self.len as usize).min(4 - 1) {
+            (assign)(self.channels[i], x[i]);
+        }
+        cursor
+    }
+}
+
+impl SamplerValue for Quatx8 {
+    type Out = [Quat; 8];
+    type Indexes = [u16; 8];
+
+    #[inline(always)]
+    fn output(self) -> Self::Out {
+        unsafe { transmute::<[ultraviolet::Vec4; 8], _>(self.0.into()) }
+    }
+}
+
+impl<T: Track<Out = Quatx8>> Sampler for TrackSampler<Quatx8, T> {
+    type Out = Quat;
+
+    fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Out)) -> u16 {
+        let (cursor, x) = self.track.sample_with_cursor(cursor, time);
+        let x = x.output();
+        for i in 0..(self.len as usize).min(8 - 1) {
+            (assign)(self.channels[i], x[i]);
+        }
+        cursor
+    }
+}
diff --git a/crates/bevy_animation/src/tracks/fixed.rs b/crates/bevy_animation/src/tracks/fixed.rs
index 7e1f2f14477ba..9ba5b6c672f66 100644
--- a/crates/bevy_animation/src/tracks/fixed.rs
+++ b/crates/bevy_animation/src/tracks/fixed.rs
@@ -69,7 +69,7 @@ impl<T> Track for TrackFixed<T>
 where
     T: Lerp + Clone,
 {
-    type Output = T;
+    type Out = T;
 
     fn duration(&self) -> f32 {
         ((self.keyframes.len() as f32 - 1.0 - self.negative_offset) / self.frame_rate).max(0.0)
diff --git a/crates/bevy_animation/src/tracks/mod.rs b/crates/bevy_animation/src/tracks/mod.rs
index 5404f9be3784a..094ce13d0f04c 100644
--- a/crates/bevy_animation/src/tracks/mod.rs
+++ b/crates/bevy_animation/src/tracks/mod.rs
@@ -1,5 +1,3 @@
-// use std::any::Any;
-
 mod fixed;
 mod variable;
 mod variable_linear;
@@ -8,10 +6,8 @@ pub use fixed::*;
 pub use variable::*;
 pub use variable_linear::*;
 
-//use crate::interpolate::Interpolate;
-
 pub trait Track {
-    type Output;
+    type Out;
 
     fn duration(&self) -> f32;
 
@@ -19,38 +15,10 @@ pub trait Track {
     /// the keyframe cursor, but is more expensive always `O(n)`. Which means
     /// sampling takes longer to evaluate as much as time get closer to curve duration
     /// and it get worse with more keyframes.
-    fn sample(&self, time: f32) -> Self::Output;
+    fn sample(&self, time: f32) -> Self::Out;
 
     /// Samples the curve starting from some keyframe cursor, this make the common case `O(1)`
     ///
     /// **NOTE** Each keyframe is indexed by a `u16` to reduce memory usage when using the keyframe caching
-    fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, Self::Output);
+    fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, Self::Out);
 }
-
-// struct TrackUntypedRaw<T>(Box<dyn Track<Output = T> + Send + Sync + 'static>);
-
-// pub struct TrackUntyped {
-//     untyped: Box<dyn Any + Send + Sync + 'static>,
-// }
-
-// impl TrackUntyped {
-//     pub fn new<T>(track: T) -> Self
-//     where
-//         T: Track + Send + Sync + 'static,
-//         <T as Track>::Output: Send + Sync + 'static,
-//     {
-//         TrackUntyped {
-//             // duration: curves.calculate_duration(),
-//             // meta: CurveMeta::of::<T>(),
-//             untyped: Box::new(TrackUntypedRaw(Box::new(track))),
-//         }
-//     }
-// }
-
-// pub enum TrackEnum<T: Interpolate> {
-//     Fixed([u16; 1], TrackFixed<T>),
-//     Wide4([u16; 4], TrackFixed<T>),
-//     Wide8([u16; 8], TrackFixed<T>),
-//     VarLinear([u16; 1], TrackVariableLinear<T>),
-//     Var([u16; 1], TrackVariable<T>),
-// }
diff --git a/crates/bevy_animation/src/tracks/variable.rs b/crates/bevy_animation/src/tracks/variable.rs
index 44b546ed7d010..815a44433a179 100644
--- a/crates/bevy_animation/src/tracks/variable.rs
+++ b/crates/bevy_animation/src/tracks/variable.rs
@@ -110,13 +110,13 @@ impl<T> Track for TrackVariable<T>
 where
     T: Interpolate + Clone + 'static,
 {
-    type Output = T;
+    type Out = T;
 
     fn duration(&self) -> f32 {
         self.time_stamps.last().copied().unwrap_or(0.0)
     }
 
-    fn sample(&self, time: f32) -> Self::Output {
+    fn sample(&self, time: f32) -> Self::Out {
         // Index guessing gives a small search optimization
         let index = if time < self.duration() * 0.5 {
             0
@@ -127,7 +127,7 @@ where
         self.sample_with_cursor(index as u16, time).1
     }
 
-    fn sample_with_cursor(&self, mut cursor: u16, time: f32) -> (u16, Self::Output) {
+    fn sample_with_cursor(&self, mut cursor: u16, time: f32) -> (u16, Self::Out) {
         // Adjust for the current keyframe cursor
         let last_cursor = (self.time_stamps.len() - 1) as u16;
 
diff --git a/crates/bevy_animation/src/tracks/variable_linear.rs b/crates/bevy_animation/src/tracks/variable_linear.rs
index 274966a8f7e8f..779274a1a37c0 100644
--- a/crates/bevy_animation/src/tracks/variable_linear.rs
+++ b/crates/bevy_animation/src/tracks/variable_linear.rs
@@ -1,5 +1,4 @@
-use std::any::TypeId;
-
+use super::Track;
 use crate::interpolate::Lerp;
 
 // TODO: Curve/Clip need a validation during deserialization because they are
@@ -74,10 +73,6 @@ impl<T> TrackVariableLinear<T> {
     //assert!(samples.len() > 1, "curve can't be empty");
     // }
 
-    pub fn duration(&self) -> f32 {
-        self.time_stamps.last().copied().unwrap_or(0.0)
-    }
-
     pub fn add_offset_time(&mut self, time_offset: f32) {
         self.time_stamps.iter_mut().for_each(|t| *t += time_offset);
     }
@@ -94,17 +89,17 @@ impl<T> TrackVariableLinear<T> {
     }
 }
 
-impl<T> TrackVariableLinear<T>
+impl<T> Track for TrackVariableLinear<T>
 where
     T: Lerp + Clone + 'static,
 {
-    // TODO: Profile sample_indexed vs sample, I want to know when use one over the other?
+    type Out = T;
 
-    /// Easer to use sampling method that don't have time restrictions or needs
-    /// the keyframe index, but is more expensive always `O(n)`. Which means
-    /// sampling takes longer to evaluate as much as time get closer to curve duration
-    /// and it get worse with more keyframes.
-    pub fn sample(&self, time: f32) -> T {
+    fn duration(&self) -> f32 {
+        self.time_stamps.last().copied().unwrap_or(0.0)
+    }
+
+    fn sample(&self, time: f32) -> Self::Out {
         // Index guessing gives a small search optimization
         let index = if time < self.duration() * 0.5 {
             0
@@ -112,67 +107,54 @@ where
             self.time_stamps.len() - 1
         };
 
-        self.sample_indexed(index as u16, time).1
+        self.sample_with_cursor(index as u16, time).1
     }
 
-    /// Samples the curve starting from some keyframe index, this make the common case `O(1)`
-    ///
-    /// **NOTE** Each keyframe is indexed by a `u16` to reduce memory usage when using the keyframe caching
-    pub fn sample_indexed(&self, mut index: u16, time: f32) -> (u16, T) {
+    fn sample_with_cursor(&self, mut cursor: u16, time: f32) -> (u16, Self::Out) {
         // Adjust for the current keyframe index
-        let last_index = (self.time_stamps.len() - 1) as u16;
+        let last_cursor = (self.time_stamps.len() - 1) as u16;
 
-        index = index.max(0).min(last_index);
-        if self.time_stamps[index as usize] < time {
+        cursor = cursor.max(0).min(last_cursor);
+        if self.time_stamps[cursor as usize] < time {
             // Forward search
             loop {
-                if index == last_index {
-                    return (last_index, self.keyframes[last_index as usize].clone());
+                if cursor == last_cursor {
+                    return (last_cursor, self.keyframes[last_cursor as usize].clone());
                 }
-                index += 1;
+                cursor += 1;
 
-                if self.time_stamps[index as usize] >= time {
+                if self.time_stamps[cursor as usize] >= time {
                     break;
                 }
             }
         } else {
             // Backward search
             loop {
-                if index == 0 {
+                if cursor == 0 {
                     return (0, self.keyframes[0].clone());
                 }
 
-                let i = index - 1;
+                let i = cursor - 1;
                 if self.time_stamps[i as usize] <= time {
                     break;
                 }
 
-                index = i;
+                cursor = i;
             }
         }
 
         // Lerp the value
-        let i = index - 1;
+        let i = cursor - 1;
         let previous_time = self.time_stamps[i as usize];
-        let t = (time - previous_time) / (self.time_stamps[index as usize] - previous_time);
+        let t = (time - previous_time) / (self.time_stamps[cursor as usize] - previous_time);
         debug_assert!(t >= 0.0 && t <= 1.0, "t = {} but should be normalized", t); // Checks if it's required to normalize t
         let value = T::lerp(
             &self.keyframes[i as usize],
-            &self.keyframes[index as usize],
+            &self.keyframes[cursor as usize],
             t,
         );
 
-        (index, value)
-    }
-
-    #[inline(always)]
-    pub fn value_type(&self) -> TypeId {
-        TypeId::of::<T>()
-    }
-
-    #[inline(always)]
-    pub fn value_size(&self) -> usize {
-        std::mem::size_of::<T>()
+        (cursor, value)
     }
 }
 
@@ -192,7 +174,7 @@ mod tests {
         let mut e0 = 0.0;
         for v in &[0.1, 0.3, 0.7, 0.4, 0.2, 0.0, 0.4, 0.85, 1.0] {
             let v = *v;
-            let (i1, e1) = curve.sample_indexed(i0, v);
+            let (i1, e1) = curve.sample_with_cursor(i0, v);
             assert_eq!(e1, 2.0 * v);
             if e1 > e0 {
                 assert!(i1 >= i0);
diff --git a/examples/animations/bench_run_idle_animation.rs b/examples/animations/bench_run_idle_animation.rs
deleted file mode 100644
index e89cb68884037..0000000000000
--- a/examples/animations/bench_run_idle_animation.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use std::{mem::drop, thread::sleep, time::Duration};
-
-use bevy::{
-    animation::{Animator, Clip},
-    asset::LoadState,
-    prelude::*,
-    render::{pipeline::RenderPipelines, render_graph::base::MainPass},
-};
-
-fn main() {
-    let mut bench = bevy::animation::Bench::build(None);
-    bench
-        .builder
-        // To load
-        .add_plugin(bevy::scene::ScenePlugin::default())
-        .add_plugin(bevy::gltf::GltfPlugin::default())
-        // These are need to load the GLTF
-        .add_asset::<Mesh>()
-        .register_type::<Draw>()
-        .register_type::<MainPass>()
-        .register_type::<Visible>()
-        .register_type::<RenderPipelines>()
-        .add_asset::<StandardMaterial>();
-
-    bench.warm();
-
-    let app = &mut bench.builder.app;
-    let asset_server = app.resources.get::<AssetServer>().unwrap();
-    let scene: Handle<Scene> = asset_server.load("models/character_medium/character_medium.gltf");
-    let idle: Handle<Clip> = asset_server.load("models/character_medium/idle.gltf#Anim0");
-    let run: Handle<Clip> = asset_server.load("models/character_medium/run.gltf#Anim0");
-    drop(asset_server);
-
-    let t = Duration::from_millis(50);
-    for h in &[
-        scene.clone_untyped(),
-        idle.clone_untyped(),
-        run.clone_untyped(),
-    ] {
-        loop {
-            app.update();
-
-            let asset_server = app.resources.get::<AssetServer>().unwrap();
-            let state = asset_server.get_load_state(h);
-            drop(asset_server);
-
-            // println!("{:?}", state);
-            if state == LoadState::Loaded {
-                break;
-            }
-            sleep(t);
-        }
-    }
-
-    let mut spawner = app.resources.get_mut::<SceneSpawner>().unwrap();
-    spawner.spawn(scene);
-    drop(spawner);
-    app.update();
-
-    let mut ok = false;
-    for (mut animator,) in app.world.query_mut::<(&mut Animator,)>() {
-        animator.add_layer(idle.clone(), 0.5);
-        animator.add_layer(run.clone(), 0.5);
-        ok = true;
-    }
-    assert!(ok, "scene not spawned or doesn't contain an animator");
-
-    bench.run(100_000);
-}
diff --git a/examples/animations/run_animation.rs b/examples/animations/run_animation.rs
index e752593663d0a..ad6e31935be92 100644
--- a/examples/animations/run_animation.rs
+++ b/examples/animations/run_animation.rs
@@ -4,9 +4,9 @@ use bevy::prelude::*;
 
 fn main() {
     App::build()
-        .add_resource(AssetServerSettings {
-            asset_folder: "G:/Rust/bevy/assets".to_string(),
-        })
+        // .add_resource(AssetServerSettings {
+        //     asset_folder: "G:/Rust/bevy/assets".to_string(),
+        // })
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup)
         .add_system(anim_set)

From 81ebe277d9a74babcfacae6006f415af13e2b126 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sat, 30 Jan 2021 00:45:35 -0300
Subject: [PATCH 094/153] added multiple track types support

---
 crates/bevy_animation/src/animator.rs   |  63 ++++---
 crates/bevy_animation/src/curve.rs      | 217 -----------------------
 crates/bevy_animation/src/lib.rs        |   3 -
 crates/bevy_animation/src/reflect.rs    |   4 +-
 crates/bevy_animation/src/sampler.rs    | 209 ----------------------
 crates/bevy_animation/src/tracks/mod.rs |   4 +
 crates/bevy_animation/src/tracks/n.rs   | 225 ++++++++++++++++++++++++
 crates/bevy_gltf/src/loader.rs          |  13 +-
 8 files changed, 276 insertions(+), 462 deletions(-)
 delete mode 100644 crates/bevy_animation/src/curve.rs
 delete mode 100644 crates/bevy_animation/src/sampler.rs
 create mode 100644 crates/bevy_animation/src/tracks/n.rs

diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index eee40fa1f3da7..8a47603c813f2 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -15,7 +15,12 @@ use fnv::FnvBuildHasher;
 use smallvec::{smallvec, SmallVec};
 use tracing::warn;
 
-use crate::{blending::AnimatorBlending, curve::Curve, hierarchy::Hierarchy, interpolate::Lerp};
+use crate::{
+    blending::AnimatorBlending,
+    hierarchy::Hierarchy,
+    interpolate::Lerp,
+    tracks::{Track, TrackBase},
+};
 
 // TODO: Load Clip name from gltf
 
@@ -40,14 +45,19 @@ const KEYFRAMES_PER_CACHE: usize = CACHE_SIZE / std::mem::size_of::<u16>();
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[derive(Debug)]
-pub struct Curves<T> {
+pub struct Tracks<T> {
     entity_indexes: SmallVec<[u16; 8]>,
     /// Pair of curve and it's index
-    curves: Vec<(usize, Curve<T>)>,
+    curves: Vec<(usize, TrackBase<T>)>,
 }
 
-impl<T> Curves<T> {
+impl<T> std::fmt::Debug for Tracks<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("Tracks").field(&self.curves.len()).finish()
+    }
+}
+
+impl<T> Tracks<T> {
     fn calculate_duration(&self) -> f32 {
         self.curves
             .iter()
@@ -62,7 +72,7 @@ impl<T> Curves<T> {
     }
 
     #[inline(always)]
-    pub fn iter(&self) -> impl Iterator<Item = (u16, &(usize, Curve<T>))> {
+    pub fn iter(&self) -> impl Iterator<Item = (u16, &(usize, TrackBase<T>))> {
         self.entity_indexes.iter().copied().zip(self.curves.iter())
     }
 }
@@ -97,7 +107,7 @@ pub struct CurvesUntyped {
 }
 
 impl CurvesUntyped {
-    fn new<T: Send + Sync + 'static>(curves: Curves<T>) -> Self {
+    fn new<T: Send + Sync + 'static>(curves: Tracks<T>) -> Self {
         CurvesUntyped {
             duration: curves.calculate_duration(),
             meta: CurveMeta::of::<T>(),
@@ -114,12 +124,12 @@ impl CurvesUntyped {
     }
 
     #[inline(always)]
-    pub fn downcast_ref<T: 'static>(&self) -> Option<&Curves<T>> {
+    pub fn downcast_ref<T: 'static>(&self) -> Option<&Tracks<T>> {
         self.untyped.downcast_ref()
     }
 
     #[inline(always)]
-    pub fn downcast_mut<T: 'static>(&mut self) -> Option<&mut Curves<T>> {
+    pub fn downcast_mut<T: 'static>(&mut self) -> Option<&mut Tracks<T>> {
         self.untyped.downcast_mut()
     }
 }
@@ -201,10 +211,13 @@ impl Clip {
     ///
     /// **NOTE** You can safely ignore the return value as it's only used for assertions during tests;
     /// The return value is the assigned curve index in cache line bucket.
-    pub fn add_curve_at_path<T>(&mut self, path: &str, mut curve: Curve<T>) -> usize
+    pub fn add_curve_at_path<T>(&mut self, path: &str, track: T) -> usize
     where
-        T: Lerp + Clone + Send + Sync + 'static,
+        T: Track + Send + Sync + 'static,
+        <T as Track>::Out: Lerp + Clone + Send + Sync + 'static,
     {
+        let mut track: TrackBase<<T as Track>::Out> = Box::new(track);
+
         // Split in entity and attribute path,
         // NOTE: use rfind because it's expected the latter to be generally shorter
         let path = path.split_at(path.rfind('@').expect("property path missing @"));
@@ -222,7 +235,7 @@ impl Clip {
 
         if let Some((cache_index, curves_untyped)) = self.properties.get_mut(property_path) {
             let curves = curves_untyped
-                .downcast_mut::<T>()
+                .downcast_mut::<<T as Track>::Out>()
                 .expect("properties can't have the same name and different curve types");
 
             // If some entity was created it means this property is a new one so we can safely skip the attribute testing
@@ -235,7 +248,7 @@ impl Clip {
                 let curve_index = *curve_index;
 
                 // Found a property equal to the one been inserted, next replace the curve
-                std::mem::swap(curve_untyped, &mut curve);
+                std::mem::swap(curve_untyped, &mut track);
 
                 // Update curve duration in two stages
                 let duration = curves.calculate_duration();
@@ -260,9 +273,9 @@ impl Clip {
                 self.len += 1;
 
                 // Append newly added curve
-                let duration = curve.duration();
+                let duration = track.duration();
 
-                curves.curves.push((*cache_index, curve));
+                curves.curves.push((*cache_index, track));
                 curves.entity_indexes.push(entity_index);
                 std::mem::drop(curves);
 
@@ -278,13 +291,13 @@ impl Clip {
         self.keyframes_cache_buckets += 1;
         self.len += 1;
 
-        self.duration = self.duration.max(curve.duration());
+        self.duration = self.duration.max(track.duration());
         self.properties.insert(
             property_path.to_string(),
             (
                 cache_index,
-                CurvesUntyped::new(Curves {
-                    curves: vec![(cache_index, curve)],
+                CurvesUntyped::new(Tracks {
+                    curves: vec![(cache_index, track)],
                     entity_indexes: smallvec![entity_index],
                 }),
             ),
@@ -777,7 +790,7 @@ pub(crate) fn animator_update_system(
 #[allow(dead_code)]
 mod tests {
     use super::*;
-    use crate::curve::Curve;
+    use crate::tracks::TrackVariableLinear;
     use bevy_asset::AddAsset;
     use bevy_math::prelude::{Quat, Vec3};
     use bevy_pbr::prelude::StandardMaterial;
@@ -814,9 +827,9 @@ mod tests {
                 let mut clip_a = Clip::default();
                 clip_a.add_curve_at_path(
                     "@Transform.translation",
-                    Curve::from_line(0.0, 1.0, Vec3::unit_x(), -Vec3::unit_x()),
+                    TrackVariableLinear::from_line(0.0, 1.0, Vec3::unit_x(), -Vec3::unit_x()),
                 );
-                let rot = Curve::from_constant(Quat::identity());
+                let rot = TrackVariableLinear::from_constant(Quat::identity());
                 clip_a.add_curve_at_path("@Transform.rotation", rot.clone());
                 clip_a.add_curve_at_path("/Node1@Transform.rotation", rot.clone());
                 clip_a.add_curve_at_path("/Node1/Node2@Transform.rotation", rot);
@@ -824,9 +837,9 @@ mod tests {
                 let mut clip_b = Clip::default();
                 clip_b.add_curve_at_path(
                     "@Transform.translation",
-                    Curve::from_constant(Vec3::zero()),
+                    TrackVariableLinear::from_constant(Vec3::zero()),
                 );
-                let rot = Curve::from_line(
+                let rot = TrackVariableLinear::from_line(
                     0.0,
                     1.0,
                     Quat::from_axis_angle(Vec3::unit_z(), 0.1),
@@ -1209,7 +1222,7 @@ mod tests {
             let clip_a = clips.get_mut(clip_a_handle).unwrap();
             clip_a.add_curve_at_path(
                 "/Node3/@Transform.translation",
-                Curve::from_line(0.0, 1.0, Vec3::unit_z(), -Vec3::unit_z()),
+                TrackVariableLinear::from_line(0.0, 1.0, Vec3::unit_z(), -Vec3::unit_z()),
             );
         }
 
@@ -1238,7 +1251,7 @@ mod tests {
 
     #[test]
     fn clip_property_index_are_grouped_into_cache_line_buckets() {
-        let curve = Curve::from_constant(0.0);
+        let curve = TrackVariableLinear::from_constant(0.0);
         let mut clip = Clip::default();
         assert_eq!(clip.add_curve_at_path("a@T.t", curve.clone()), 0);
         assert_eq!(clip.add_curve_at_path("b@T.t", curve.clone()), 1);
diff --git a/crates/bevy_animation/src/curve.rs b/crates/bevy_animation/src/curve.rs
deleted file mode 100644
index f6fa5c7552108..0000000000000
--- a/crates/bevy_animation/src/curve.rs
+++ /dev/null
@@ -1,217 +0,0 @@
-use std::any::TypeId;
-
-use crate::interpolate::Lerp;
-
-// TODO: Curve/Clip need a validation during deserialization because they are
-// structured as SOA (struct of arrays), so the vec's length must match
-
-// https://github.com/niklasfrykholm/blog
-// https://bitsquid.blogspot.com/search?q=animation
-// http://bitsquid.blogspot.com/2009/11/bitsquid-low-level-animation-system.html
-// http://archive.gamedev.net/archive/reference/articles/article1497.html (bit old)
-
-// http://nfrechette.github.io/2016/12/07/anim_compression_key_reduction/
-// https://github.com/nfrechette/acl
-
-// TODO: impl Serialize, Deserialize
-#[derive(Default, Debug)]
-pub struct Curve<T> {
-    // TODO: Change to frame_rate / frame_indexes to reduce memory usage
-    samples: Vec<f32>,
-    values: Vec<T>,
-}
-
-impl<T: Clone> Clone for Curve<T> {
-    fn clone(&self) -> Self {
-        Self {
-            samples: self.samples.clone(),
-            values: self.values.clone(),
-        }
-    }
-}
-
-impl<T> Curve<T> {
-    pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
-        // TODO: Result?
-
-        // Make sure both have the same length
-        assert!(
-            samples.len() == values.len(),
-            "samples and values must have the same length"
-        );
-
-        assert!(
-            values.len() <= u16::MAX as usize,
-            "limit of {} keyframes exceeded",
-            u16::MAX
-        );
-
-        assert!(samples.len() > 0, "empty curve");
-
-        // Make sure the
-        assert!(
-            samples
-                .iter()
-                .zip(samples.iter().skip(1))
-                .all(|(a, b)| a < b),
-            "time samples must be on ascending order"
-        );
-        Self { samples, values }
-    }
-
-    pub fn from_line(t0: f32, t1: f32, v0: T, v1: T) -> Self {
-        Self {
-            samples: if t1 >= t0 { vec![t0, t1] } else { vec![t1, t0] },
-            values: vec![v0, v1],
-        }
-    }
-
-    pub fn from_constant(v: T) -> Self {
-        Self {
-            samples: vec![0.0],
-            values: vec![v],
-        }
-    }
-
-    // pub fn insert(&mut self, time_sample: f32, value: T) {
-    // }
-
-    // pub fn remove(&mut self, index: usize) {
-    //assert!(samples.len() > 1, "curve can't be empty");
-    // }
-
-    pub fn duration(&self) -> f32 {
-        self.samples.last().copied().unwrap_or(0.0)
-    }
-
-    pub fn add_offset_time(&mut self, time_offset: f32) {
-        self.samples.iter_mut().for_each(|t| *t += time_offset);
-    }
-
-    pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
-        self.samples.iter().copied().zip(self.values.iter())
-    }
-
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
-        self.samples.iter().copied().zip(self.values.iter_mut())
-    }
-}
-
-impl<T> Curve<T>
-where
-    T: Lerp + Clone + 'static,
-{
-    // TODO: Profile sample_indexed vs sample, I want to know when use one over the other?
-
-    /// Easer to use sampling method that don't have time restrictions or needs
-    /// the keyframe index, but is more expensive always `O(n)`. Which means
-    /// sampling takes longer to evaluate as much as time get closer to curve duration
-    /// and it get worse with more keyframes.
-    pub fn sample(&self, time: f32) -> T {
-        // Index guessing gives a small search optimization
-        let index = if time < self.duration() * 0.5 {
-            0
-        } else {
-            self.samples.len() - 1
-        };
-
-        self.sample_indexed(index as u16, time).1
-    }
-
-    /// Samples the curve starting from some keyframe index, this make the common case `O(1)`
-    ///
-    /// **NOTE** Each keyframe is indexed by a `u16` to reduce memory usage when using the keyframe caching
-    pub fn sample_indexed(&self, mut index: u16, time: f32) -> (u16, T) {
-        // Adjust for the current keyframe index
-        let last_index = (self.samples.len() - 1) as u16;
-
-        index = index.max(0).min(last_index);
-        if self.samples[index as usize] < time {
-            // Forward search
-            loop {
-                if index == last_index {
-                    return (last_index, self.values[last_index as usize].clone());
-                }
-                index += 1;
-
-                if self.samples[index as usize] >= time {
-                    break;
-                }
-            }
-        } else {
-            // Backward search
-            loop {
-                if index == 0 {
-                    return (0, self.values[0].clone());
-                }
-
-                let i = index - 1;
-                if self.samples[i as usize] <= time {
-                    break;
-                }
-
-                index = i;
-            }
-        }
-
-        // Lerp the value
-        let i = index - 1;
-        let previous_time = self.samples[i as usize];
-        let t = (time - previous_time) / (self.samples[index as usize] - previous_time);
-        debug_assert!(t >= 0.0 && t <= 1.0, "t = {} but should be normalized", t); // Checks if it's required to normalize t
-        let value = T::lerp(&self.values[i as usize], &self.values[index as usize], t);
-
-        (index, value)
-    }
-
-    #[inline(always)]
-    pub fn value_type(&self) -> TypeId {
-        TypeId::of::<T>()
-    }
-
-    #[inline(always)]
-    pub fn value_size(&self) -> usize {
-        std::mem::size_of::<T>()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn curve_evaluation() {
-        let curve = Curve::new(
-            vec![0.0, 0.25, 0.5, 0.75, 1.0],
-            vec![0.0, 0.5, 1.0, 1.5, 2.0],
-        );
-        assert_eq!(curve.sample(0.5), 1.0);
-
-        let mut i0 = 0;
-        let mut e0 = 0.0;
-        for v in &[0.1, 0.3, 0.7, 0.4, 0.2, 0.0, 0.4, 0.85, 1.0] {
-            let v = *v;
-            let (i1, e1) = curve.sample_indexed(i0, v);
-            assert_eq!(e1, 2.0 * v);
-            if e1 > e0 {
-                assert!(i1 >= i0);
-            } else {
-                assert!(i1 <= i0);
-            }
-            e0 = e1;
-            i0 = i1;
-        }
-    }
-
-    #[test]
-    #[should_panic]
-    fn curve_bad_length() {
-        let _ = Curve::new(vec![0.0, 0.5, 1.0], vec![0.0, 1.0]);
-    }
-
-    #[test]
-    #[should_panic]
-    fn curve_time_samples_not_sorted() {
-        let _ = Curve::new(vec![0.0, 1.5, 1.0], vec![0.0, 1.0, 2.0]);
-    }
-}
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index ad946336491f9..30eafdee708ee 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -12,9 +12,7 @@ mod hierarchy;
 mod skinned_mesh;
 
 pub mod blending;
-pub mod curve;
 pub mod interpolate;
-pub mod sampler;
 pub mod tracks;
 
 pub use crate::animator::*;
@@ -28,7 +26,6 @@ pub mod prelude {
     pub use crate::animator::{Animator, Clip};
     pub use crate::app::AddAnimated;
     pub use crate::blending::AnimatorBlending;
-    pub use crate::curve::Curve;
     pub use crate::hierarchy::Hierarchy;
     pub use crate::interpolate::Lerp;
     pub use crate::reflect::AnimatorPropertyRegistry;
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index 551b90d7d57de..1f7ac7b950fd6 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -122,7 +122,7 @@ unsafe fn animate<T>(
             let entity_index = entities_map[entity_index as usize] as usize;
             if let Some(component) = (get_mut)(entity_index) {
                 let kr = &mut keyframes[*curve_index];
-                let (k, v) = curve.sample_indexed(*kr, time);
+                let (k, v) = curve.sample_with_cursor(*kr, time);
                 *kr = k;
 
                 // Unsafe portion
@@ -457,7 +457,7 @@ pub(crate) fn animate_asset_system<T: Asset>(
                         let entity_index = entities_map[entity_index as usize] as usize;
                         if let Some(ref mut component) = cached_components[entity_index] {
                             let kr = &mut keyframes[*curve_index];
-                            let (k, v) = curve.sample_indexed(*kr, time);
+                            let (k, v) = curve.sample_with_cursor(*kr, time);
                             *kr = k;
 
                             let value = &mut **component;
diff --git a/crates/bevy_animation/src/sampler.rs b/crates/bevy_animation/src/sampler.rs
deleted file mode 100644
index be01437096447..0000000000000
--- a/crates/bevy_animation/src/sampler.rs
+++ /dev/null
@@ -1,209 +0,0 @@
-use std::mem::transmute;
-
-use bevy_math::prelude::*;
-use bevy_render::prelude::Color;
-use smallvec::Array;
-
-use crate::{tracks::Track, wide::*};
-
-/// Defines a sampler value output;
-///
-/// Required because wide types outputs to many different channels at the same time
-pub trait SamplerValue {
-    /// The result value ready to be assign to each channel;
-    ///
-    /// Are defined as `Self` for simpler types like `f32` or `Vec3` etc, and arrays for wide types like `Vec3x4`;
-    type Out;
-
-    /// Defines how many channels needed be indexed in oder to assign all of this output
-    type Indexes: Array<Item = u16>;
-
-    fn output(self) -> Self::Out;
-}
-
-/// Defines a sampler and it's target channels
-pub trait Sampler {
-    /// Channel type
-    type Out;
-
-    /// Evaluates the sampler while assign each outputs to their respective channel
-    fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Out)) -> u16;
-}
-
-/// Defines how to sample an track and output it's results
-pub struct TrackSampler<V: SamplerValue, T: Track> {
-    /// These indexes are usually entity indexes within the clip space, a fully defined channel is
-    /// made by a property name plus some index, each track will be sorted by property
-    pub channels: V::Indexes,
-    /// Only applicable when `channels.len() > 0`, defines how many of the output lanes are actually assigned;
-    /// In the case of `len == 0` this track doesn't output anything and should be deleted to preserve performance
-    pub len: u16,
-    pub track: T,
-}
-
-// /// Base sampler type
-// pub struct SamplerBase<T>(Box<dyn Sampler<Out = T> + Send + Sync + 'static>);
-
-// impl<T> Sampler for SamplerBase<T> {
-//     type Out = T;
-
-//     #[inline(always)]
-//     fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Out)) -> u16 {
-//         self.0.sample(cursor, time, assign)
-//     }
-// }
-
-// pub struct SamplerUntyped(Box<dyn Any + Send + Sync + 'static>);
-
-// impl SamplerUntyped {
-//     pub fn new<S>(sampler: S) -> Self
-//     where
-//         S: Sampler + Send + Sync + 'static,
-//     {
-//         SamplerUntyped(Box::new(SamplerBase(Box::new(sampler))))
-//     }
-
-//     #[inline(always)]
-//     pub fn downcast_ref<T: 'static>(&self) -> Option<&SamplerBase<T>> {
-//         self.0.downcast_ref()
-//     }
-
-//     #[inline(always)]
-//     pub fn downcast_mut<T: 'static>(&mut self) -> Option<&mut SamplerBase<T>> {
-//         self.0.downcast_mut()
-//     }
-// }
-
-macro_rules! output1x1 {
-    ($t:ty) => {
-        impl SamplerValue for $t {
-            type Out = $t;
-            type Indexes = [u16; 1];
-
-            #[inline(always)]
-            fn output(self) -> Self::Out {
-                self
-            }
-        }
-
-        impl<T: Track<Out = $t>> Sampler for TrackSampler<$t, T> {
-            type Out = $t;
-
-            fn sample(
-                &self,
-                cursor: u16,
-                time: f32,
-                assign: &mut dyn FnMut(u16, Self::Out),
-            ) -> u16 {
-                let (cursor, x) = self.track.sample_with_cursor(cursor, time);
-                (assign)(self.channels[0], x);
-                cursor
-            }
-        }
-    };
-}
-
-output1x1!(bool);
-output1x1!(u8);
-output1x1!(u16);
-output1x1!(u32);
-output1x1!(u64);
-output1x1!(usize);
-output1x1!(i8);
-output1x1!(i16);
-output1x1!(i32);
-output1x1!(i64);
-output1x1!(isize);
-output1x1!(f32);
-output1x1!(f64);
-
-output1x1!(Vec2);
-output1x1!(Vec3);
-output1x1!(Vec4);
-output1x1!(Color);
-output1x1!(Quat);
-
-macro_rules! output1xn {
-    ($t:ty, $i:ty, $o:ty, $s:tt) => {
-        impl SamplerValue for $t {
-            type Out = [$o; $s];
-            type Indexes = [u16; $s];
-
-            #[inline(always)]
-            fn output(self) -> Self::Out {
-                unsafe { transmute::<[$i; $s], _>(self.into()) }
-            }
-        }
-
-        impl<T: Track<Out = $t>> Sampler for TrackSampler<$t, T> {
-            type Out = $o;
-
-            fn sample(
-                &self,
-                cursor: u16,
-                time: f32,
-                assign: &mut dyn FnMut(u16, Self::Out),
-            ) -> u16 {
-                let (cursor, x) = self.track.sample_with_cursor(cursor, time);
-                let x = x.output();
-                for i in 0..(self.len as usize).min($s - 1) {
-                    (assign)(self.channels[i], x[i]);
-                }
-                cursor
-            }
-        }
-    };
-}
-
-output1xn!(f32x4, f32, f32, 4);
-output1xn!(f32x8, f32, f32, 8);
-output1xn!(Vec3x4, ultraviolet::Vec3, Vec3, 4);
-output1xn!(Vec3x8, ultraviolet::Vec3, Vec3, 8);
-output1xn!(Vec4x4, ultraviolet::Vec4, Vec4, 4);
-output1xn!(Vec4x8, ultraviolet::Vec4, Vec4, 8);
-
-impl SamplerValue for Quatx4 {
-    type Out = [Quat; 4];
-    type Indexes = [u16; 4];
-
-    #[inline(always)]
-    fn output(self) -> Self::Out {
-        unsafe { transmute::<[ultraviolet::Vec4; 4], _>(self.0.into()) }
-    }
-}
-
-impl<T: Track<Out = Quatx4>> Sampler for TrackSampler<Quatx4, T> {
-    type Out = Quat;
-
-    fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Out)) -> u16 {
-        let (cursor, x) = self.track.sample_with_cursor(cursor, time);
-        let x = x.output();
-        for i in 0..(self.len as usize).min(4 - 1) {
-            (assign)(self.channels[i], x[i]);
-        }
-        cursor
-    }
-}
-
-impl SamplerValue for Quatx8 {
-    type Out = [Quat; 8];
-    type Indexes = [u16; 8];
-
-    #[inline(always)]
-    fn output(self) -> Self::Out {
-        unsafe { transmute::<[ultraviolet::Vec4; 8], _>(self.0.into()) }
-    }
-}
-
-impl<T: Track<Out = Quatx8>> Sampler for TrackSampler<Quatx8, T> {
-    type Out = Quat;
-
-    fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Out)) -> u16 {
-        let (cursor, x) = self.track.sample_with_cursor(cursor, time);
-        let x = x.output();
-        for i in 0..(self.len as usize).min(8 - 1) {
-            (assign)(self.channels[i], x[i]);
-        }
-        cursor
-    }
-}
diff --git a/crates/bevy_animation/src/tracks/mod.rs b/crates/bevy_animation/src/tracks/mod.rs
index 094ce13d0f04c..ee3b7b2e1ba14 100644
--- a/crates/bevy_animation/src/tracks/mod.rs
+++ b/crates/bevy_animation/src/tracks/mod.rs
@@ -1,8 +1,10 @@
 mod fixed;
+mod n;
 mod variable;
 mod variable_linear;
 
 pub use fixed::*;
+pub use n::*;
 pub use variable::*;
 pub use variable_linear::*;
 
@@ -22,3 +24,5 @@ pub trait Track {
     /// **NOTE** Each keyframe is indexed by a `u16` to reduce memory usage when using the keyframe caching
     fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, Self::Out);
 }
+
+pub type TrackBase<T> = Box<dyn Track<Out = T> + Send + Sync + 'static>;
diff --git a/crates/bevy_animation/src/tracks/n.rs b/crates/bevy_animation/src/tracks/n.rs
new file mode 100644
index 0000000000000..9699f816e1ab7
--- /dev/null
+++ b/crates/bevy_animation/src/tracks/n.rs
@@ -0,0 +1,225 @@
+use std::mem::transmute;
+
+use bevy_math::prelude::*;
+use bevy_render::prelude::Color;
+
+use crate::{
+    interpolate::Lerp,
+    tracks::{Track, TrackFixed},
+    wide::*,
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+// ? NOTE: Index and IndexMut are only available in rust 1.50.0
+
+/// Array of N elements
+pub unsafe trait ArrayN {
+    type Item;
+
+    fn size() -> usize;
+
+    fn get(&self, index: usize) -> &Self::Item;
+
+    fn get_mut(&mut self, index: usize) -> &mut Self::Item;
+}
+
+macro_rules! arrayn(
+    ($($size:expr),+) => {
+        $(
+            unsafe impl<T> ArrayN for [T; $size] {
+                type Item = T;
+                fn size() -> usize { $size }
+                fn get(&self, index: usize) -> &Self::Item { &self[index] }
+                fn get_mut(&mut self, index: usize) -> &mut Self::Item { &mut self[index] }
+            }
+        )+
+    }
+);
+
+arrayn!(1, 4, 8);
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// N length value
+pub trait ValueN {
+    type Value: Copy;
+
+    /// [u16; N]
+    type Outputs: ArrayN<Item = u16>;
+
+    /// [Self::Value; N]
+    type Lanes: ArrayN<Item = Self::Value>;
+
+    fn unpack(self) -> Self::Lanes;
+
+    /// N
+    fn size() -> usize;
+}
+
+/// Tack with N output lanes
+pub trait TrackN {
+    type Out;
+
+    fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Out)) -> u16;
+
+    /// N
+    fn size(&self) -> usize;
+}
+
+pub struct TrackNData<V: ValueN, T: Track<Out = V>> {
+    /// These indexes are usually entity indexes within the clip space, a fully defined channel is
+    /// made by a property name plus some index, each track will be sorted by property
+    pub outputs: V::Outputs,
+    /// Only applicable when `channels.len() > 0`, defines how many of the output lanes are actually assigned;
+    /// In the case of `len == 0` this track doesn't output anything and should be deleted to preserve performance
+    pub len: u16,
+    pub track: T,
+}
+
+impl<V: ValueN, T: Track<Out = V>> TrackN for TrackNData<V, T> {
+    type Out = V::Value;
+
+    fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Out)) -> u16 {
+        let (cursor, x) = self.track.sample_with_cursor(cursor, time);
+        let x = x.unpack();
+        for i in 0..(self.len as usize).min(self.size() - 1) {
+            (assign)(*self.outputs.get(i), *x.get(i));
+        }
+        cursor
+    }
+
+    #[inline(always)]
+    fn size(&self) -> usize {
+        V::size()
+    }
+}
+
+impl<V: ValueN + Lerp + Clone> TrackNData<V, TrackFixed<V>> {
+    // TODO: Function to edit each lane
+    // pub fn add_track
+    // pub fn add_track_resampled (will accept any kind of track)
+    // pub fn remove_track
+}
+
+pub type TrackNBase<T> = Box<dyn TrackN<Out = T> + Send + Sync + 'static>;
+
+// impl<T> Sampler for SamplerBase<T> {
+//     type Out = T;
+
+//     #[inline(always)]
+//     fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Out)) -> u16 {
+//         self.0.sample(cursor, time, assign)
+//     }
+// }
+
+// pub struct SamplerUntyped(Box<dyn Any + Send + Sync + 'static>);
+
+// impl SamplerUntyped {
+//     pub fn new<S>(sampler: S) -> Self
+//     where
+//         S: Sampler + Send + Sync + 'static,
+//     {
+//         SamplerUntyped(Box::new(SamplerBase(Box::new(sampler))))
+//     }
+
+//     #[inline(always)]
+//     pub fn downcast_ref<T: 'static>(&self) -> Option<&SamplerBase<T>> {
+//         self.0.downcast_ref()
+//     }
+
+//     #[inline(always)]
+//     pub fn downcast_mut<T: 'static>(&mut self) -> Option<&mut SamplerBase<T>> {
+//         self.0.downcast_mut()
+//     }
+// }
+
+///////////////////////////////////////////////////////////////////////////////
+
+macro_rules! output1x1 {
+    ($t:ty) => {
+        impl ValueN for $t {
+            type Value = $t;
+
+            type Outputs = [u16; 1];
+
+            type Lanes = [Self::Value; 1];
+
+            fn unpack(self) -> Self::Lanes {
+                [self]
+            }
+
+            fn size() -> usize {
+                1
+            }
+        }
+    };
+}
+
+output1x1!(bool);
+output1x1!(u8);
+output1x1!(u16);
+output1x1!(u32);
+output1x1!(u64);
+output1x1!(usize);
+output1x1!(i8);
+output1x1!(i16);
+output1x1!(i32);
+output1x1!(i64);
+output1x1!(isize);
+output1x1!(f32);
+output1x1!(f64);
+
+output1x1!(Vec2);
+output1x1!(Vec3);
+output1x1!(Vec4);
+output1x1!(Color);
+output1x1!(Quat);
+
+macro_rules! output1xn {
+    ($t:ty, $i:ty, $o:ty, $s:tt) => {
+        impl ValueN for $t {
+            type Value = $o;
+
+            type Outputs = [u16; $s];
+
+            type Lanes = [Self::Value; $s];
+
+            #[inline(always)]
+            fn unpack(self) -> Self::Lanes {
+                unsafe { transmute::<[$i; $s], _>(self.into()) }
+            }
+
+            fn size() -> usize {
+                $s
+            }
+        }
+    };
+}
+
+output1xn!(f32x4, f32, f32, 4);
+output1xn!(f32x8, f32, f32, 8);
+output1xn!(Vec3x4, ultraviolet::Vec3, Vec3, 4);
+output1xn!(Vec3x8, ultraviolet::Vec3, Vec3, 8);
+output1xn!(Vec4x4, ultraviolet::Vec4, Vec4, 4);
+output1xn!(Vec4x8, ultraviolet::Vec4, Vec4, 8);
+
+// impl SamplerValue for Quatx4 {
+//     type Out = [Quat; 4];
+//     type Indexes = [u16; 4];
+
+//     #[inline(always)]
+//     fn output(self) -> Self::Out {
+//         unsafe { transmute::<[ultraviolet::Vec4; 4], _>(self.0.into()) }
+//     }
+// }
+
+// impl SamplerValue for Quatx8 {
+//     type Out = [Quat; 8];
+//     type Indexes = [u16; 8];
+
+//     #[inline(always)]
+//     fn output(self) -> Self::Out {
+//         unsafe { transmute::<[ultraviolet::Vec4; 8], _>(self.0.into()) }
+//     }
+// }
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 4b7125b03fa48..427f5cdc56a83 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -1,5 +1,5 @@
 use anyhow::Result;
-use bevy_animation::prelude::*;
+use bevy_animation::{prelude::*, tracks::*};
 use bevy_asset::{AssetIoError, AssetLoader, AssetPath, Handle, LoadContext, LoadedAsset};
 use bevy_core::Name;
 use bevy_ecs::{bevy_utils::BoxedFuture, Entity, World, WorldBuilderSource};
@@ -305,21 +305,22 @@ async fn load_gltf<'a, 'b>(
                     let values = values.map(|v| Vec3::from(v)).collect::<Vec<_>>();
                     property_path += "@Transform.translation";
                     clip_curves_translation_and_scale
-                        .push((property_path, Curve::new(time_stamps, values)));
+                        .push((property_path, TrackVariableLinear::new(time_stamps, values)));
 
                     // TODO: This is a runtime importer so here's no place for further optimizations
                 }
                 ReadOutputs::Rotations(values) => {
                     let values = values.into_f32().map(|v| Quat::from(v)).collect::<Vec<_>>();
                     property_path += "@Transform.rotation";
-                    clip_curves_rotation.push((property_path, Curve::new(time_stamps, values)));
+                    clip_curves_rotation
+                        .push((property_path, TrackVariableLinear::new(time_stamps, values)));
                 }
                 ReadOutputs::Scales(values) => {
                     let values = values.map(|v| Vec3::from(v)).collect::<Vec<_>>();
 
                     property_path += "@Transform.scale";
                     clip_curves_translation_and_scale
-                        .push((property_path, Curve::new(time_stamps, values)));
+                        .push((property_path, TrackVariableLinear::new(time_stamps, values)));
                 }
                 ReadOutputs::MorphTargetWeights(_) => {
                     unimplemented!("morph targets aren't current supported")
@@ -329,13 +330,13 @@ async fn load_gltf<'a, 'b>(
 
         // Make sure the start frame is always 0.0
         for (property_path, mut curve) in clip_curves_rotation {
-            Curve::<Quat>::add_offset_time(&mut curve, -start_time);
+            TrackVariableLinear::<Quat>::add_offset_time(&mut curve, -start_time);
             //curve.add_time_offset(-start_time);
             clip.add_curve_at_path(&property_path, curve);
         }
 
         for (property_path, mut curve) in clip_curves_translation_and_scale {
-            Curve::<Vec3>::add_offset_time(&mut curve, -start_time);
+            TrackVariableLinear::<Vec3>::add_offset_time(&mut curve, -start_time);
             //curve.add_time_offset(-start_time);
             clip.add_curve_at_path(&property_path, curve);
         }

From cc85a7b3cc5bfb963bba3482ea1580e2eac15e0d Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sat, 30 Jan 2021 02:13:32 -0300
Subject: [PATCH 095/153] added support for multilane track (extra overhead for
 single lane tracks)

---
 crates/bevy_animation/src/animator.rs         | 174 ++++++++++--------
 crates/bevy_animation/src/reflect.rs          |  40 ++--
 crates/bevy_animation/src/tracks/fixed.rs     |   6 +-
 crates/bevy_animation/src/tracks/mod.rs       |  17 +-
 crates/bevy_animation/src/tracks/n.rs         | 109 +++++++----
 crates/bevy_animation/src/tracks/variable.rs  |   6 +-
 .../src/tracks/variable_linear.rs             |   6 +-
 crates/bevy_gltf/src/loader.rs                |   4 +-
 8 files changed, 209 insertions(+), 153 deletions(-)

diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index 8a47603c813f2..94cd37163f21a 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -12,14 +12,13 @@ use bevy_ecs::prelude::*;
 use bevy_reflect::{Reflect, ReflectComponent, TypeUuid};
 use bevy_transform::prelude::*;
 use fnv::FnvBuildHasher;
-use smallvec::{smallvec, SmallVec};
 use tracing::warn;
 
 use crate::{
     blending::AnimatorBlending,
     hierarchy::Hierarchy,
     interpolate::Lerp,
-    tracks::{Track, TrackBase},
+    tracks::{Track, TrackNBase, TrackNData, ValueN},
 };
 
 // TODO: Load Clip name from gltf
@@ -46,39 +45,38 @@ const KEYFRAMES_PER_CACHE: usize = CACHE_SIZE / std::mem::size_of::<u16>();
 ///////////////////////////////////////////////////////////////////////////////
 
 pub struct Tracks<T> {
-    entity_indexes: SmallVec<[u16; 8]>,
     /// Pair of curve and it's index
-    curves: Vec<(usize, TrackBase<T>)>,
+    inner: Vec<(usize, TrackNBase<T>)>,
 }
 
 impl<T> std::fmt::Debug for Tracks<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_tuple("Tracks").field(&self.curves.len()).finish()
+        f.debug_tuple("Tracks").field(&self.len()).finish()
     }
 }
 
 impl<T> Tracks<T> {
     fn calculate_duration(&self) -> f32 {
-        self.curves
+        self.inner
             .iter()
-            .map(|(_, c)| c.duration())
+            .map(|(_, track)| track.duration())
             .fold(0.0f32, |acc, d| acc.max(d))
     }
 
     /// Number of curves inside
     #[inline(always)]
     pub fn len(&self) -> usize {
-        self.curves.len()
+        self.inner.len()
     }
 
     #[inline(always)]
-    pub fn iter(&self) -> impl Iterator<Item = (u16, &(usize, TrackBase<T>))> {
-        self.entity_indexes.iter().copied().zip(self.curves.iter())
+    pub fn iter(&self) -> impl Iterator<Item = &(usize, TrackNBase<T>)> {
+        self.inner.iter()
     }
 }
-pub struct CurveMeta(&'static str, TypeId);
+pub struct TrackMeta(&'static str, TypeId);
 
-impl CurveMeta {
+impl TrackMeta {
     pub fn of<T: 'static>() -> Self {
         Self(type_name::<T>(), TypeId::of::<T>())
     }
@@ -92,30 +90,30 @@ impl CurveMeta {
     }
 }
 
-impl std::fmt::Debug for CurveMeta {
+impl std::fmt::Debug for TrackMeta {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_tuple("CurveMeta").field(&self.0).finish()
+        f.debug_tuple("TrackMeta").field(&self.0).finish()
     }
 }
 
 #[derive(Debug)]
-pub struct CurvesUntyped {
+pub struct TracksUntyped {
     /// Cached calculated curves duration
     duration: f32,
-    meta: CurveMeta,
+    meta: TrackMeta,
     untyped: Box<dyn Any + Send + Sync + 'static>,
 }
 
-impl CurvesUntyped {
-    fn new<T: Send + Sync + 'static>(curves: Tracks<T>) -> Self {
-        CurvesUntyped {
-            duration: curves.calculate_duration(),
-            meta: CurveMeta::of::<T>(),
-            untyped: Box::new(curves),
+impl TracksUntyped {
+    fn new<T: Send + Sync + 'static>(tracks: Tracks<T>) -> Self {
+        TracksUntyped {
+            duration: tracks.calculate_duration(),
+            meta: TrackMeta::of::<T>(),
+            untyped: Box::new(tracks),
         }
     }
 
-    pub const fn meta(&self) -> &CurveMeta {
+    pub const fn meta(&self) -> &TrackMeta {
         &self.meta
     }
 
@@ -174,7 +172,7 @@ pub struct Clip {
     // ? NOTE: AHash performed worse than FnvHasher
     // TODO: Change to the hashbrown::raw::RawTable and use a `label!()` to make hashes constants
     /// Each curve and keyframe cache index mapped by property name
-    properties: HashMap<String, (usize, CurvesUntyped), FnvBuildHasher>,
+    properties: HashMap<String, (usize, TracksUntyped), FnvBuildHasher>,
     /// Number of animated properties
     len: usize,
     /// Number of cache lines currently been used to organize the keyframe
@@ -211,13 +209,13 @@ impl Clip {
     ///
     /// **NOTE** You can safely ignore the return value as it's only used for assertions during tests;
     /// The return value is the assigned curve index in cache line bucket.
-    pub fn add_curve_at_path<T>(&mut self, path: &str, track: T) -> usize
+    pub fn add_track_at_path<T>(&mut self, path: &str, track: T) -> usize
     where
         T: Track + Send + Sync + 'static,
-        <T as Track>::Out: Lerp + Clone + Send + Sync + 'static,
+        <T as Track>::Output: Lerp + Clone + Send + Sync + 'static,
+        // Means this track have a single lane
+        <T as Track>::Output: ValueN<Value = <T as Track>::Output, Lanes = [u16; 1]>,
     {
-        let mut track: TrackBase<<T as Track>::Out> = Box::new(track);
-
         // Split in entity and attribute path,
         // NOTE: use rfind because it's expected the latter to be generally shorter
         let path = path.split_at(path.rfind('@').expect("property path missing @"));
@@ -233,35 +231,47 @@ impl Clip {
 
         let (entity_index, _) = self.hierarchy.get_or_insert_entity(entity_path);
 
-        if let Some((cache_index, curves_untyped)) = self.properties.get_mut(property_path) {
-            let curves = curves_untyped
-                .downcast_mut::<<T as Track>::Out>()
+        if let Some((cache_index, tracks_untyped)) = self.properties.get_mut(property_path) {
+            let tracks = tracks_untyped
+                .downcast_mut::<<T as Track>::Output>()
                 .expect("properties can't have the same name and different curve types");
 
+            let search = tracks.iter().enumerate().find_map(|(i, (_, t))| {
+                t.lanes()
+                    .into_iter()
+                    .position(|index| *index == entity_index)
+                    .map(|o| (i, o))
+            });
+
             // If some entity was created it means this property is a new one so we can safely skip the attribute testing
-            if let Some(i) = curves
-                .entity_indexes
-                .iter()
-                .position(|index| *index == entity_index)
-            {
-                let (curve_index, curve_untyped) = &mut curves.curves[i];
-                let curve_index = *curve_index;
+            if let Some((track_index, _lane_index)) = search {
+                let (k_index, track_a) = &mut tracks.inner[track_index];
+                if track_a.size() == 1 {
+                    let k_index = *k_index;
+                    let mut track_b: TrackNBase<<T as Track>::Output> = Box::new(TrackNData {
+                        lanes: [entity_index],
+                        len: 1,
+                        track,
+                    });
 
-                // Found a property equal to the one been inserted, next replace the curve
-                std::mem::swap(curve_untyped, &mut track);
+                    // Found a property equal to the one been inserted, next replace the curve
+                    std::mem::swap(track_a, &mut track_b);
 
-                // Update curve duration in two stages
-                let duration = curves.calculate_duration();
+                    // Update curve duration in two stages
+                    let duration = tracks.calculate_duration();
 
-                // Drop the down casted ref and update the parent curve
-                std::mem::drop(curves);
-                curves_untyped.duration = duration;
+                    // Drop the down casted ref and update the parent curve
+                    std::mem::drop(tracks);
+                    tracks_untyped.duration = duration;
 
-                // Drop the curves untyped (which as a mut borrow) and update the total duration
-                std::mem::drop(curves_untyped);
-                self.duration = self.calculate_duration();
+                    // Drop the curves untyped (which as a mut borrow) and update the total duration
+                    std::mem::drop(tracks_untyped);
+                    self.duration = self.calculate_duration();
 
-                return curve_index;
+                    return k_index;
+                } else {
+                    panic!("replacing a single lane in multi lane track isn't supported")
+                }
             } else {
                 *cache_index += 1;
                 if (*cache_index % KEYFRAMES_PER_CACHE) == 0 {
@@ -274,14 +284,18 @@ impl Clip {
 
                 // Append newly added curve
                 let duration = track.duration();
+                let track_n = Box::new(TrackNData {
+                    lanes: [entity_index],
+                    len: 1,
+                    track,
+                });
 
-                curves.curves.push((*cache_index, track));
-                curves.entity_indexes.push(entity_index);
-                std::mem::drop(curves);
+                tracks.inner.push((*cache_index, track_n));
+                std::mem::drop(tracks);
 
                 self.len += 1;
                 self.duration = self.duration.max(duration);
-                curves_untyped.duration = curves_untyped.duration.max(duration);
+                tracks_untyped.duration = tracks_untyped.duration.max(duration);
 
                 return *cache_index;
             }
@@ -296,9 +310,15 @@ impl Clip {
             property_path.to_string(),
             (
                 cache_index,
-                CurvesUntyped::new(Tracks {
-                    curves: vec![(cache_index, track)],
-                    entity_indexes: smallvec![entity_index],
+                TracksUntyped::new(Tracks {
+                    inner: vec![(
+                        cache_index,
+                        Box::new(TrackNData {
+                            lanes: [entity_index],
+                            len: 1,
+                            track,
+                        }),
+                    )],
                 }),
             ),
         );
@@ -351,7 +371,7 @@ impl Clip {
 
     /// Get the curves an given property
     #[inline(always)]
-    pub fn get(&self, property_name: &str) -> Option<&CurvesUntyped> {
+    pub fn get(&self, property_name: &str) -> Option<&TracksUntyped> {
         self.properties
             .get(property_name)
             .map(|(_, curve_untyped)| curve_untyped)
@@ -825,17 +845,17 @@ mod tests {
             let mut animator = Animator::default();
             {
                 let mut clip_a = Clip::default();
-                clip_a.add_curve_at_path(
+                clip_a.add_track_at_path(
                     "@Transform.translation",
                     TrackVariableLinear::from_line(0.0, 1.0, Vec3::unit_x(), -Vec3::unit_x()),
                 );
                 let rot = TrackVariableLinear::from_constant(Quat::identity());
-                clip_a.add_curve_at_path("@Transform.rotation", rot.clone());
-                clip_a.add_curve_at_path("/Node1@Transform.rotation", rot.clone());
-                clip_a.add_curve_at_path("/Node1/Node2@Transform.rotation", rot);
+                clip_a.add_track_at_path("@Transform.rotation", rot.clone());
+                clip_a.add_track_at_path("/Node1@Transform.rotation", rot.clone());
+                clip_a.add_track_at_path("/Node1/Node2@Transform.rotation", rot);
 
                 let mut clip_b = Clip::default();
-                clip_b.add_curve_at_path(
+                clip_b.add_track_at_path(
                     "@Transform.translation",
                     TrackVariableLinear::from_constant(Vec3::zero()),
                 );
@@ -845,9 +865,9 @@ mod tests {
                     Quat::from_axis_angle(Vec3::unit_z(), 0.1),
                     Quat::from_axis_angle(Vec3::unit_z(), -0.1),
                 );
-                clip_b.add_curve_at_path("@Transform.rotation", rot.clone());
-                clip_b.add_curve_at_path("/Node1@Transform.rotation", rot.clone());
-                clip_b.add_curve_at_path("/Node1/Node2@Transform.rotation", rot);
+                clip_b.add_track_at_path("@Transform.rotation", rot.clone());
+                clip_b.add_track_at_path("/Node1@Transform.rotation", rot.clone());
+                clip_b.add_track_at_path("/Node1/Node2@Transform.rotation", rot);
 
                 let mut clips = app_builder
                     .resources_mut()
@@ -1220,7 +1240,7 @@ mod tests {
             let clip_a_handle = test_bench.animator().clips()[0].clone();
             let mut clips = test_bench.app.resources.get_mut::<Assets<Clip>>().unwrap();
             let clip_a = clips.get_mut(clip_a_handle).unwrap();
-            clip_a.add_curve_at_path(
+            clip_a.add_track_at_path(
                 "/Node3/@Transform.translation",
                 TrackVariableLinear::from_line(0.0, 1.0, Vec3::unit_z(), -Vec3::unit_z()),
             );
@@ -1253,40 +1273,40 @@ mod tests {
     fn clip_property_index_are_grouped_into_cache_line_buckets() {
         let curve = TrackVariableLinear::from_constant(0.0);
         let mut clip = Clip::default();
-        assert_eq!(clip.add_curve_at_path("a@T.t", curve.clone()), 0);
-        assert_eq!(clip.add_curve_at_path("b@T.t", curve.clone()), 1);
+        assert_eq!(clip.add_track_at_path("a@T.t", curve.clone()), 0);
+        assert_eq!(clip.add_track_at_path("b@T.t", curve.clone()), 1);
         assert_eq!(
-            clip.add_curve_at_path("a@T.r", curve.clone()),
+            clip.add_track_at_path("a@T.r", curve.clone()),
             KEYFRAMES_PER_CACHE
         );
-        assert_eq!(clip.add_curve_at_path("c@T.t", curve.clone()), 2);
+        assert_eq!(clip.add_track_at_path("c@T.t", curve.clone()), 2);
         assert_eq!(
-            clip.add_curve_at_path("b@T.r", curve.clone()),
+            clip.add_track_at_path("b@T.r", curve.clone()),
             KEYFRAMES_PER_CACHE + 1
         );
         assert_eq!(
-            clip.add_curve_at_path("c@T.r", curve.clone()),
+            clip.add_track_at_path("c@T.r", curve.clone()),
             KEYFRAMES_PER_CACHE + 2
         );
-        assert_eq!(clip.add_curve_at_path("d@T.t", curve.clone()), 3);
+        assert_eq!(clip.add_track_at_path("d@T.t", curve.clone()), 3);
 
         for i in 4..KEYFRAMES_PER_CACHE {
             assert_eq!(
-                clip.add_curve_at_path(&format!("node_{}@T.t", i), curve.clone()),
+                clip.add_track_at_path(&format!("node_{}@T.t", i), curve.clone()),
                 i
             );
         }
 
         assert_eq!(
-            clip.add_curve_at_path("za@T.t", curve.clone()),
+            clip.add_track_at_path("za@T.t", curve.clone()),
             KEYFRAMES_PER_CACHE * 2
         );
         assert_eq!(
-            clip.add_curve_at_path("za@T.r", curve.clone()),
+            clip.add_track_at_path("za@T.r", curve.clone()),
             KEYFRAMES_PER_CACHE + 3
         );
         assert_eq!(
-            clip.add_curve_at_path("zb@T.t", curve.clone()),
+            clip.add_track_at_path("zb@T.t", curve.clone()),
             KEYFRAMES_PER_CACHE * 2 + 1
         );
     }
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index 1f7ac7b950fd6..e3732d016f80d 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -118,17 +118,16 @@ unsafe fn animate<T>(
         .map(|curve_untyped| curve_untyped.downcast_ref::<T>())
         .flatten()
     {
-        for (entity_index, (curve_index, curve)) in curves.iter() {
-            let entity_index = entities_map[entity_index as usize] as usize;
-            if let Some(component) = (get_mut)(entity_index) {
-                let kr = &mut keyframes[*curve_index];
-                let (k, v) = curve.sample_with_cursor(*kr, time);
-                *kr = k;
-
-                // Unsafe portion
-                let value = &mut *(component.offset(prop.offset) as *mut T);
-                value.blend(entity_index, prop.mask, blend_group, v, w);
-            }
+        for (curve_index, curve) in curves.iter() {
+            let cursor = &mut keyframes[*curve_index];
+            *cursor = curve.sample(*cursor, time, &mut |output_lane, v| {
+                let entity_index = entities_map[output_lane as usize] as usize;
+                if let Some(component) = (get_mut)(entity_index) {
+                    // Unsafe portion
+                    let value = &mut *(component.offset(prop.offset) as *mut T);
+                    value.blend(entity_index, prop.mask, blend_group, v, w);
+                }
+            });
         }
     }
 }
@@ -453,16 +452,15 @@ pub(crate) fn animate_asset_system<T: Asset>(
                     .map(|curve_untyped| curve_untyped.downcast_ref::<Handle<T>>())
                     .flatten()
                 {
-                    for (entity_index, (curve_index, curve)) in curves.iter() {
-                        let entity_index = entities_map[entity_index as usize] as usize;
-                        if let Some(ref mut component) = cached_components[entity_index] {
-                            let kr = &mut keyframes[*curve_index];
-                            let (k, v) = curve.sample_with_cursor(*kr, time);
-                            *kr = k;
-
-                            let value = &mut **component;
-                            value.blend(entity_index, prop_mask, &mut blend_group, v, w);
-                        }
+                    for (curve_index, curve) in curves.iter() {
+                        let cursor = &mut keyframes[*curve_index];
+                        *cursor = curve.sample(*cursor, time, &mut |output_lane, v| {
+                            let entity_index = entities_map[output_lane as usize] as usize;
+                            if let Some(ref mut component) = cached_components[entity_index] {
+                                let value = &mut **component;
+                                value.blend(entity_index, prop_mask, &mut blend_group, v, w);
+                            }
+                        });
                     }
                 }
             }
diff --git a/crates/bevy_animation/src/tracks/fixed.rs b/crates/bevy_animation/src/tracks/fixed.rs
index 9ba5b6c672f66..5a2b70f22a3e1 100644
--- a/crates/bevy_animation/src/tracks/fixed.rs
+++ b/crates/bevy_animation/src/tracks/fixed.rs
@@ -69,13 +69,13 @@ impl<T> Track for TrackFixed<T>
 where
     T: Lerp + Clone,
 {
-    type Out = T;
+    type Output = T;
 
     fn duration(&self) -> f32 {
         ((self.keyframes.len() as f32 - 1.0 - self.negative_offset) / self.frame_rate).max(0.0)
     }
 
-    fn sample(&self, time: f32) -> T {
+    fn sample(&self, time: f32) -> Self::Output {
         // Make sure to have at least one sample
         assert!(self.keyframes.len() > 0, "curve is empty");
 
@@ -108,7 +108,7 @@ where
 
     /// Same as `sample` function
     #[inline(always)]
-    fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, T) {
+    fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, Self::Output) {
         let _ = cursor;
         (0, self.sample(time))
     }
diff --git a/crates/bevy_animation/src/tracks/mod.rs b/crates/bevy_animation/src/tracks/mod.rs
index ee3b7b2e1ba14..a50a9946d8a2c 100644
--- a/crates/bevy_animation/src/tracks/mod.rs
+++ b/crates/bevy_animation/src/tracks/mod.rs
@@ -1,3 +1,12 @@
+//! The bread and butter of the animation system tracks are the source of
+//! data at given state and comes in 3 different flavours: `TrackFixed`, `TrackVariantLinear`  
+//! and `TrackVariant`;
+//!
+//! Each track implements the `Track` trait but the animation system it self uses
+//! the `TrackN` trait which implements a wide track type capable of outputting
+//! multiple values for each sampling call, they can also be used for narrow track as well
+//! (only a single output).
+
 mod fixed;
 mod n;
 mod variable;
@@ -9,7 +18,7 @@ pub use variable::*;
 pub use variable_linear::*;
 
 pub trait Track {
-    type Out;
+    type Output;
 
     fn duration(&self) -> f32;
 
@@ -17,12 +26,12 @@ pub trait Track {
     /// the keyframe cursor, but is more expensive always `O(n)`. Which means
     /// sampling takes longer to evaluate as much as time get closer to curve duration
     /// and it get worse with more keyframes.
-    fn sample(&self, time: f32) -> Self::Out;
+    fn sample(&self, time: f32) -> Self::Output;
 
     /// Samples the curve starting from some keyframe cursor, this make the common case `O(1)`
     ///
     /// **NOTE** Each keyframe is indexed by a `u16` to reduce memory usage when using the keyframe caching
-    fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, Self::Out);
+    fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, Self::Output);
 }
 
-pub type TrackBase<T> = Box<dyn Track<Out = T> + Send + Sync + 'static>;
+pub type TrackBase<T> = Box<dyn Track<Output = T> + Send + Sync + 'static>;
diff --git a/crates/bevy_animation/src/tracks/n.rs b/crates/bevy_animation/src/tracks/n.rs
index 9699f816e1ab7..98455462436f4 100644
--- a/crates/bevy_animation/src/tracks/n.rs
+++ b/crates/bevy_animation/src/tracks/n.rs
@@ -22,6 +22,10 @@ pub unsafe trait ArrayN {
     fn get(&self, index: usize) -> &Self::Item;
 
     fn get_mut(&mut self, index: usize) -> &mut Self::Item;
+
+    fn as_slice(&self) -> &[Self::Item];
+
+    fn as_slice_mut(&mut self) -> &mut [Self::Item];
 }
 
 macro_rules! arrayn(
@@ -32,6 +36,8 @@ macro_rules! arrayn(
                 fn size() -> usize { $size }
                 fn get(&self, index: usize) -> &Self::Item { &self[index] }
                 fn get_mut(&mut self, index: usize) -> &mut Self::Item { &mut self[index] }
+                fn as_slice(&self) -> &[Self::Item] { &self[..] }
+                fn as_slice_mut(&mut self) -> &mut [Self::Item] { &mut self[..] }
             }
         )+
     }
@@ -46,12 +52,12 @@ pub trait ValueN {
     type Value: Copy;
 
     /// [u16; N]
-    type Outputs: ArrayN<Item = u16>;
+    type Lanes: ArrayN<Item = u16>;
 
     /// [Self::Value; N]
-    type Lanes: ArrayN<Item = Self::Value>;
+    type Outputs: ArrayN<Item = Self::Value>;
 
-    fn unpack(self) -> Self::Lanes;
+    fn unpack(self) -> Self::Outputs;
 
     /// N
     fn size() -> usize;
@@ -59,37 +65,46 @@ pub trait ValueN {
 
 /// Tack with N output lanes
 pub trait TrackN {
-    type Out;
+    type Output;
+
+    fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Output)) -> u16;
+
+    fn duration(&self) -> f32;
 
-    fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Out)) -> u16;
+    fn lanes(&self) -> &[u16];
 
     /// N
     fn size(&self) -> usize;
 }
 
-pub struct TrackNData<V: ValueN, T: Track<Out = V>> {
-    /// These indexes are usually entity indexes within the clip space, a fully defined channel is
-    /// made by a property name plus some index, each track will be sorted by property
-    pub outputs: V::Outputs,
-    /// Only applicable when `channels.len() > 0`, defines how many of the output lanes are actually assigned;
+pub struct TrackNData<V: ValueN, T: Track<Output = V>> {
+    pub lanes: V::Lanes,
+    /// Only applicable when `outputs.len() > 0`, defines how many of the output lanes are actually assigned;
     /// In the case of `len == 0` this track doesn't output anything and should be deleted to preserve performance
     pub len: u16,
     pub track: T,
 }
 
-impl<V: ValueN, T: Track<Out = V>> TrackN for TrackNData<V, T> {
-    type Out = V::Value;
+impl<V: ValueN, T: Track<Output = V>> TrackN for TrackNData<V, T> {
+    type Output = V::Value;
 
-    fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Out)) -> u16 {
+    fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Output)) -> u16 {
         let (cursor, x) = self.track.sample_with_cursor(cursor, time);
         let x = x.unpack();
-        for i in 0..(self.len as usize).min(self.size() - 1) {
-            (assign)(*self.outputs.get(i), *x.get(i));
+        for i in 0..(self.len as usize).min(self.size()) {
+            (assign)(*self.lanes.get(i), *x.get(i));
         }
         cursor
     }
 
-    #[inline(always)]
+    fn duration(&self) -> f32 {
+        self.track.duration()
+    }
+
+    fn lanes(&self) -> &[u16] {
+        self.lanes.as_slice()
+    }
+
     fn size(&self) -> usize {
         V::size()
     }
@@ -102,13 +117,13 @@ impl<V: ValueN + Lerp + Clone> TrackNData<V, TrackFixed<V>> {
     // pub fn remove_track
 }
 
-pub type TrackNBase<T> = Box<dyn TrackN<Out = T> + Send + Sync + 'static>;
+pub type TrackNBase<T> = Box<dyn TrackN<Output = T> + Send + Sync + 'static>;
 
 // impl<T> Sampler for SamplerBase<T> {
 //     type Out = T;
 
 //     #[inline(always)]
-//     fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Out)) -> u16 {
+//     fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Output)) -> u16 {
 //         self.0.sample(cursor, time, assign)
 //     }
 // }
@@ -141,11 +156,11 @@ macro_rules! output1x1 {
         impl ValueN for $t {
             type Value = $t;
 
-            type Outputs = [u16; 1];
+            type Lanes = [u16; 1];
 
-            type Lanes = [Self::Value; 1];
+            type Outputs = [Self::Value; 1];
 
-            fn unpack(self) -> Self::Lanes {
+            fn unpack(self) -> Self::Outputs {
                 [self]
             }
 
@@ -181,12 +196,12 @@ macro_rules! output1xn {
         impl ValueN for $t {
             type Value = $o;
 
-            type Outputs = [u16; $s];
+            type Lanes = [u16; $s];
 
-            type Lanes = [Self::Value; $s];
+            type Outputs = [Self::Value; $s];
 
             #[inline(always)]
-            fn unpack(self) -> Self::Lanes {
+            fn unpack(self) -> Self::Outputs {
                 unsafe { transmute::<[$i; $s], _>(self.into()) }
             }
 
@@ -204,22 +219,36 @@ output1xn!(Vec3x8, ultraviolet::Vec3, Vec3, 8);
 output1xn!(Vec4x4, ultraviolet::Vec4, Vec4, 4);
 output1xn!(Vec4x8, ultraviolet::Vec4, Vec4, 8);
 
-// impl SamplerValue for Quatx4 {
-//     type Out = [Quat; 4];
-//     type Indexes = [u16; 4];
+impl ValueN for Quatx4 {
+    type Value = Quat;
 
-//     #[inline(always)]
-//     fn output(self) -> Self::Out {
-//         unsafe { transmute::<[ultraviolet::Vec4; 4], _>(self.0.into()) }
-//     }
-// }
+    type Lanes = [u16; 4];
 
-// impl SamplerValue for Quatx8 {
-//     type Out = [Quat; 8];
-//     type Indexes = [u16; 8];
+    type Outputs = [Self::Value; 4];
 
-//     #[inline(always)]
-//     fn output(self) -> Self::Out {
-//         unsafe { transmute::<[ultraviolet::Vec4; 8], _>(self.0.into()) }
-//     }
-// }
+    #[inline(always)]
+    fn unpack(self) -> Self::Outputs {
+        unsafe { transmute::<[ultraviolet::Vec4; 4], _>(self.0.into()) }
+    }
+
+    fn size() -> usize {
+        4
+    }
+}
+
+impl ValueN for Quatx8 {
+    type Value = Quat;
+
+    type Lanes = [u16; 8];
+
+    type Outputs = [Self::Value; 8];
+
+    #[inline(always)]
+    fn unpack(self) -> Self::Outputs {
+        unsafe { transmute::<[ultraviolet::Vec4; 8], _>(self.0.into()) }
+    }
+
+    fn size() -> usize {
+        8
+    }
+}
diff --git a/crates/bevy_animation/src/tracks/variable.rs b/crates/bevy_animation/src/tracks/variable.rs
index 815a44433a179..44b546ed7d010 100644
--- a/crates/bevy_animation/src/tracks/variable.rs
+++ b/crates/bevy_animation/src/tracks/variable.rs
@@ -110,13 +110,13 @@ impl<T> Track for TrackVariable<T>
 where
     T: Interpolate + Clone + 'static,
 {
-    type Out = T;
+    type Output = T;
 
     fn duration(&self) -> f32 {
         self.time_stamps.last().copied().unwrap_or(0.0)
     }
 
-    fn sample(&self, time: f32) -> Self::Out {
+    fn sample(&self, time: f32) -> Self::Output {
         // Index guessing gives a small search optimization
         let index = if time < self.duration() * 0.5 {
             0
@@ -127,7 +127,7 @@ where
         self.sample_with_cursor(index as u16, time).1
     }
 
-    fn sample_with_cursor(&self, mut cursor: u16, time: f32) -> (u16, Self::Out) {
+    fn sample_with_cursor(&self, mut cursor: u16, time: f32) -> (u16, Self::Output) {
         // Adjust for the current keyframe cursor
         let last_cursor = (self.time_stamps.len() - 1) as u16;
 
diff --git a/crates/bevy_animation/src/tracks/variable_linear.rs b/crates/bevy_animation/src/tracks/variable_linear.rs
index 779274a1a37c0..ca8384aa2b967 100644
--- a/crates/bevy_animation/src/tracks/variable_linear.rs
+++ b/crates/bevy_animation/src/tracks/variable_linear.rs
@@ -93,13 +93,13 @@ impl<T> Track for TrackVariableLinear<T>
 where
     T: Lerp + Clone + 'static,
 {
-    type Out = T;
+    type Output = T;
 
     fn duration(&self) -> f32 {
         self.time_stamps.last().copied().unwrap_or(0.0)
     }
 
-    fn sample(&self, time: f32) -> Self::Out {
+    fn sample(&self, time: f32) -> Self::Output {
         // Index guessing gives a small search optimization
         let index = if time < self.duration() * 0.5 {
             0
@@ -110,7 +110,7 @@ where
         self.sample_with_cursor(index as u16, time).1
     }
 
-    fn sample_with_cursor(&self, mut cursor: u16, time: f32) -> (u16, Self::Out) {
+    fn sample_with_cursor(&self, mut cursor: u16, time: f32) -> (u16, Self::Output) {
         // Adjust for the current keyframe index
         let last_cursor = (self.time_stamps.len() - 1) as u16;
 
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 427f5cdc56a83..83714eec0e726 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -332,13 +332,13 @@ async fn load_gltf<'a, 'b>(
         for (property_path, mut curve) in clip_curves_rotation {
             TrackVariableLinear::<Quat>::add_offset_time(&mut curve, -start_time);
             //curve.add_time_offset(-start_time);
-            clip.add_curve_at_path(&property_path, curve);
+            clip.add_track_at_path(&property_path, curve);
         }
 
         for (property_path, mut curve) in clip_curves_translation_and_scale {
             TrackVariableLinear::<Vec3>::add_offset_time(&mut curve, -start_time);
             //curve.add_time_offset(-start_time);
-            clip.add_curve_at_path(&property_path, curve);
+            clip.add_track_at_path(&property_path, curve);
         }
 
         load_context.set_labeled_asset(&anim_label, LoadedAsset::new(clip));

From 93b1af29f85d3e8fb3e544bf24f5574ad4ce8e13 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sat, 30 Jan 2021 09:55:42 -0300
Subject: [PATCH 096/153] reduce multilane track overhead

---
 crates/bevy_animation/src/animator.rs | 146 ++++++++++++++------------
 crates/bevy_animation/src/reflect.rs  |  60 +++++++++--
 crates/bevy_animation/src/tracks/n.rs |  98 ++++-------------
 3 files changed, 145 insertions(+), 159 deletions(-)

diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index 94cd37163f21a..c57bc2aa5134f 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -12,13 +12,14 @@ use bevy_ecs::prelude::*;
 use bevy_reflect::{Reflect, ReflectComponent, TypeUuid};
 use bevy_transform::prelude::*;
 use fnv::FnvBuildHasher;
+use smallvec::{smallvec, SmallVec};
 use tracing::warn;
 
 use crate::{
     blending::AnimatorBlending,
     hierarchy::Hierarchy,
     interpolate::Lerp,
-    tracks::{Track, TrackNBase, TrackNData, ValueN},
+    tracks::{Track, TrackBase, TrackNBase},
 };
 
 // TODO: Load Clip name from gltf
@@ -45,8 +46,13 @@ const KEYFRAMES_PER_CACHE: usize = CACHE_SIZE / std::mem::size_of::<u16>();
 ///////////////////////////////////////////////////////////////////////////////
 
 pub struct Tracks<T> {
-    /// Pair of curve and it's index
-    inner: Vec<(usize, TrackNBase<T>)>,
+    outputs: SmallVec<[u16; 8]>,
+    /// Tuple of track and it's index
+    tracks: Vec<(usize, TrackBase<T>)>,
+    /// Similar to `tracks` but simultaneously has many outputs
+    ///
+    /// **NOTE** It has its own `outputs` stored inside
+    n: Vec<(usize, TrackNBase<T>)>,
 }
 
 impl<T> std::fmt::Debug for Tracks<T> {
@@ -56,24 +62,36 @@ impl<T> std::fmt::Debug for Tracks<T> {
 }
 
 impl<T> Tracks<T> {
+    /// Possible expensive function that calculates from scratch the total tracks duration;
+    ///
+    /// **NOTE** Caching the result value is desired
     fn calculate_duration(&self) -> f32 {
-        self.inner
+        self.tracks
             .iter()
             .map(|(_, track)| track.duration())
+            .chain(self.n.iter().map(|(_, track)| track.duration()))
             .fold(0.0f32, |acc, d| acc.max(d))
     }
 
     /// Number of curves inside
-    #[inline(always)]
     pub fn len(&self) -> usize {
-        self.inner.len()
+        self.tracks.len() + self.n.iter().map(|(_, t)| t.len()).sum::<usize>()
     }
 
     #[inline(always)]
-    pub fn iter(&self) -> impl Iterator<Item = &(usize, TrackNBase<T>)> {
-        self.inner.iter()
+    pub fn iter(
+        &self,
+    ) -> (
+        impl Iterator<Item = (u16, &(usize, TrackBase<T>))>,
+        &[(usize, TrackNBase<T>)],
+    ) {
+        (
+            self.outputs.iter().copied().zip(self.tracks.iter()),
+            &self.n,
+        )
     }
 }
+
 pub struct TrackMeta(&'static str, TypeId);
 
 impl TrackMeta {
@@ -213,8 +231,6 @@ impl Clip {
     where
         T: Track + Send + Sync + 'static,
         <T as Track>::Output: Lerp + Clone + Send + Sync + 'static,
-        // Means this track have a single lane
-        <T as Track>::Output: ValueN<Value = <T as Track>::Output, Lanes = [u16; 1]>,
     {
         // Split in entity and attribute path,
         // NOTE: use rfind because it's expected the latter to be generally shorter
@@ -236,69 +252,66 @@ impl Clip {
                 .downcast_mut::<<T as Track>::Output>()
                 .expect("properties can't have the same name and different curve types");
 
-            let search = tracks.iter().enumerate().find_map(|(i, (_, t))| {
-                t.lanes()
-                    .into_iter()
-                    .position(|index| *index == entity_index)
-                    .map(|o| (i, o))
-            });
+            let search = tracks
+                .outputs
+                .iter()
+                .position(|index| *index == entity_index);
 
             // If some entity was created it means this property is a new one so we can safely skip the attribute testing
-            if let Some((track_index, _lane_index)) = search {
-                let (k_index, track_a) = &mut tracks.inner[track_index];
-                if track_a.size() == 1 {
-                    let k_index = *k_index;
-                    let mut track_b: TrackNBase<<T as Track>::Output> = Box::new(TrackNData {
-                        lanes: [entity_index],
-                        len: 1,
-                        track,
-                    });
+            if let Some(track_index) = search {
+                let (kf_index, source) = &mut tracks.tracks[track_index];
+                let k_index = *kf_index;
 
-                    // Found a property equal to the one been inserted, next replace the curve
-                    std::mem::swap(track_a, &mut track_b);
+                let mut track: TrackBase<<T as Track>::Output> = Box::new(track);
 
-                    // Update curve duration in two stages
-                    let duration = tracks.calculate_duration();
+                // Found a property equal to the one been inserted, next replace the curve
+                std::mem::swap(source, &mut track);
 
-                    // Drop the down casted ref and update the parent curve
-                    std::mem::drop(tracks);
-                    tracks_untyped.duration = duration;
+                // Update curve duration in two stages
+                let duration = tracks.calculate_duration();
 
-                    // Drop the curves untyped (which as a mut borrow) and update the total duration
-                    std::mem::drop(tracks_untyped);
-                    self.duration = self.calculate_duration();
-
-                    return k_index;
-                } else {
-                    panic!("replacing a single lane in multi lane track isn't supported")
-                }
-            } else {
-                *cache_index += 1;
-                if (*cache_index % KEYFRAMES_PER_CACHE) == 0 {
-                    // No more spaces left in the current cache line
-                    *cache_index = self.keyframes_cache_buckets * KEYFRAMES_PER_CACHE;
-                    self.keyframes_cache_buckets += 1;
-                }
+                // Drop the down casted ref and update the parent curve
+                std::mem::drop(tracks);
+                tracks_untyped.duration = duration;
 
-                self.len += 1;
+                // Drop the curves untyped (which as a mut borrow) and update the total duration
+                std::mem::drop(tracks_untyped);
+                self.duration = self.calculate_duration();
 
-                // Append newly added curve
-                let duration = track.duration();
-                let track_n = Box::new(TrackNData {
-                    lanes: [entity_index],
-                    len: 1,
-                    track,
-                });
+                return k_index;
+            }
 
-                tracks.inner.push((*cache_index, track_n));
-                std::mem::drop(tracks);
+            let search_n = tracks.n.iter().enumerate().find_map(|(i, (_, t))| {
+                t.lanes()
+                    .into_iter()
+                    .position(|index| *index == entity_index)
+                    .map(|o| (i, o))
+            });
 
-                self.len += 1;
-                self.duration = self.duration.max(duration);
-                tracks_untyped.duration = tracks_untyped.duration.max(duration);
+            if let Some((_track_index, _lane_index)) = search_n {
+                panic!("replacing a single lane in multi lane track isn't supported");
+            }
 
-                return *cache_index;
+            *cache_index += 1;
+            if (*cache_index % KEYFRAMES_PER_CACHE) == 0 {
+                // No more spaces left in the current cache line
+                *cache_index = self.keyframes_cache_buckets * KEYFRAMES_PER_CACHE;
+                self.keyframes_cache_buckets += 1;
             }
+
+            self.len += 1;
+
+            // Append newly added curve
+            let duration = track.duration();
+            tracks.outputs.push(entity_index);
+            tracks.tracks.push((*cache_index, Box::new(track)));
+            std::mem::drop(tracks);
+
+            self.len += 1;
+            self.duration = self.duration.max(duration);
+            tracks_untyped.duration = tracks_untyped.duration.max(duration);
+
+            return *cache_index;
         }
 
         let cache_index = self.keyframes_cache_buckets * KEYFRAMES_PER_CACHE;
@@ -311,14 +324,9 @@ impl Clip {
             (
                 cache_index,
                 TracksUntyped::new(Tracks {
-                    inner: vec![(
-                        cache_index,
-                        Box::new(TrackNData {
-                            lanes: [entity_index],
-                            len: 1,
-                            track,
-                        }),
-                    )],
+                    outputs: smallvec![entity_index],
+                    tracks: vec![(cache_index, Box::new(track))],
+                    n: vec![],
                 }),
             ),
         );
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index e3732d016f80d..fdd20e1adbcb7 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -113,21 +113,41 @@ unsafe fn animate<T>(
 {
     assert_eq!(TypeId::of::<T>(), prop.type_id);
 
-    if let Some(curves) = clip
+    if let Some(tracks) = clip
         .get(&prop.path)
         .map(|curve_untyped| curve_untyped.downcast_ref::<T>())
         .flatten()
     {
-        for (curve_index, curve) in curves.iter() {
-            let cursor = &mut keyframes[*curve_index];
-            *cursor = curve.sample(*cursor, time, &mut |output_lane, v| {
+        let (tracks, tracks_n) = tracks.iter();
+
+        for (entity_index, (curve_index, track)) in tracks {
+            let entity_index = entities_map[entity_index as usize] as usize;
+            if let Some(component) = (get_mut)(entity_index) {
+                let kr = &mut keyframes[*curve_index];
+                let (k, v) = track.sample_with_cursor(*kr, time);
+                *kr = k;
+
+                // Unsafe portion
+                let value = &mut *(component.offset(prop.offset) as *mut T);
+                value.blend(entity_index, prop.mask, blend_group, v, w);
+            }
+        }
+
+        // Handle N lane tracks
+        if tracks_n.len() > 0 {
+            let assign = &mut |output_lane: u16, v: T| {
                 let entity_index = entities_map[output_lane as usize] as usize;
                 if let Some(component) = (get_mut)(entity_index) {
                     // Unsafe portion
                     let value = &mut *(component.offset(prop.offset) as *mut T);
                     value.blend(entity_index, prop.mask, blend_group, v, w);
                 }
-            });
+            };
+
+            for (curve_index, track_n) in tracks_n {
+                let cursor = &mut keyframes[*curve_index];
+                *cursor = track_n.sample(*cursor, time, assign);
+            }
         }
     }
 }
@@ -447,20 +467,40 @@ pub(crate) fn animate_asset_system<T: Asset>(
 
                 // ? NOTE: Maybe a bit incontinent to have this `animate` function inlined here,
                 // ? but it will make the code more safe and also faster
-                if let Some(curves) = clip
+                if let Some(tracks) = clip
                     .get(prop_name)
                     .map(|curve_untyped| curve_untyped.downcast_ref::<Handle<T>>())
                     .flatten()
                 {
-                    for (curve_index, curve) in curves.iter() {
-                        let cursor = &mut keyframes[*curve_index];
-                        *cursor = curve.sample(*cursor, time, &mut |output_lane, v| {
+                    let (tracks, tracks_n) = tracks.iter();
+
+                    for (entity_index, (curve_index, curve)) in tracks {
+                        let entity_index = entities_map[entity_index as usize] as usize;
+                        if let Some(ref mut component) = cached_components[entity_index] {
+                            let kr = &mut keyframes[*curve_index];
+                            let (k, v) = curve.sample_with_cursor(*kr, time);
+                            *kr = k;
+
+                            let value = &mut **component;
+                            value.blend(entity_index, prop_mask, &mut blend_group, v, w);
+                        }
+                    }
+
+                    // Handle N lane tracks
+                    // ? NOTE: Currently Handle<T> isn't supported but still be implemented where
+                    if tracks_n.len() > 0 {
+                        let assign = &mut |output_lane: u16, v: Handle<T>| {
                             let entity_index = entities_map[output_lane as usize] as usize;
                             if let Some(ref mut component) = cached_components[entity_index] {
                                 let value = &mut **component;
                                 value.blend(entity_index, prop_mask, &mut blend_group, v, w);
                             }
-                        });
+                        };
+
+                        for (curve_index, curve) in tracks_n {
+                            let cursor = &mut keyframes[*curve_index];
+                            *cursor = curve.sample(*cursor, time, assign);
+                        }
                     }
                 }
             }
diff --git a/crates/bevy_animation/src/tracks/n.rs b/crates/bevy_animation/src/tracks/n.rs
index 98455462436f4..2cfdb2dbedf7d 100644
--- a/crates/bevy_animation/src/tracks/n.rs
+++ b/crates/bevy_animation/src/tracks/n.rs
@@ -1,7 +1,8 @@
 use std::mem::transmute;
 
 use bevy_math::prelude::*;
-use bevy_render::prelude::Color;
+// TODO: `bevy_render::prelude::Color` can be implemented the same way as Quatx4
+// use bevy_render::prelude::Color;
 
 use crate::{
     interpolate::Lerp,
@@ -73,6 +74,9 @@ pub trait TrackN {
 
     fn lanes(&self) -> &[u16];
 
+    /// Number of used outputs, may be N or less
+    fn len(&self) -> usize;
+
     /// N
     fn size(&self) -> usize;
 }
@@ -91,7 +95,7 @@ impl<V: ValueN, T: Track<Output = V>> TrackN for TrackNData<V, T> {
     fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Output)) -> u16 {
         let (cursor, x) = self.track.sample_with_cursor(cursor, time);
         let x = x.unpack();
-        for i in 0..(self.len as usize).min(self.size()) {
+        for i in 0..self.len() {
             (assign)(*self.lanes.get(i), *x.get(i));
         }
         cursor
@@ -101,8 +105,12 @@ impl<V: ValueN, T: Track<Output = V>> TrackN for TrackNData<V, T> {
         self.track.duration()
     }
 
+    fn len(&self) -> usize {
+        (self.len as usize).min(V::size())
+    }
+
     fn lanes(&self) -> &[u16] {
-        self.lanes.as_slice()
+        &self.lanes.as_slice()[0..self.len()]
     }
 
     fn size(&self) -> usize {
@@ -119,79 +127,9 @@ impl<V: ValueN + Lerp + Clone> TrackNData<V, TrackFixed<V>> {
 
 pub type TrackNBase<T> = Box<dyn TrackN<Output = T> + Send + Sync + 'static>;
 
-// impl<T> Sampler for SamplerBase<T> {
-//     type Out = T;
-
-//     #[inline(always)]
-//     fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Output)) -> u16 {
-//         self.0.sample(cursor, time, assign)
-//     }
-// }
-
-// pub struct SamplerUntyped(Box<dyn Any + Send + Sync + 'static>);
-
-// impl SamplerUntyped {
-//     pub fn new<S>(sampler: S) -> Self
-//     where
-//         S: Sampler + Send + Sync + 'static,
-//     {
-//         SamplerUntyped(Box::new(SamplerBase(Box::new(sampler))))
-//     }
-
-//     #[inline(always)]
-//     pub fn downcast_ref<T: 'static>(&self) -> Option<&SamplerBase<T>> {
-//         self.0.downcast_ref()
-//     }
-
-//     #[inline(always)]
-//     pub fn downcast_mut<T: 'static>(&mut self) -> Option<&mut SamplerBase<T>> {
-//         self.0.downcast_mut()
-//     }
-// }
-
 ///////////////////////////////////////////////////////////////////////////////
 
-macro_rules! output1x1 {
-    ($t:ty) => {
-        impl ValueN for $t {
-            type Value = $t;
-
-            type Lanes = [u16; 1];
-
-            type Outputs = [Self::Value; 1];
-
-            fn unpack(self) -> Self::Outputs {
-                [self]
-            }
-
-            fn size() -> usize {
-                1
-            }
-        }
-    };
-}
-
-output1x1!(bool);
-output1x1!(u8);
-output1x1!(u16);
-output1x1!(u32);
-output1x1!(u64);
-output1x1!(usize);
-output1x1!(i8);
-output1x1!(i16);
-output1x1!(i32);
-output1x1!(i64);
-output1x1!(isize);
-output1x1!(f32);
-output1x1!(f64);
-
-output1x1!(Vec2);
-output1x1!(Vec3);
-output1x1!(Vec4);
-output1x1!(Color);
-output1x1!(Quat);
-
-macro_rules! output1xn {
+macro_rules! valuen {
     ($t:ty, $i:ty, $o:ty, $s:tt) => {
         impl ValueN for $t {
             type Value = $o;
@@ -212,12 +150,12 @@ macro_rules! output1xn {
     };
 }
 
-output1xn!(f32x4, f32, f32, 4);
-output1xn!(f32x8, f32, f32, 8);
-output1xn!(Vec3x4, ultraviolet::Vec3, Vec3, 4);
-output1xn!(Vec3x8, ultraviolet::Vec3, Vec3, 8);
-output1xn!(Vec4x4, ultraviolet::Vec4, Vec4, 4);
-output1xn!(Vec4x8, ultraviolet::Vec4, Vec4, 8);
+valuen!(f32x4, f32, f32, 4);
+valuen!(f32x8, f32, f32, 8);
+valuen!(Vec3x4, ultraviolet::Vec3, Vec3, 4);
+valuen!(Vec3x8, ultraviolet::Vec3, Vec3, 8);
+valuen!(Vec4x4, ultraviolet::Vec4, Vec4, 4);
+valuen!(Vec4x8, ultraviolet::Vec4, Vec4, 8);
 
 impl ValueN for Quatx4 {
     type Value = Quat;

From 9f392e024923c4469d706e169b5b89db0e832303 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sat, 30 Jan 2021 13:47:17 -0300
Subject: [PATCH 097/153] primitive clip packing

---
 crates/bevy_animation/src/animator.rs         | 101 ++++++++++++++++--
 .../bevy_animation/src/interpolate/utils.rs   |   2 +
 crates/bevy_animation/src/tracks/fixed.rs     |  14 ++-
 crates/bevy_animation/src/tracks/n.rs         |  57 ++++++++--
 crates/bevy_gltf/src/loader.rs                |   2 +
 5 files changed, 157 insertions(+), 19 deletions(-)

diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index c57bc2aa5134f..23d756cb1696d 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -2,6 +2,9 @@ use std::{
     any::{type_name, Any, TypeId},
     borrow::Cow,
     collections::{HashMap, HashSet},
+    convert::TryFrom,
+    convert::TryInto,
+    fmt,
 };
 
 use anyhow::Result;
@@ -9,6 +12,7 @@ use bevy_app::prelude::{EventReader, Events};
 use bevy_asset::{AssetEvent, Assets, Handle};
 use bevy_core::prelude::*;
 use bevy_ecs::prelude::*;
+use bevy_math::prelude::*;
 use bevy_reflect::{Reflect, ReflectComponent, TypeUuid};
 use bevy_transform::prelude::*;
 use fnv::FnvBuildHasher;
@@ -19,7 +23,9 @@ use crate::{
     blending::AnimatorBlending,
     hierarchy::Hierarchy,
     interpolate::Lerp,
-    tracks::{Track, TrackBase, TrackNBase},
+    tracks::ArrayN,
+    tracks::{Track, TrackBase, TrackFixed, TrackFixedN, TrackNBase, ValueN},
+    wide::{Quatx8, Vec3x8},
 };
 
 // TODO: Load Clip name from gltf
@@ -55,8 +61,8 @@ pub struct Tracks<T> {
     n: Vec<(usize, TrackNBase<T>)>,
 }
 
-impl<T> std::fmt::Debug for Tracks<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl<T> fmt::Debug for Tracks<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("Tracks").field(&self.len()).finish()
     }
 }
@@ -108,8 +114,8 @@ impl TrackMeta {
     }
 }
 
-impl std::fmt::Debug for TrackMeta {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl fmt::Debug for TrackMeta {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("TrackMeta").field(&self.0).finish()
     }
 }
@@ -334,6 +340,87 @@ impl Clip {
         cache_index
     }
 
+    #[inline(always)]
+    fn pack_by_type<V>(sampling_rate: f32, tracks: &mut Tracks<V::Value>) -> usize
+    where
+        V: ValueN + Lerp + Clone + Send + Sync + 'static,
+        <V as ValueN>::Value: Default + Send + Sync + 'static,
+        <V as ValueN>::Outputs: Default + Copy + Send + Sync + 'static,
+        <V as ValueN>::Lanes: for<'a> TryFrom<&'a [u16]> + Send + Sync + 'static,
+    {
+        let mut total = 0;
+        let mut left = tracks.tracks.len();
+
+        while left >= V::size() {
+            let lanes: V::Lanes = if let Ok(lanes) = tracks.outputs[0..V::size()].try_into() {
+                lanes
+            } else {
+                panic!("not enough output lanes");
+            };
+
+            let group = &tracks.tracks[0..8];
+            let d = group
+                .iter()
+                .fold(0.0f32, |acc, (_, t)| acc.max(t.duration()));
+
+            let f = (d * sampling_rate).trunc();
+            // Actual frame rate, is approximated the desired sampling rate,
+            // but isn't always equal to avoid loop seams
+            let frame_rate = d / f;
+            let frame_count = f as usize;
+
+            let mut v = V::Outputs::default();
+            let mut keyframes: Vec<V> = Vec::with_capacity(frame_count);
+            for frame_index in 0..frame_count {
+                let time = (frame_index as f32) * frame_rate;
+
+                for (i, (_, t)) in group.iter().enumerate() {
+                    *v.get_mut(i) = t.sample(time);
+                }
+
+                keyframes.push(V::pack(v));
+            }
+
+            let track_packed = TrackFixedN {
+                lanes,
+                len: V::size() as u16,
+                track: TrackFixed::from_keyframes(1.0 / frame_rate, 0, keyframes),
+            };
+
+            tracks.n.push((group[0].0, Box::new(track_packed)));
+
+            tracks.outputs.drain(0..V::size());
+            tracks.tracks.drain(0..V::size());
+            left -= V::size();
+
+            total += 1;
+        }
+
+        total
+    }
+
+    /// Packs single lane tracks into multi lane tracks, increases the performance trading memory
+    /// so the sampling mechanism can issue as many SIMD instruction as possible;
+    ///
+    /// **NOTE** Only a handful of types can be packed, like `Vec3` and `Quat`, more should
+    /// be added in the future;
+    ///
+    /// **NOTE** This is a very expensive function, it works by re-sampling each
+    /// curve at approximately the desired `sampling_rate`, it will preserve the clip total duration
+    /// but can't handle start offsets, so make sure all the tracks starts at time 0.0;
+    pub fn pack(&mut self, sampling_rate: f32) {
+        // println!("packing clip '{}'", self.name);
+
+        for (_, (_, tracks_untyped)) in self.properties.iter_mut() {
+            // TODO: Support more types
+            if let Some(tracks) = tracks_untyped.downcast_mut::<Vec3>() {
+                Self::pack_by_type::<Vec3x8>(sampling_rate, tracks);
+            } else if let Some(tracks) = tracks_untyped.downcast_mut::<Quat>() {
+                Self::pack_by_type::<Quatx8>(sampling_rate, tracks);
+            }
+        }
+    }
+
     /// Number of animated properties in this clip
     #[inline(always)]
     pub fn len(&self) -> usize {
@@ -425,8 +512,8 @@ impl Default for Layer {
     }
 }
 
-impl std::fmt::Debug for Layer {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl fmt::Debug for Layer {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Layer")
             .field("weight", &self.weight)
             .field("clip", &self.clip)
diff --git a/crates/bevy_animation/src/interpolate/utils.rs b/crates/bevy_animation/src/interpolate/utils.rs
index 737beabeaab10..09ca80f1040c6 100644
--- a/crates/bevy_animation/src/interpolate/utils.rs
+++ b/crates/bevy_animation/src/interpolate/utils.rs
@@ -2,6 +2,8 @@ use std::ops::{Add, Div, Mul, Sub};
 use ultraviolet::{f32x4, f32x8, Vec4x4, Vec4x8};
 use wide::{i32x4, i32x8};
 
+// TODO: Add Quat support to ultraviolet?
+
 /// Wide quaternion
 #[derive(Debug, Clone)]
 pub struct Quatx4(pub Vec4x4);
diff --git a/crates/bevy_animation/src/tracks/fixed.rs b/crates/bevy_animation/src/tracks/fixed.rs
index 5a2b70f22a3e1..bb93a9acd3dba 100644
--- a/crates/bevy_animation/src/tracks/fixed.rs
+++ b/crates/bevy_animation/src/tracks/fixed.rs
@@ -23,9 +23,9 @@ impl<T: Clone> Clone for TrackFixed<T> {
 }
 
 impl<T> TrackFixed<T> {
-    pub fn from_keyframes(frame_rate: usize, offset: isize, keyframes: Vec<T>) -> Self {
+    pub fn from_keyframes(frame_rate: f32, offset: isize, keyframes: Vec<T>) -> Self {
         let curve = Self {
-            frame_rate: frame_rate as f32,
+            frame_rate,
             negative_offset: -(offset as f32),
             keyframes,
         };
@@ -41,6 +41,10 @@ impl<T> TrackFixed<T> {
         }
     }
 
+    pub fn keyframes_mut(&mut self) -> &mut [T] {
+        &mut self.keyframes[..]
+    }
+
     // pub fn insert(&mut self, time_sample: f32, value: T) {
     // }
 
@@ -48,10 +52,14 @@ impl<T> TrackFixed<T> {
     //assert!(samples.len() > 1, "curve can't be empty");
     // }
 
-    pub const fn frame_rate(&self) -> usize {
+    pub const fn len(&self) -> usize {
         self.frame_rate as usize
     }
 
+    pub fn frame_rate(&self) -> usize {
+        self.keyframes.len()
+    }
+
     pub fn offset(&self) -> isize {
         (-self.negative_offset) as isize
     }
diff --git a/crates/bevy_animation/src/tracks/n.rs b/crates/bevy_animation/src/tracks/n.rs
index 2cfdb2dbedf7d..c5d42a451e9ac 100644
--- a/crates/bevy_animation/src/tracks/n.rs
+++ b/crates/bevy_animation/src/tracks/n.rs
@@ -58,6 +58,8 @@ pub trait ValueN {
     /// [Self::Value; N]
     type Outputs: ArrayN<Item = Self::Value>;
 
+    fn pack(values: Self::Outputs) -> Self;
+
     fn unpack(self) -> Self::Outputs;
 
     /// N
@@ -81,15 +83,15 @@ pub trait TrackN {
     fn size(&self) -> usize;
 }
 
-pub struct TrackNData<V: ValueN, T: Track<Output = V>> {
+pub struct TrackFixedN<V: ValueN> {
     pub lanes: V::Lanes,
     /// Only applicable when `outputs.len() > 0`, defines how many of the output lanes are actually assigned;
     /// In the case of `len == 0` this track doesn't output anything and should be deleted to preserve performance
     pub len: u16,
-    pub track: T,
+    pub track: TrackFixed<V>,
 }
 
-impl<V: ValueN, T: Track<Output = V>> TrackN for TrackNData<V, T> {
+impl<V: ValueN + Lerp + Clone> TrackN for TrackFixedN<V> {
     type Output = V::Value;
 
     fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Output)) -> u16 {
@@ -118,12 +120,34 @@ impl<V: ValueN, T: Track<Output = V>> TrackN for TrackNData<V, T> {
     }
 }
 
-impl<V: ValueN + Lerp + Clone> TrackNData<V, TrackFixed<V>> {
-    // TODO: Function to edit each lane
-    // pub fn add_track
-    // pub fn add_track_resampled (will accept any kind of track)
-    // pub fn remove_track
-}
+// impl<V: ValueN + Lerp + Clone> TrackFixedN<V> {
+//     // TODO: Function to edit each lane
+//     // pub fn add_track
+
+//     pub fn add_track_resampled(&mut self, track: &dyn Track<Output = <V as ValueN>::Value>) {
+//         let i = self.len as usize;
+//         if i >= V::size() {
+//             panic!("track is full");
+//         }
+
+//         self.len += 1;
+
+//         let mut cursor = 0;
+//         let f = 1.0 / (self.track.frame_rate() as f32);
+//         let offset = self.track.offset() as f32 * f;
+//         let s = self.track.len();
+//         let keyframes = self.track.keyframes_mut();
+
+//         for frame in 0..s {
+//             let time = offset + f * frame as f32;
+//             let (k, v) = track.sample_with_cursor(cursor, time);
+//             keyframes[frame].set(v, i);
+//             cursor = k;
+//         }
+//     }
+
+//     // pub fn remove_track
+// }
 
 pub type TrackNBase<T> = Box<dyn TrackN<Output = T> + Send + Sync + 'static>;
 
@@ -138,6 +162,11 @@ macro_rules! valuen {
 
             type Outputs = [Self::Value; $s];
 
+            #[inline(always)]
+            fn pack(values: Self::Outputs) -> Self {
+                unsafe { transmute::<_, [$i; $s]>(values).into() }
+            }
+
             #[inline(always)]
             fn unpack(self) -> Self::Outputs {
                 unsafe { transmute::<[$i; $s], _>(self.into()) }
@@ -164,6 +193,11 @@ impl ValueN for Quatx4 {
 
     type Outputs = [Self::Value; 4];
 
+    #[inline(always)]
+    fn pack(values: Self::Outputs) -> Self {
+        Quatx4(unsafe { transmute::<_, [ultraviolet::Vec4; 4]>(values).into() })
+    }
+
     #[inline(always)]
     fn unpack(self) -> Self::Outputs {
         unsafe { transmute::<[ultraviolet::Vec4; 4], _>(self.0.into()) }
@@ -181,6 +215,11 @@ impl ValueN for Quatx8 {
 
     type Outputs = [Self::Value; 8];
 
+    #[inline(always)]
+    fn pack(values: Self::Outputs) -> Self {
+        Quatx8(unsafe { transmute::<_, [ultraviolet::Vec4; 8]>(values).into() })
+    }
+
     #[inline(always)]
     fn unpack(self) -> Self::Outputs {
         unsafe { transmute::<[ultraviolet::Vec4; 8], _>(self.0.into()) }
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 83714eec0e726..3655a456db8b0 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -341,6 +341,8 @@ async fn load_gltf<'a, 'b>(
             clip.add_track_at_path(&property_path, curve);
         }
 
+        clip.pack(30.0);
+
         load_context.set_labeled_asset(&anim_label, LoadedAsset::new(clip));
 
         let path = AssetPath::new_ref(load_context.path(), Some(&anim_label));

From 20bcf2ff19f301f8fb6c51805e2b7d023cd27f92 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sat, 30 Jan 2021 19:33:02 -0300
Subject: [PATCH 098/153] additive blending

---
 crates/bevy_animation/src/animator.rs         |   3 +
 crates/bevy_animation/src/blending.rs         | 184 +++++++++++++-----
 crates/bevy_animation/src/interpolate/lerp.rs |  16 +-
 .../bevy_animation/src/interpolate/utils.rs   |  10 +
 crates/bevy_animation/src/reflect.rs          |  59 +++++-
 5 files changed, 215 insertions(+), 57 deletions(-)

diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index 23d756cb1696d..6826bf7547226 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -495,6 +495,7 @@ pub struct Layer {
     pub clip: usize,
     pub time: f32,
     pub time_scale: f32,
+    pub additive: bool,
     #[reflect(ignore)]
     keyframes_buckets: Vec<KeyframeBucket>,
     // TODO: LayerMask
@@ -507,6 +508,7 @@ impl Default for Layer {
             clip: 0,
             time: 0.0,
             time_scale: 1.0,
+            additive: false,
             keyframes_buckets: vec![],
         }
     }
@@ -519,6 +521,7 @@ impl fmt::Debug for Layer {
             .field("clip", &self.clip)
             .field("time", &self.time)
             .field("time_scale", &self.time_scale)
+            .field("additive", &self.additive)
             .finish()
     }
 }
diff --git a/crates/bevy_animation/src/blending.rs b/crates/bevy_animation/src/blending.rs
index 6d86dcf2004d0..30a47f43416ca 100644
--- a/crates/bevy_animation/src/blending.rs
+++ b/crates/bevy_animation/src/blending.rs
@@ -1,24 +1,13 @@
+use std::mem::size_of;
+
 use bevy_asset::{Asset, Handle, HandleUntyped};
 use bevy_math::prelude::*;
 use bevy_render::color::Color;
-use fnv::FnvBuildHasher;
-use std::{collections::HashMap, mem::size_of};
-
-use crate::interpolate::Lerp;
-
-// TODO: Remove pointers and use indexes to handle context blending
-// this way begin_blending will take the entity_count and context size
-// with a bit extra work I can define if a type needs or not a slot for context blending
-
-// TODO: Additive blending
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-struct Ptr(*const u8);
-
-// SAFETY: The underlying pointer will never will be dereferenced,
-// it's only use as an numerical value globally unique any attribute
-unsafe impl Send for Ptr {}
-unsafe impl Sync for Ptr {}
+use crate::interpolate::{
+    utils::{Scale2, Scale3},
+    Lerp,
+};
 
 /// Mask size used to blend properties, each bit corresponds to a single property
 pub type Mask = u32;
@@ -29,18 +18,20 @@ pub const MASK_LIMIT: usize = size_of::<Mask>() * 8;
 #[derive(Default, Debug)]
 pub struct AnimatorBlending {
     bits: Vec<Mask>,
-    // ? NOTE: HashMap is used here to reduce memory waste, it's slower but other wise a lot of memory won't be used
-    // TODO: Change to the hashbrown::raw::RawTable to use the pointers values as hashes it self
-    /// Used for contest blend type
-    weights: HashMap<Ptr, f32, FnvBuildHasher>,
+    weight_slots: usize,
+    weights: Vec<f32>,
 }
 
 impl AnimatorBlending {
     #[inline(always)]
-    pub fn begin_blending(&mut self, entities: usize) -> AnimatorBlendGroup {
+    pub fn begin_blending(&mut self, entities: usize, weight_slots: usize) -> AnimatorBlendGroup {
         self.bits.clear();
         self.bits.resize(entities, 0);
+
+        self.weight_slots = weight_slots;
         self.weights.clear();
+        self.weights.resize(entities * weight_slots, f32::MIN);
+
         AnimatorBlendGroup { blending: self }
     }
 }
@@ -50,19 +41,19 @@ pub struct AnimatorBlendGroup<'a> {
 }
 
 impl<'a> AnimatorBlendGroup<'a> {
-    /// Blend using lerping
     #[inline(always)]
-    pub fn blend_lerp<T: Lerp>(
+    pub fn blend<T>(
         &mut self,
         entity_index: usize,
         bit_mask: Mask,
         attribute: &mut T,
         value: T,
         weight: f32,
+        function: impl Fn(&T, &T, f32) -> T,
     ) {
         let b = &mut self.blending.bits[entity_index];
         if *b & bit_mask != 0 {
-            *attribute = Lerp::lerp(&*attribute, &value, weight);
+            *attribute = (function)(&*attribute, &value, weight);
         } else {
             *attribute = value;
         }
@@ -71,9 +62,15 @@ impl<'a> AnimatorBlendGroup<'a> {
 
     /// Contest blending, only the value with the highest weight value will remain
     #[inline(always)]
-    pub fn blend_contest<T>(&mut self, attribute: &mut T, value: T, weight: f32) {
-        let ptr = Ptr(attribute as *const _ as *const u8);
-        let w = self.blending.weights.entry(ptr).or_insert(0.0);
+    pub fn blend_contest<T>(
+        &mut self,
+        entity_index: usize,
+        slot: usize,
+        attribute: &mut T,
+        value: T,
+        weight: f32,
+    ) {
+        let w = &mut self.blending.weights[entity_index * slot];
         if weight > *w {
             *w = weight;
             *attribute = value;
@@ -81,6 +78,58 @@ impl<'a> AnimatorBlendGroup<'a> {
     }
 }
 
+///////////////////////////////////////////////////////////////////////////////
+
+// ? NOTE: Implements the 'Additive 1' mode described here
+// ? https://github.com/nfrechette/acl/blob/develop/docs/additive_clips.md
+
+#[inline(always)]
+fn additive_blend_bool(a: &bool, b: &bool, _: f32) -> bool {
+    *a || *b
+}
+
+#[inline(always)]
+fn additive_blend_f32(a: &f32, b: &f32, _: f32) -> f32 {
+    *a + *b
+}
+
+#[inline(always)]
+fn additive_blend_vec2(a: &Vec2, b: &Vec2, _: f32) -> Vec2 {
+    *a + *b
+}
+
+#[inline(always)]
+fn additive_blend_vec3(a: &Vec3, b: &Vec3, _: f32) -> Vec3 {
+    *a + *b
+}
+
+#[inline(always)]
+fn additive_blend_vec4(a: &Vec4, b: &Vec4, _: f32) -> Vec4 {
+    *a + *b
+}
+
+#[inline(always)]
+fn additive_blend_quat(a: &Quat, b: &Quat, _: f32) -> Quat {
+    *b * *a
+}
+
+#[inline(always)]
+fn additive_blend_scale2(a: &Scale2, b: &Scale2, _: f32) -> Scale2 {
+    Scale2((Vec2::one() + b.0) * a.0)
+}
+
+#[inline(always)]
+fn additive_blend_scale3(a: &Scale3, b: &Scale3, _: f32) -> Scale3 {
+    Scale3((Vec3::one() + b.0) * a.0)
+}
+
+#[inline(always)]
+fn additive_blend_color(a: &Color, b: &Color, _: f32) -> Color {
+    (Vec4::from(*a) + Vec4::from(*b)).into()
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 /// Instructs on how blend multiple layers togethers based on their value,
 /// normally there is two types of blend, lerp and contest blending, the first
 /// is used by floats, vectors and quaternions, while the second keeps only the value
@@ -99,102 +148,139 @@ impl<'a> AnimatorBlendGroup<'a> {
 ///         blend_group: &mut AnimatorBlendGroup,
 ///         value: Self,
 ///         weight: f32,
+///         additive: bool,
 ///     ){
 ///         blend_group.blend_contest(self, value, weight);
 ///         // or (MyType needs to implement `Lerp`)
-///         // blend_group.blend_lerp(entity_index, bit_mask, self, value, weight);
+///         // blend_group.blend(entity_index, bit_mask, self, value, weight, blend_function);
 ///     }
 /// }
 /// ```
-pub trait Blend {
+pub trait Blend: Sized {
+    fn requires_weight_slot() -> bool;
+
     fn blend(
         &mut self,
         entity_index: usize,
         bit_mask: Mask,
+        slot: usize,
         blend_group: &mut AnimatorBlendGroup,
         value: Self,
         weight: f32,
+        additive: bool,
     );
 }
 
-macro_rules! lerp {
-    ($t:ty) => {
+macro_rules! impl_blend {
+    ($t:ty, $normal:path, $add:path) => {
         impl Blend for $t {
+            fn requires_weight_slot() -> bool {
+                false
+            }
+
             #[inline(always)]
             fn blend(
                 &mut self,
                 entity_index: usize,
                 bit_mask: Mask,
+                _: usize,
                 blend_group: &mut AnimatorBlendGroup,
                 value: Self,
                 weight: f32,
+                additive: bool,
             ) {
-                blend_group.blend_lerp(entity_index, bit_mask, self, value, weight);
+                if additive {
+                    blend_group.blend(entity_index, bit_mask, self, value, weight, $add);
+                } else {
+                    blend_group.blend(entity_index, bit_mask, self, value, weight, $normal);
+                }
             }
         }
     };
 }
 
-lerp!(bool);
-lerp!(f32);
-lerp!(Vec2);
-lerp!(Vec3);
-lerp!(Vec4);
-lerp!(Quat);
-lerp!(Color);
+impl_blend!(bool, Lerp::lerp, additive_blend_bool);
+impl_blend!(f32, Lerp::lerp, additive_blend_f32);
+impl_blend!(Vec2, Lerp::lerp, additive_blend_vec2);
+impl_blend!(Vec3, Lerp::lerp, additive_blend_vec3);
+impl_blend!(Vec4, Lerp::lerp, additive_blend_vec4);
+impl_blend!(Quat, Lerp::lerp, additive_blend_quat);
+impl_blend!(Scale2, Lerp::lerp, additive_blend_scale2);
+impl_blend!(Scale3, Lerp::lerp, additive_blend_scale3);
+impl_blend!(Color, Lerp::lerp, additive_blend_color);
+
+///////////////////////////////////////////////////////////////////////////////
 
 impl<T: Asset + 'static> Blend for Handle<T> {
+    fn requires_weight_slot() -> bool {
+        true
+    }
+
     #[inline(always)]
     fn blend(
         &mut self,
-        _: usize,
+        entity_index: usize,
         _: Mask,
+        slot: usize,
         blend_group: &mut AnimatorBlendGroup,
         value: Self,
         weight: f32,
+        _: bool,
     ) {
-        blend_group.blend_contest(self, value, weight);
+        blend_group.blend_contest(entity_index, slot, self, value, weight);
     }
 }
 
 impl Blend for HandleUntyped {
+    fn requires_weight_slot() -> bool {
+        true
+    }
+
     #[inline(always)]
     fn blend(
         &mut self,
-        _: usize,
+        entity_index: usize,
         _: Mask,
+        slot: usize,
         blend_group: &mut AnimatorBlendGroup,
         value: Self,
         weight: f32,
+        _: bool,
     ) {
-        blend_group.blend_contest(self, value, weight);
+        blend_group.blend_contest(entity_index, slot, self, value, weight);
     }
 }
 
 impl<T: Blend> Blend for Option<T> {
+    fn requires_weight_slot() -> bool {
+        true
+    }
+
     fn blend(
         &mut self,
         entity_index: usize,
         bit_mask: Mask,
+        slot: usize,
         blend_group: &mut AnimatorBlendGroup,
         value: Self,
         weight: f32,
+        additive: bool,
     ) {
-        let ptr = Ptr(self as *const _ as *const u8);
-
         match (self.is_some(), value.is_some()) {
             (true, true) => {
                 // Blend by lerp but also add the entry for the conext blending
                 self.as_mut().unwrap().blend(
                     entity_index,
                     bit_mask,
+                    slot,
                     blend_group,
                     value.unwrap(),
                     weight,
+                    additive,
                 );
 
                 // Make sure to also add an entry for contest blent to work
-                let w = blend_group.blending.weights.entry(ptr).or_insert(0.0);
+                let w = &mut blend_group.blending.weights[entity_index * slot];
                 if weight > *w {
                     *w = weight;
                 }
@@ -202,10 +288,8 @@ impl<T: Blend> Blend for Option<T> {
             (false, true) | (true, false) | (false, false) => {
                 // Blend by context but also add an entry for the next blend_lerp if needed
                 blend_group.blending.bits[entity_index] |= bit_mask;
-                blend_group.blend_contest(self, value, weight);
+                blend_group.blend_contest(entity_index, slot, self, value, weight);
             }
         }
     }
 }
-
-// TODO: std::ops::Range
diff --git a/crates/bevy_animation/src/interpolate/lerp.rs b/crates/bevy_animation/src/interpolate/lerp.rs
index 07a5efd659491..c71e333fa5fdb 100644
--- a/crates/bevy_animation/src/interpolate/lerp.rs
+++ b/crates/bevy_animation/src/interpolate/lerp.rs
@@ -5,7 +5,7 @@ use ultraviolet::{f32x4, f32x8, Vec3x4, Vec3x8, Vec4x4, Vec4x8};
 
 use super::utils::*;
 
-// TODO: add Rotors
+// TODO: add Rotors?
 
 /// Defines how a particular type will be interpolated
 pub trait Lerp {
@@ -146,6 +146,20 @@ impl Lerp for Quatx8 {
     }
 }
 
+impl Lerp for Scale2 {
+    #[inline(always)]
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        Scale2(Vec2::lerp(a.0, b.0, t))
+    }
+}
+
+impl Lerp for Scale3 {
+    #[inline(always)]
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        Scale3(Vec3::lerp(a.0, b.0, t))
+    }
+}
+
 impl<T: Asset + 'static> Lerp for Handle<T> {
     #[inline(always)]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
diff --git a/crates/bevy_animation/src/interpolate/utils.rs b/crates/bevy_animation/src/interpolate/utils.rs
index 09ca80f1040c6..63aad015e238a 100644
--- a/crates/bevy_animation/src/interpolate/utils.rs
+++ b/crates/bevy_animation/src/interpolate/utils.rs
@@ -1,4 +1,6 @@
 use std::ops::{Add, Div, Mul, Sub};
+
+use bevy_math::{Vec2, Vec3};
 use ultraviolet::{f32x4, f32x8, Vec4x4, Vec4x8};
 use wide::{i32x4, i32x8};
 
@@ -25,6 +27,14 @@ pub struct Quatx8(pub Vec4x8);
 // wide_quat!(Quat4);
 // wide_quat!(Quat8);
 
+/// Used to change the blending semantics of a `Vec2`
+#[derive(Debug, Clone)]
+pub struct Scale2(pub Vec2);
+
+/// Used to change the blending semantics of a `Vec3`
+#[derive(Debug, Clone)]
+pub struct Scale3(pub Vec3);
+
 /// Quake 3 fast inverse sqrt
 ///
 /// Took this one from piston: https://github.com/PistonDevelopers/skeletal_animation
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index fdd20e1adbcb7..9685293d314f4 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -34,6 +34,7 @@ type AnimateFn = unsafe fn(
     time: f32,
     w: f32,
     prop: &Property,
+    additive: bool,
 );
 
 /// Register how to animate custom types
@@ -108,6 +109,7 @@ unsafe fn animate<T>(
     time: f32,
     w: f32,
     prop: &Property,
+    additive: bool,
 ) where
     T: Lerp + Blend + Clone + 'static,
 {
@@ -129,7 +131,15 @@ unsafe fn animate<T>(
 
                 // Unsafe portion
                 let value = &mut *(component.offset(prop.offset) as *mut T);
-                value.blend(entity_index, prop.mask, blend_group, v, w);
+                value.blend(
+                    entity_index,
+                    prop.mask,
+                    prop.slot,
+                    blend_group,
+                    v,
+                    w,
+                    additive,
+                );
             }
         }
 
@@ -140,7 +150,15 @@ unsafe fn animate<T>(
                 if let Some(component) = (get_mut)(entity_index) {
                     // Unsafe portion
                     let value = &mut *(component.offset(prop.offset) as *mut T);
-                    value.blend(entity_index, prop.mask, blend_group, v, w);
+                    value.blend(
+                        entity_index,
+                        prop.mask,
+                        prop.slot,
+                        blend_group,
+                        v,
+                        w,
+                        additive,
+                    );
                 }
             };
 
@@ -158,12 +176,14 @@ struct Property {
     index: usize,
     offset: isize,
     mask: Mask,
+    slot: usize,
 }
 
 // Defines how to animate an type
 pub(crate) struct AnimatorDescriptor<T> {
     ver: usize,
     short_name: String,
+    weight_slots: usize,
     dynamic_properties: Vec<Property>,
     animator_blending: AnimatorBlending,
     _marker: PhantomData<T>,
@@ -174,6 +194,7 @@ impl<T> Default for AnimatorDescriptor<T> {
         Self {
             ver: 0,
             short_name: String::new(),
+            weight_slots: 0,
             dynamic_properties: vec![],
             animator_blending: AnimatorBlending::default(),
             _marker: PhantomData,
@@ -208,6 +229,7 @@ impl<T: Struct> AnimatorDescriptor<T> {
     }
 
     fn build(instance: &T, base_path: &str) -> Self {
+        let mut weight_slots = 0;
         let mut dynamic_properties = vec![];
 
         // Lazy initialize the descriptor
@@ -220,6 +242,10 @@ impl<T: Struct> AnimatorDescriptor<T> {
                 );
             }
 
+            // TODO: Reduce the number of slots needed
+            let slot = weight_slots;
+            weight_slots += 1;
+
             let field_name = instance.name_at(i).unwrap();
             // NOTE: Pre calculate all the space needed to make in a single allocation (untested)
             let mut path = String::with_capacity(base_path.len() + 1 + field_name.len());
@@ -251,10 +277,12 @@ impl<T: Struct> AnimatorDescriptor<T> {
                 index,
                 offset,
                 mask,
+                slot,
             });
         }
 
         Self {
+            weight_slots,
             dynamic_properties,
             ..Default::default()
         }
@@ -312,7 +340,7 @@ pub(crate) fn animate_component_system<T: Component>(
 
         let mut blend_group = descriptor
             .animator_blending
-            .begin_blending(cached_components.len());
+            .begin_blending(cached_components.len(), descriptor.weight_slots);
 
         let mut get_mut_components = |index: usize| -> Option<*mut u8> {
             // NOTE: Will trigger the `Changed` event to the right types
@@ -357,6 +385,7 @@ pub(crate) fn animate_component_system<T: Component>(
                             time,
                             w,
                             &prop,
+                            layer.additive,
                         )
                     }
                 }
@@ -429,7 +458,7 @@ pub(crate) fn animate_asset_system<T: Asset>(
 
         let mut blend_group = descriptor
             .animator_blending
-            .begin_blending(cached_components.len());
+            .begin_blending(cached_components.len(), descriptor.weight_slots + 1);
 
         // Animate asset handle
 
@@ -464,6 +493,7 @@ pub(crate) fn animate_asset_system<T: Asset>(
                     );
                 }
                 let prop_mask = 1 << descriptor.dynamic_properties.len();
+                let prop_slot = descriptor.weight_slots + 1;
 
                 // ? NOTE: Maybe a bit incontinent to have this `animate` function inlined here,
                 // ? but it will make the code more safe and also faster
@@ -482,7 +512,15 @@ pub(crate) fn animate_asset_system<T: Asset>(
                             *kr = k;
 
                             let value = &mut **component;
-                            value.blend(entity_index, prop_mask, &mut blend_group, v, w);
+                            value.blend(
+                                entity_index,
+                                prop_mask,
+                                prop_slot,
+                                &mut blend_group,
+                                v,
+                                w,
+                                layer.additive,
+                            );
                         }
                     }
 
@@ -493,7 +531,15 @@ pub(crate) fn animate_asset_system<T: Asset>(
                             let entity_index = entities_map[output_lane as usize] as usize;
                             if let Some(ref mut component) = cached_components[entity_index] {
                                 let value = &mut **component;
-                                value.blend(entity_index, prop_mask, &mut blend_group, v, w);
+                                value.blend(
+                                    entity_index,
+                                    prop_mask,
+                                    prop_slot,
+                                    &mut blend_group,
+                                    v,
+                                    w,
+                                    layer.additive,
+                                );
                             }
                         };
 
@@ -565,6 +611,7 @@ pub(crate) fn animate_asset_system<T: Asset>(
                             time,
                             w,
                             &prop,
+                            layer.additive,
                         )
                     }
                 }

From 09d10fc85ec5680c0b7a3c5bc3326667a6d6aebc Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sat, 30 Jan 2021 19:43:29 -0300
Subject: [PATCH 099/153] add weights in aditive blending + pr.md

---
 crates/bevy_animation/prdraft.md      | 24 +++++++++++--------
 crates/bevy_animation/src/blending.rs | 34 ++++++++++++++-------------
 2 files changed, 32 insertions(+), 26 deletions(-)

diff --git a/crates/bevy_animation/prdraft.md b/crates/bevy_animation/prdraft.md
index 9296812419f4d..071c8d2f81c0a 100644
--- a/crates/bevy_animation/prdraft.md
+++ b/crates/bevy_animation/prdraft.md
@@ -97,6 +97,16 @@ c) NLerp only and you wont notice the difference, hopefully ...
 Simple and naive implementation, replaces the vertex shader from the `bevy_pbr::prelude::StandardMaterial`.
 Further work should done along side with the rendering, but hey it works!  
 
+11. Additive Blending
+
+Supports additive blending as defined by the ACL mode Additive 1, that can be found
+[here](https://github.com/nfrechette/acl/blob/develop/docs/additive_clips.md)
+
+12. SIMD support
+
+Clips can now be packed, a packed clip will contain tracks that are sampled using wide types from the `ultraviolet` crate
+thus resulting in a greater sampling throughput.
+
 ## Missing Features
 
 1. Nested properties
@@ -104,24 +114,18 @@ Further work should done along side with the rendering, but hey it works!
 Right now only the top most properties of each struct can be animated,
 this means `"@CustomComponent.point.x"` isn't valid;
 
-2. Additive Blending
-
-3. Masks
+2. Masks
 
-4. Animation events (simple and interval)
+3. Animation events (simple and interval)
 
-5. Morph Targets
+4. Morph Targets
 
-6. Dedicated `Transform` animator system
+5. Dedicated `Transform` animator system
 
 `Transform` is the most common animated component in any game, its the only animated component registered
 by default and it should receive a custom animator system to squeeze every single us that is possible,
 this custom system should be also be capable of performing SIMD blending;
 
-7. SIMD support
-
-The sampler do support wide types from the `ultraviolet` crate, but it's isn't fully integrated yet;
-SIMD blending will be a challenge to implement, and probably wont ever land; 
 
 ## Terminology and Internals
 
diff --git a/crates/bevy_animation/src/blending.rs b/crates/bevy_animation/src/blending.rs
index 30a47f43416ca..140822773384b 100644
--- a/crates/bevy_animation/src/blending.rs
+++ b/crates/bevy_animation/src/blending.rs
@@ -85,47 +85,49 @@ impl<'a> AnimatorBlendGroup<'a> {
 
 #[inline(always)]
 fn additive_blend_bool(a: &bool, b: &bool, _: f32) -> bool {
+    // TODO: Review
     *a || *b
 }
 
 #[inline(always)]
-fn additive_blend_f32(a: &f32, b: &f32, _: f32) -> f32 {
-    *a + *b
+fn additive_blend_f32(a: &f32, b: &f32, w: f32) -> f32 {
+    *a + (*b * w)
 }
 
 #[inline(always)]
-fn additive_blend_vec2(a: &Vec2, b: &Vec2, _: f32) -> Vec2 {
-    *a + *b
+fn additive_blend_vec2(a: &Vec2, b: &Vec2, w: f32) -> Vec2 {
+    *a + (*b * w)
 }
 
 #[inline(always)]
-fn additive_blend_vec3(a: &Vec3, b: &Vec3, _: f32) -> Vec3 {
-    *a + *b
+fn additive_blend_vec3(a: &Vec3, b: &Vec3, w: f32) -> Vec3 {
+    *a + (*b * w)
 }
 
 #[inline(always)]
-fn additive_blend_vec4(a: &Vec4, b: &Vec4, _: f32) -> Vec4 {
-    *a + *b
+fn additive_blend_vec4(a: &Vec4, b: &Vec4, w: f32) -> Vec4 {
+    *a + (*b * w)
 }
 
 #[inline(always)]
-fn additive_blend_quat(a: &Quat, b: &Quat, _: f32) -> Quat {
-    *b * *a
+fn additive_blend_quat(a: &Quat, b: &Quat, w: f32) -> Quat {
+    // TODO: Review
+    (*b * w) * *a
 }
 
 #[inline(always)]
-fn additive_blend_scale2(a: &Scale2, b: &Scale2, _: f32) -> Scale2 {
-    Scale2((Vec2::one() + b.0) * a.0)
+fn additive_blend_scale2(a: &Scale2, b: &Scale2, w: f32) -> Scale2 {
+    Scale2((Vec2::one() + (b.0 * w)) * a.0)
 }
 
 #[inline(always)]
-fn additive_blend_scale3(a: &Scale3, b: &Scale3, _: f32) -> Scale3 {
-    Scale3((Vec3::one() + b.0) * a.0)
+fn additive_blend_scale3(a: &Scale3, b: &Scale3, w: f32) -> Scale3 {
+    Scale3((Vec3::one() + (b.0 * w)) * a.0)
 }
 
 #[inline(always)]
-fn additive_blend_color(a: &Color, b: &Color, _: f32) -> Color {
-    (Vec4::from(*a) + Vec4::from(*b)).into()
+fn additive_blend_color(a: &Color, b: &Color, w: f32) -> Color {
+    (Vec4::from(*a) + (Vec4::from(*b) * w)).into()
 }
 
 ///////////////////////////////////////////////////////////////////////////////

From f2b0448fbb693454eb8bfc6b421e5d91e909cf5f Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sun, 14 Feb 2021 15:43:51 -0300
Subject: [PATCH 100/153] add a skinning system to fix animation lag and give
 space for a procedural animations stage (like IK)

---
 crates/bevy_animation/src/lib.rs | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index af71b176fc9e2..b0f9309b53ad1 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -42,6 +42,7 @@ pub mod wide {
 
 pub mod stage {
     pub const ANIMATE: &'static str = "animate";
+    pub const SKINNING: &'static str = "skinning";
     pub use bevy_app::stage::{POST_UPDATE, UPDATE};
 }
 
@@ -56,6 +57,7 @@ pub struct AnimationPlugin {
 impl Plugin for AnimationPlugin {
     fn build(&self, app: &mut AppBuilder) {
         app.add_stage_after(stage::UPDATE, stage::ANIMATE, SystemStage::parallel());
+        app.add_stage_after(stage::POST_UPDATE, stage::SKINNING, SystemStage::parallel());
 
         // Generic animation
         app.insert_resource(animator::AnimatorRegistry::default())
@@ -89,10 +91,17 @@ impl Plugin for AnimationPlugin {
 
         if !self.headless {
             app.add_startup_system(skinned_mesh::skinning_setup.system())
-                .add_system_to_stage(stage::POST_UPDATE, skinned_mesh::skinning_update.system())
                 .add_system_to_stage(
-                    stage::POST_UPDATE,
-                    skinned_mesh::skinning_debugger_update.system(),
+                    stage::SKINNING,
+                    skinned_mesh::skinning_update
+                        .system()
+                        .label("skinning_update"),
+                )
+                .add_system_to_stage(
+                    stage::SKINNING,
+                    skinned_mesh::skinning_debugger_update
+                        .system()
+                        .after("skinning_update"),
                 );
         }
     }

From 12edbc9843584568da21019d708a2b1cfd7e0919 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sun, 14 Feb 2021 16:02:04 -0300
Subject: [PATCH 101/153] rename haedless param of animator plugin to skinning

---
 crates/bevy_animation/src/animator.rs |  2 +-
 crates/bevy_animation/src/bench.rs    |  2 +-
 crates/bevy_animation/src/lib.rs      | 13 +++++++++----
 3 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index 3c661afabbabf..6494f3024afe9 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -928,7 +928,7 @@ mod tests {
                 .add_asset::<Mesh>()
                 .add_asset::<StandardMaterial>()
                 .add_plugin(bevy_transform::TransformPlugin::default())
-                .add_plugin(crate::AnimationPlugin { headless: true });
+                .add_plugin(crate::AnimationPlugin { skinning: false });
 
             let mut world = World::new();
             let mut world_builder = world.build();
diff --git a/crates/bevy_animation/src/bench.rs b/crates/bevy_animation/src/bench.rs
index 2c356117cc0b7..9e70aeb991d5f 100644
--- a/crates/bevy_animation/src/bench.rs
+++ b/crates/bevy_animation/src/bench.rs
@@ -32,7 +32,7 @@ impl Bench {
             .add_plugin(bevy_asset::AssetPlugin::default())
             .add_plugin(TransformPlugin::default())
             .add_plugin(crate::AnimationPlugin {
-                headless: true,
+                skinning: false,
                 ..Default::default()
             });
 
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index b0f9309b53ad1..ad6a4eaae354f 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -48,10 +48,15 @@ pub mod stage {
 
 use bevy_ecs::ParallelSystemDescriptorCoercion;
 
-#[derive(Default)]
 pub struct AnimationPlugin {
-    /// Headless mode (no skinning)
-    pub headless: bool,
+    /// Enables or disables the built in skinning
+    pub skinning: bool,
+}
+
+impl Default for AnimationPlugin {
+    fn default() -> Self {
+        Self { skinning: true }
+    }
 }
 
 impl Plugin for AnimationPlugin {
@@ -89,7 +94,7 @@ impl Plugin for AnimationPlugin {
             .register_type::<skinned_mesh::SkinComponent>()
             .register_type::<skinned_mesh::SkinDebugger>();
 
-        if !self.headless {
+        if self.skinning {
             app.add_startup_system(skinned_mesh::skinning_setup.system())
                 .add_system_to_stage(
                     stage::SKINNING,

From 4d26d85bf420d102ff547931f53dd8943fa60692 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sun, 14 Feb 2021 16:45:51 -0300
Subject: [PATCH 102/153] rev 1

---
 Cargo.toml                                    |   8 +
 crates/bevy_animation/src/_experimental.rs    | 142 ------------------
 crates/bevy_animation/src/animator.rs         |  26 ++--
 crates/bevy_animation/src/blending.rs         |  32 ++--
 crates/bevy_animation/src/hierarchy.rs        |   6 +-
 .../src/interpolate/interpolate.rs            |   2 +-
 crates/bevy_animation/src/interpolate/lerp.rs |  34 ++---
 .../bevy_animation/src/interpolate/utils.rs   |  16 +-
 crates/bevy_animation/src/reflect.rs          |   2 +-
 crates/bevy_animation/src/tracks/fixed.rs     |  13 +-
 crates/bevy_animation/src/tracks/n.rs         |  12 +-
 examples/README.md                            |   8 +
 examples/animations/material_animation.rs     |  59 ++++++++
 examples/animations/mesh_swap_animation.rs    |  42 ++----
 examples/animations/run_animation.rs          |   3 -
 15 files changed, 157 insertions(+), 248 deletions(-)
 delete mode 100644 crates/bevy_animation/src/_experimental.rs
 create mode 100644 examples/animations/material_animation.rs

diff --git a/Cargo.toml b/Cargo.toml
index cdf3bdced6b4c..1417712c694df 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -412,6 +412,14 @@ path = "examples/android/android.rs"
 name = "run_animation"
 path = "examples/animations/run_animation.rs"
 
+# [[example]]
+# name = "mesh_swap_animation"
+# path = "examples/animations/mesh_swap_animation.rs"
+
+# [[example]]
+# name = "material_animation"
+# path = "examples/animations/material_animation.rs"
+
 [package.metadata.android]
 apk_label = "Bevy Example"
 assets = "assets"
diff --git a/crates/bevy_animation/src/_experimental.rs b/crates/bevy_animation/src/_experimental.rs
deleted file mode 100644
index 90ba32c1ec8f4..0000000000000
--- a/crates/bevy_animation/src/_experimental.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-//! Contains unused experimental ideas
-
-#![allow(dead_code)]
-
-use bevy_ecs::prelude::*;
-use fnv::FnvBuildHasher;
-use std::{collections::HashMap, num::NonZeroU16};
-
-use crate::custom::{Curves, CurvesUntyped};
-
-// pub struct EntityMap<'a>(&'a [u16]);
-
-// impl<'a> EntityMap<'a> {
-//     pub fn get_entity(index: EntityIndex) {
-
-//     }
-// }
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub enum FetchState<T> {
-    Pending,
-    Missing,
-    Found(T),
-}
-
-pub struct FetchComponentsMut<'a, T: Component> {
-    query: Query<'a, &'a mut T>,
-    cache: Vec<FetchState<Mut<'a, T>>>,
-}
-
-impl<'a, T: Component> FetchComponentsMut<'a, T> {
-    pub fn new(query: Query<'a, &'a mut T>) -> Self {
-        Self {
-            query,
-            cache: vec![],
-        }
-    }
-
-    pub fn begin<'b>(
-        &'b mut self,
-        entities: &'b [Option<Entity>],
-    ) -> FetchComponentsMutGroup<'a, 'b, T> {
-        self.cache.clear();
-        self.cache
-            .resize_with(entities.len(), || FetchState::Pending);
-
-        FetchComponentsMutGroup {
-            entities,
-            fetch: self,
-        }
-    }
-}
-
-pub struct FetchComponentsMutGroup<'a, 'b, T: Component> {
-    entities: &'b [Option<Entity>],
-    fetch: &'b mut FetchComponentsMut<'a, T>,
-}
-
-impl<'a, 'b, T: Component> FetchComponentsMutGroup<'a, 'b, T> {
-    pub fn get_mut<'c: 'a + 'b>(&'c mut self, entity_index: usize) -> Option<&'c mut Mut<'c, T>> {
-        let state = &mut self.fetch.cache[entity_index];
-        match state {
-            FetchState::Pending => {
-                // Try fetch once only
-                // SAFETY: Only one component will be fetched at the time
-                if let Some(t) = self.entities[entity_index]
-                    .map(|entity| unsafe { self.fetch.query.get_unsafe(entity).ok() })
-                    .flatten()
-                {
-                    *state = FetchState::Found(t);
-
-                    // TODO: Figure out a nicer way of getting t
-                    if let FetchState::Found(t) = state {
-                        Some(t)
-                    } else {
-                        unreachable!()
-                    }
-                } else {
-                    *state = FetchState::Missing;
-                    None
-                }
-            }
-            FetchState::Missing => None,
-            FetchState::Found(t) => Some(t),
-        }
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-#[derive(Default)]
-pub struct PropTicket(u16, u16);
-
-// Fast cached lookup table for properties names
-struct PropertiesStash {
-    table: HashMap<String, u16, FnvBuildHasher>,
-    ver: NonZeroU16,
-    elements: Vec<CurvesUntyped>,
-}
-
-impl Default for PropertiesStash {
-    fn default() -> Self {
-        Self {
-            table: HashMap::default(),
-            ver: NonZeroU16::new(1).unwrap(),
-            elements: vec![],
-        }
-    }
-}
-
-impl PropertiesStash {
-    // pub fn entry(&mut self, name: String) -> PropEntry {
-    //     //
-    //     todo!()
-    // }
-
-    pub fn get<T: 'static>(&self, name: &str, ticket: &mut PropTicket) -> Option<&Curves<T>> {
-        if ticket.1 != self.ver.get() {
-            // Token expired, find the new ticket
-            if let Some(index) = self.table.get(name) {
-                *ticket = PropTicket(*index, self.ver.get());
-            } else {
-                // Not found, set ticket invalid and return none
-                *ticket = PropTicket(u16::MAX, self.ver.get());
-                return None;
-            }
-        }
-
-        self.elements
-            .get(ticket.0 as usize)
-            .map(|curve_untyped| {
-                let curves = curve_untyped.downcast_ref::<T>();
-                if curves.is_none() {
-                    // Wrong type, return the invalid ticket
-                    *ticket = PropTicket(u16::MAX, self.ver.get());
-                }
-                curves
-            })
-            .flatten()
-    }
-}
diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index 6494f3024afe9..9b369f2a43ba5 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -82,7 +82,7 @@ impl<T> Tracks<T> {
         self.tracks.len() + self.n.iter().map(|(_, t)| t.len()).sum::<usize>()
     }
 
-    #[inline(always)]
+    #[inline]
     pub fn iter(
         &self,
     ) -> (
@@ -143,12 +143,12 @@ impl TracksUntyped {
         self.duration
     }
 
-    #[inline(always)]
+    #[inline]
     pub fn downcast_ref<T: 'static>(&self) -> Option<&Tracks<T>> {
         self.untyped.downcast_ref()
     }
 
-    #[inline(always)]
+    #[inline]
     pub fn downcast_mut<T: 'static>(&mut self) -> Option<&mut Tracks<T>> {
         self.untyped.downcast_mut()
     }
@@ -338,7 +338,7 @@ impl Clip {
         cache_index
     }
 
-    #[inline(always)]
+    #[inline]
     fn pack_by_type<V>(sampling_rate: f32, tracks: &mut Tracks<V::Value>) -> usize
     where
         V: ValueN + Lerp + Clone + Send + Sync + 'static,
@@ -420,7 +420,7 @@ impl Clip {
     }
 
     /// Number of animated properties in this clip
-    #[inline(always)]
+    #[inline]
     pub fn len(&self) -> usize {
         self.len
     }
@@ -452,18 +452,18 @@ impl Clip {
     }
 
     /// Clip duration
-    #[inline(always)]
+    #[inline]
     pub fn duration(&self) -> f32 {
         self.duration
     }
 
-    #[inline(always)]
+    #[inline]
     pub fn hierarchy(&self) -> &Hierarchy {
         &self.hierarchy
     }
 
     /// Get the curves an given property
-    #[inline(always)]
+    #[inline]
     pub fn get(&self, property_name: &str) -> Option<&TracksUntyped> {
         self.properties
             .get(property_name)
@@ -525,7 +525,7 @@ impl fmt::Debug for Layer {
 }
 
 impl Layer {
-    #[inline(always)]
+    #[inline]
     pub fn keyframes(&self) -> &[u16] {
         // SAFETY: Keyframes vec still needs to be flatten
         unsafe {
@@ -536,13 +536,13 @@ impl Layer {
         }
     }
 
-    #[inline(always)]
+    #[inline]
     pub fn keyframes_mut(&mut self) -> &mut [u16] {
         // SAFETY: Have mutability over self, but the keyframes vec still needs to be flatten
         unsafe { self.keyframes_unsafe() }
     }
 
-    #[inline(always)]
+    #[inline]
     pub unsafe fn keyframes_unsafe(&self) -> &mut [u16] {
         std::slice::from_raw_parts_mut(
             self.keyframes_buckets.as_ptr() as *mut _,
@@ -615,12 +615,12 @@ impl Animator {
 
     // TODO: cleanup, clears hierarchy entities and binds
 
-    #[inline(always)]
+    #[inline]
     pub fn entities(&self) -> &[Option<Entity>] {
         &self.entities[..]
     }
 
-    #[inline(always)]
+    #[inline]
     pub fn clips(&self) -> &[Handle<Clip>] {
         &self.clips[..]
     }
diff --git a/crates/bevy_animation/src/blending.rs b/crates/bevy_animation/src/blending.rs
index 40fc1834ef950..dfaadb00f06d6 100644
--- a/crates/bevy_animation/src/blending.rs
+++ b/crates/bevy_animation/src/blending.rs
@@ -23,7 +23,7 @@ pub struct AnimatorBlending {
 }
 
 impl AnimatorBlending {
-    #[inline(always)]
+    #[inline]
     pub fn begin_blending(&mut self, entities: usize, weight_slots: usize) -> AnimatorBlendGroup {
         self.bits.clear();
         self.bits.resize(entities, 0);
@@ -41,7 +41,7 @@ pub struct AnimatorBlendGroup<'a> {
 }
 
 impl<'a> AnimatorBlendGroup<'a> {
-    #[inline(always)]
+    #[inline]
     pub fn blend<T>(
         &mut self,
         entity_index: usize,
@@ -61,7 +61,7 @@ impl<'a> AnimatorBlendGroup<'a> {
     }
 
     /// Contest blending, only the value with the highest weight value will remain
-    #[inline(always)]
+    #[inline]
     pub fn blend_contest<T>(
         &mut self,
         entity_index: usize,
@@ -83,49 +83,49 @@ impl<'a> AnimatorBlendGroup<'a> {
 // ? NOTE: Implements the 'Additive 1' mode described here
 // ? https://github.com/nfrechette/acl/blob/develop/docs/additive_clips.md
 
-#[inline(always)]
+#[inline]
 fn additive_blend_bool(a: &bool, b: &bool, _: f32) -> bool {
     // TODO: Review
     *a || *b
 }
 
-#[inline(always)]
+#[inline]
 fn additive_blend_f32(a: &f32, b: &f32, w: f32) -> f32 {
     *a + (*b * w)
 }
 
-#[inline(always)]
+#[inline]
 fn additive_blend_vec2(a: &Vec2, b: &Vec2, w: f32) -> Vec2 {
     *a + (*b * w)
 }
 
-#[inline(always)]
+#[inline]
 fn additive_blend_vec3(a: &Vec3, b: &Vec3, w: f32) -> Vec3 {
     *a + (*b * w)
 }
 
-#[inline(always)]
+#[inline]
 fn additive_blend_vec4(a: &Vec4, b: &Vec4, w: f32) -> Vec4 {
     *a + (*b * w)
 }
 
-#[inline(always)]
+#[inline]
 fn additive_blend_quat(a: &Quat, b: &Quat, w: f32) -> Quat {
     // TODO: Review
     (*b * w) * *a
 }
 
-#[inline(always)]
+#[inline]
 fn additive_blend_scale2(a: &Scale2, b: &Scale2, w: f32) -> Scale2 {
     Scale2((Vec2::one() + (b.0 * w)) * a.0)
 }
 
-#[inline(always)]
+#[inline]
 fn additive_blend_scale3(a: &Scale3, b: &Scale3, w: f32) -> Scale3 {
     Scale3((Vec3::one() + (b.0 * w)) * a.0)
 }
 
-#[inline(always)]
+#[inline]
 fn additive_blend_color(a: &Color, b: &Color, w: f32) -> Color {
     (Vec4::from(*a) + (Vec4::from(*b) * w)).into()
 }
@@ -142,7 +142,7 @@ fn additive_blend_color(a: &Color, b: &Color, w: f32) -> Color {
 /// struct MyType;
 ///
 /// impl Blend for MyType {
-///     #[inline(always)]
+///     #[inline]
 ///     fn blend(
 ///         &mut self,
 ///         entity_index: usize,
@@ -180,7 +180,7 @@ macro_rules! impl_blend {
                 false
             }
 
-            #[inline(always)]
+            #[inline]
             fn blend(
                 &mut self,
                 entity_index: usize,
@@ -218,7 +218,7 @@ impl<T: Asset + 'static> Blend for Handle<T> {
         true
     }
 
-    #[inline(always)]
+    #[inline]
     fn blend(
         &mut self,
         entity_index: usize,
@@ -238,7 +238,7 @@ impl Blend for HandleUntyped {
         true
     }
 
-    #[inline(always)]
+    #[inline]
     fn blend(
         &mut self,
         entity_index: usize,
diff --git a/crates/bevy_animation/src/hierarchy.rs b/crates/bevy_animation/src/hierarchy.rs
index 739437985c276..e1273295349f0 100644
--- a/crates/bevy_animation/src/hierarchy.rs
+++ b/crates/bevy_animation/src/hierarchy.rs
@@ -120,13 +120,13 @@ impl<I: Index> Hierarchy<I> {
     }
 
     /// Number of entities registered.
-    #[inline(always)]
+    #[inline]
     pub fn len(&self) -> usize {
         self.entities.len()
     }
 
     /// Iterates over each entity parent index, name and children indexes
-    #[inline(always)]
+    #[inline]
     pub fn iter(&self) -> impl Iterator<Item = (&(I, Name), &[I])> {
         self.entities
             .iter()
@@ -134,7 +134,7 @@ impl<I: Index> Hierarchy<I> {
     }
 
     /// Gets the entity parent index and `Name` components
-    #[inline(always)]
+    #[inline]
     pub fn get_entity(&self, entity_index: I) -> &(I, Name) {
         &self.entities[entity_index.as_usize()]
     }
diff --git a/crates/bevy_animation/src/interpolate/interpolate.rs b/crates/bevy_animation/src/interpolate/interpolate.rs
index 915b668820695..a87adb714b42b 100644
--- a/crates/bevy_animation/src/interpolate/interpolate.rs
+++ b/crates/bevy_animation/src/interpolate/interpolate.rs
@@ -41,7 +41,7 @@ pub trait Interpolate {
 impl Interpolate for bool {
     type Tangent = TangentIgnore;
 
-    #[inline(always)]
+    #[inline]
     fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
         let _ = interp;
         if t > 0.99 {
diff --git a/crates/bevy_animation/src/interpolate/lerp.rs b/crates/bevy_animation/src/interpolate/lerp.rs
index c71e333fa5fdb..9acf7d2ea92c4 100644
--- a/crates/bevy_animation/src/interpolate/lerp.rs
+++ b/crates/bevy_animation/src/interpolate/lerp.rs
@@ -13,7 +13,7 @@ pub trait Lerp {
 }
 
 impl Lerp for bool {
-    #[inline(always)]
+    #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         if t > 0.99 {
             b.clone()
@@ -24,63 +24,63 @@ impl Lerp for bool {
 }
 
 impl Lerp for f32 {
-    #[inline(always)]
+    #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
 }
 
 impl Lerp for Vec2 {
-    #[inline(always)]
+    #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
 }
 
 impl Lerp for Vec3 {
-    #[inline(always)]
+    #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
 }
 
 impl Lerp for Vec3x4 {
-    #[inline(always)]
+    #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * f32x4::splat(1.0 - t) + (*b) * f32x4::splat(t)
     }
 }
 
 impl Lerp for Vec3x8 {
-    #[inline(always)]
+    #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * f32x8::splat(1.0 - t) + (*b) * f32x8::splat(t)
     }
 }
 
 impl Lerp for Vec4 {
-    #[inline(always)]
+    #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
 }
 
 impl Lerp for Vec4x4 {
-    #[inline(always)]
+    #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * f32x4::splat(1.0 - t) + (*b) * f32x4::splat(t)
     }
 }
 
 impl Lerp for Vec4x8 {
-    #[inline(always)]
+    #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * f32x8::splat(1.0 - t) + (*b) * f32x8::splat(t)
     }
 }
 
 impl Lerp for Color {
-    #[inline(always)]
+    #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
@@ -89,7 +89,7 @@ impl Lerp for Color {
 impl Lerp for Quat {
     /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
     /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
-    #[inline(always)]
+    #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         let mut b = *b;
 
@@ -107,7 +107,7 @@ impl Lerp for Quat {
 impl Lerp for Quatx4 {
     /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
     /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
-    #[inline(always)]
+    #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         let mut b = b.0;
 
@@ -128,7 +128,7 @@ impl Lerp for Quatx4 {
 impl Lerp for Quatx8 {
     /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
     /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
-    #[inline(always)]
+    #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         let mut b = b.0;
 
@@ -147,21 +147,21 @@ impl Lerp for Quatx8 {
 }
 
 impl Lerp for Scale2 {
-    #[inline(always)]
+    #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         Scale2(Vec2::lerp(a.0, b.0, t))
     }
 }
 
 impl Lerp for Scale3 {
-    #[inline(always)]
+    #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         Scale3(Vec3::lerp(a.0, b.0, t))
     }
 }
 
 impl<T: Asset + 'static> Lerp for Handle<T> {
-    #[inline(always)]
+    #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         if t > 0.99 {
             b.clone()
@@ -172,7 +172,7 @@ impl<T: Asset + 'static> Lerp for Handle<T> {
 }
 
 impl Lerp for HandleUntyped {
-    #[inline(always)]
+    #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         if t > 0.99 {
             b.clone()
diff --git a/crates/bevy_animation/src/interpolate/utils.rs b/crates/bevy_animation/src/interpolate/utils.rs
index 63aad015e238a..e6f1e97699742 100644
--- a/crates/bevy_animation/src/interpolate/utils.rs
+++ b/crates/bevy_animation/src/interpolate/utils.rs
@@ -38,12 +38,12 @@ pub struct Scale3(pub Vec3);
 /// Quake 3 fast inverse sqrt
 ///
 /// Took this one from piston: https://github.com/PistonDevelopers/skeletal_animation
-#[inline(always)]
+#[inline]
 pub fn inv_sqrt(x: f32) -> f32 {
     let x2: f32 = x * 0.5;
     let mut y: f32 = x;
 
-    let mut i: i32 = unsafe { std::mem::transmute(y) };
+    let mut i: i32 = y.to_bits() as i32;
     i = 0x5f3759df - (i >> 1);
     y = unsafe { std::mem::transmute(i) };
 
@@ -52,7 +52,7 @@ pub fn inv_sqrt(x: f32) -> f32 {
 }
 
 /// Quake 3 fast inverse sqrt for `f32x4`
-#[inline(always)]
+#[inline]
 pub fn inv_sqrt4(x: f32x4) -> f32x4 {
     let x2: f32x4 = x * 0.5;
     let mut y: f32x4 = x;
@@ -66,7 +66,7 @@ pub fn inv_sqrt4(x: f32x4) -> f32x4 {
 }
 
 /// Quake 3 fast inverse sqrt for `f32x8`
-#[inline(always)]
+#[inline]
 pub fn inv_sqrt8(x: f32x8) -> f32x8 {
     let x2: f32x8 = x * 0.5;
     let mut y: f32x8 = x;
@@ -79,7 +79,7 @@ pub fn inv_sqrt8(x: f32x8) -> f32x8 {
     y
 }
 
-#[inline(always)]
+#[inline]
 pub fn step<T: Clone>(k0: &T, k1: &T, u: f32) -> T {
     if u > 0.99 {
         k0.clone()
@@ -88,7 +88,7 @@ pub fn step<T: Clone>(k0: &T, k1: &T, u: f32) -> T {
     }
 }
 
-#[inline(always)]
+#[inline]
 pub fn lerp<T>(k0: T, k1: T, u: f32) -> T
 where
     T: Add<Output = T> + Mul<f32, Output = T>,
@@ -99,7 +99,7 @@ where
 /// Catmull-Rom spline interpolation
 ///
 /// Source: http://archive.gamedev.net/archive/reference/articles/article1497.html
-#[inline(always)]
+#[inline]
 pub fn catmull_rom<T>(k0: T, t0: T, k1: T, t1: T, u: f32) -> T
 where
     T: Add<Output = T> + Sub<Output = T> + Mul<f32, Output = T>,
@@ -115,7 +115,7 @@ where
 /// Finds the tangent gradients for the Catmull-Rom spline
 ///
 /// Source: http://archive.gamedev.net/archive/reference/articles/article1497.html
-#[inline(always)]
+#[inline]
 pub fn auto_tangent<T>(t0: f32, t1: f32, t2: f32, k0: T, k1: T, k2: T) -> T
 where
     T: Copy + Add<Output = T> + Sub<Output = T> + Mul<f32, Output = T> + Div<f32, Output = T>,
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index 8240889c05471..db5801354cf2e 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -208,7 +208,7 @@ impl<T> Default for AnimatorDescriptor<T> {
 }
 
 impl<T> AnimatorDescriptor<T> {
-    #[inline(always)]
+    #[inline]
     pub fn properties(&self) -> impl Iterator<Item = (&str, TypeId)> {
         self.dynamic_properties
             .iter()
diff --git a/crates/bevy_animation/src/tracks/fixed.rs b/crates/bevy_animation/src/tracks/fixed.rs
index bb93a9acd3dba..786669aced286 100644
--- a/crates/bevy_animation/src/tracks/fixed.rs
+++ b/crates/bevy_animation/src/tracks/fixed.rs
@@ -85,7 +85,7 @@ where
 
     fn sample(&self, time: f32) -> Self::Output {
         // Make sure to have at least one sample
-        assert!(self.keyframes.len() > 0, "curve is empty");
+        assert!(self.keyframes.len() > 0, "track is empty");
 
         let t = time.mul_add(self.frame_rate, self.negative_offset);
         if t.is_sign_negative() {
@@ -104,18 +104,11 @@ where
         }
 
         // Lerp the value
-        // SAFETY: bounds checks are performed in the lines above
-        unsafe {
-            T::lerp(
-                self.keyframes.get_unchecked(f),
-                self.keyframes.get_unchecked(f + 1),
-                t,
-            )
-        }
+        T::lerp(&self.keyframes[f], &self.keyframes[f + 1], t)
     }
 
     /// Same as `sample` function
-    #[inline(always)]
+    #[inline]
     fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, Self::Output) {
         let _ = cursor;
         (0, self.sample(time))
diff --git a/crates/bevy_animation/src/tracks/n.rs b/crates/bevy_animation/src/tracks/n.rs
index b766d46fdb4da..86d1610d2844f 100644
--- a/crates/bevy_animation/src/tracks/n.rs
+++ b/crates/bevy_animation/src/tracks/n.rs
@@ -160,12 +160,12 @@ macro_rules! valuen {
             type Outputs = [Self::Value; $s];
             type Value = $o;
 
-            #[inline(always)]
+            #[inline]
             fn pack(values: Self::Outputs) -> Self {
                 unsafe { transmute::<_, [$i; $s]>(values).into() }
             }
 
-            #[inline(always)]
+            #[inline]
             fn unpack(self) -> Self::Outputs {
                 unsafe { transmute::<[$i; $s], _>(self.into()) }
             }
@@ -189,12 +189,12 @@ impl ValueN for Quatx4 {
     type Outputs = [Self::Value; 4];
     type Value = Quat;
 
-    #[inline(always)]
+    #[inline]
     fn pack(values: Self::Outputs) -> Self {
         Quatx4(unsafe { transmute::<_, [ultraviolet::Vec4; 4]>(values).into() })
     }
 
-    #[inline(always)]
+    #[inline]
     fn unpack(self) -> Self::Outputs {
         unsafe { transmute::<[ultraviolet::Vec4; 4], _>(self.0.into()) }
     }
@@ -209,12 +209,12 @@ impl ValueN for Quatx8 {
     type Outputs = [Self::Value; 8];
     type Value = Quat;
 
-    #[inline(always)]
+    #[inline]
     fn pack(values: Self::Outputs) -> Self {
         Quatx8(unsafe { transmute::<_, [ultraviolet::Vec4; 8]>(values).into() })
     }
 
-    #[inline(always)]
+    #[inline]
     fn unpack(self) -> Self::Outputs {
         unsafe { transmute::<[ultraviolet::Vec4; 8], _>(self.0.into()) }
     }
diff --git a/examples/README.md b/examples/README.md
index 1968eeaa16ec9..fd36755964747 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -78,6 +78,14 @@ Example | File | Description
 `update_gltf_scene` | [`3d/update_gltf_scene.rs`](./3d/update_gltf_scene.rs) | Update a scene from a gltf file, either by spawning the scene as a child of another entity, or by accessing the entities of the scene
 `z_sort_debug` | [`3d/z_sort_debug.rs`](./3d/z_sort_debug.rs) | Visualizes camera Z-ordering
 
+## Animations
+
+Example | File | Description
+--- | --- | ---
+`run_animation` | [`animations/run_animation.rs`](./animations/run_animation.rs) | Demonstrates how to play and blending between a idle and run animations
+[//]: # (`mesh_swap_animation` | [`animations/mesh_swap_animation.rs`](./animations/mesh_swap_animation.rs) | Demonstrates hot to create your own animation clip that swaps meshes (or any other asset handle))
+[//]: # (`material_animation` | [`animations/material_animation.rs`](./animations/material_animation.rs) | Illustrate how to animate material properties (or any other asset property))
+
 ## Application
 
 Example | File | Description
diff --git a/examples/animations/material_animation.rs b/examples/animations/material_animation.rs
new file mode 100644
index 0000000000000..ad94065b4cdc1
--- /dev/null
+++ b/examples/animations/material_animation.rs
@@ -0,0 +1,59 @@
+use bevy::animation::{AddAnimated, Animator, Clip};
+use bevy::asset::AssetServerSettings;
+use bevy::prelude::*;
+
+fn main() {
+    App::build()
+        .add_plugins(DefaultPlugins)
+        .register_animated_asset::<StandardMaterial>()
+        .add_startup_system(setup.system())
+        .run();
+}
+
+fn setup(
+    commands: &mut Commands,
+    asset_server: Res<AssetServer>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut clips: ResMut<Assets<Clip>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // TODO: create clip here
+
+    let mut animator = Animator::default();
+    // TODO: add clip
+
+    let entity = commands
+        .spawn(PbrBundle {
+            mesh: meshes.add(Mesh::from(shape::Icosphere {
+                radius: 1.0,
+                subdivisions: 5,
+            })),
+            transform: Transform::from_translation(Vec3::new(0.0, -1.0, 0.0)),
+            material: materials.add(Color::rgb(0.1, 0.05, 0.0).into()),
+            ..Default::default()
+        })
+        .with(animator);
+
+    commands
+        // plane
+        .spawn(PbrBundle {
+            mesh: meshes.add(Mesh::from(shape::Plane { size: 20.0 })),
+            transform: Transform::from_translation(Vec3::new(0.0, -1.0, 0.0)),
+            material: materials.add(Color::rgb(0.1, 0.05, 0.0).into()),
+            ..Default::default()
+        })
+        // light
+        .spawn(LightBundle {
+            transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
+            ..Default::default()
+        })
+        // camera
+        .spawn(PerspectiveCameraBundle {
+            transform: Transform::from_matrix(Mat4::face_toward(
+                Vec3::new(-3.0, 5.0, 8.0),
+                Vec3::new(0.0, 0.0, 0.0),
+                Vec3::new(0.0, 1.0, 0.0),
+            )),
+            ..Default::default()
+        });
+}
diff --git a/examples/animations/mesh_swap_animation.rs b/examples/animations/mesh_swap_animation.rs
index c170821f450e6..1332a9c3e1847 100644
--- a/examples/animations/mesh_swap_animation.rs
+++ b/examples/animations/mesh_swap_animation.rs
@@ -1,11 +1,12 @@
-use bevy::animation::Animator;
+use bevy::animation::{AddAnimated, Animator, Clip};
 use bevy::asset::AssetServerSettings;
 use bevy::prelude::*;
 
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .register_animated_asset::<Mesh>()
+        .add_startup_system(setup.system())
         .run();
 }
 
@@ -13,6 +14,7 @@ fn setup(
     commands: &mut Commands,
     asset_server: Res<AssetServer>,
     mut meshes: ResMut<Assets<Mesh>>,
+    mut clips: ResMut<Assets<Clip>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
     let cube = meshes.add(Mesh::from(shape::Cube { size: 1.0 }));
@@ -22,6 +24,13 @@ fn setup(
         subdivisions: 5,
     }));
 
+    // TODO: more shapes will be nice!
+
+    // TODO: create clip here
+
+    let mut animator = Animator::default();
+    // TODO: add clip
+
     let entity = commands
         .spawn(PbrBundle {
             mesh: cube.clone(),
@@ -29,44 +38,21 @@ fn setup(
             material: materials.add(Color::rgb(0.1, 0.05, 0.0).into()),
             ..Default::default()
         })
-        .with_;
+        .with(animator);
 
     commands
-        // plane
-        .spawn(PbrBundle {
-            mesh: meshes.add(Mesh::from(shape::Plane { size: 20.0 })),
-            transform: Transform::from_translation(Vec3::new(0.0, -1.0, 0.0)),
-            material: materials.add(Color::rgb(0.1, 0.05, 0.0).into()),
-            ..Default::default()
-        })
         // light
         .spawn(LightBundle {
             transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
             ..Default::default()
         })
         // camera
-        .spawn(Camera3dBundle {
+        .spawn(PerspectiveCameraBundle {
             transform: Transform::from_matrix(Mat4::face_toward(
                 Vec3::new(-3.0, 5.0, 8.0),
                 Vec3::new(0.0, 0.0, 0.0),
                 Vec3::new(0.0, 1.0, 0.0),
             )),
             ..Default::default()
-        })
-}
-
-fn anim_set(asset_server: Res<AssetServer>, mut animators_query: Query<(&mut Animator,)>) {
-    // Load animations and set them to the animator
-    for (mut animator,) in animators_query.iter_mut() {
-        if animator.clips().len() == 0 {
-            animator.add_layer(
-                asset_server.load("models/character_medium/idle.gltf#Anim0"),
-                1.0,
-            );
-            animator.add_layer(
-                asset_server.load("models/character_medium/run.gltf#Anim0"),
-                1.0,
-            );
-        }
-    }
+        });
 }
diff --git a/examples/animations/run_animation.rs b/examples/animations/run_animation.rs
index 3c94690ead156..f534c4c178309 100644
--- a/examples/animations/run_animation.rs
+++ b/examples/animations/run_animation.rs
@@ -2,9 +2,6 @@ use bevy::{animation::Animator, prelude::*};
 
 fn main() {
     App::build()
-        // .add_resource(AssetServerSettings {
-        //     asset_folder: "G:/Rust/bevy/assets".to_string(),
-        // })
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
         .add_system(anim_set.system().label("anim_set"))

From ccb35cc33f170f2cd4ef0adf983a0ebd53fc8c69 Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Sun, 14 Feb 2021 22:02:21 -0300
Subject: [PATCH 103/153] more examples to animate handle and theirs properties

---
 Cargo.toml                                 |  12 +-
 crates/bevy_animation/prdraft.md           | 158 ---------------------
 crates/bevy_pbr/src/material.rs            |   5 +-
 crates/bevy_render/src/mesh/mesh.rs        |  14 +-
 examples/animations/material_animation.rs  |  30 ++--
 examples/animations/mesh_swap_animation.rs |  29 ++--
 6 files changed, 52 insertions(+), 196 deletions(-)
 delete mode 100644 crates/bevy_animation/prdraft.md

diff --git a/Cargo.toml b/Cargo.toml
index 1417712c694df..b70ff439c8646 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -412,13 +412,13 @@ path = "examples/android/android.rs"
 name = "run_animation"
 path = "examples/animations/run_animation.rs"
 
-# [[example]]
-# name = "mesh_swap_animation"
-# path = "examples/animations/mesh_swap_animation.rs"
+[[example]]
+name = "mesh_swap_animation"
+path = "examples/animations/mesh_swap_animation.rs"
 
-# [[example]]
-# name = "material_animation"
-# path = "examples/animations/material_animation.rs"
+[[example]]
+name = "material_animation"
+path = "examples/animations/material_animation.rs"
 
 [package.metadata.android]
 apk_label = "Bevy Example"
diff --git a/crates/bevy_animation/prdraft.md b/crates/bevy_animation/prdraft.md
deleted file mode 100644
index 071c8d2f81c0a..0000000000000
--- a/crates/bevy_animation/prdraft.md
+++ /dev/null
@@ -1,158 +0,0 @@
-Property based Animation PR (draft)
-
-Any type that implements `bevy_reflect::Struct` can have their attributes animated.
-
-Has a safety restriction only attributes that are within the struct memory limits can be addressed and animated,
-this means you can't animate items behind a `Vec`, array types could be animated but nested properties implementation
-is missing.
-
-The system main goal is to provide an low level api to play and blend animations.
-That been said an animation state machine should be built by the user or provided by a external crate.
-
-## Features
-
-1. Property based animation
-
-```rust
-let mut clip = Clip::default();
-/// A property is defined by the entity path followed by the component property
-clip.add_curve_at_path("/Node1/Node2@Transform.translation", track_data);
-```
-
-2. Animate any type using bevy_reflect
-
-```rust
-#[derive(Debug, Reflect)]
-#[reflect(Component)]
-struct CustomComponent {
-    value: f32,
-    point: Vec3,
-    #[reflect(ignore)]
-    non_animated: Vec3,
-}
-
-// During app startup
-app_builder.register_animated_component::<bevy_transform::prelude::Transform>();
-
-let mut clip = Clip::default();
-clip.add_curve_at_path("@CustomComponent.value", ...);
-clip.add_curve_at_path("@CustomComponent.point", ...);
-```
-
-4. Animate assets by swapping handles or animate their properties
-
-```rust
-// During app startup
-app_builder.register_animated_asset::<bevy_pbr::prelude::StandardMaterial>();
-
-let mut clip = Clip::default();
-// Swap material with
-clip.add_curve_at_path("@Handle<StandardMaterial>", ...);
-// Change the current material properties
-clip.add_curve_at_path("@Handle<StandardMaterial>.albedo", ...);
-clip.add_curve_at_path("@Handle<StandardMaterial>.albedo_texture", ...);
-```
-
-5. GLTF support
-
-You can load any animation clips embedded within a GLTF file
-
-```rust
-// Loads the skinned mesh ready to be animated with all of its clips (if any)
-let char_scene_handle = asset_server.load("models/character_medium/character_medium.gltf");
-// Returns a single clip from the GLTF
-let clip_handle = asset_server.load("models/character_medium/idle.gltf#Anim0");
-```
-
-6. Animation Blending
-
-It's possible to blend `bool`, `f32`, `Vec2`, `Vec3`, `Vec4`, `Quat`, `Handle<T>`, `Option<T>` when `T` can also be blended, and more.
-
-7. Animation clips defined by a named hierarchy
-
-Each `Animator` can only animate children entities, this is similar to other engines like Unity;
-
-Each clip have it's own hierarchy space, this allows clips to be reused for different setups that
-share some similarities. 
-
-Note that this isn't a humanoid retargeting system, but it could give you some good results is some particular situations;
-
-8. Mostly safe :p
-
-This crate uses a couple `unsafe`'s blocks, the safety rules of these blocks should be guaranteed
-at within the scope of a function or file (in the worst case) this way changes can be more easily
-made without the fear braking random safety conditions, as a bonus they should be asserted
-by code whenever possible;
-
-**The unsafe code still needs a review** 
-
-9. Fast TM
-
-a) Each component animation runs in parallel from each other
-b) Keyframe cursor, allows for faster sample rates by remembering the last keyframe it was last frame
-c) NLerp only and you wont notice the difference, hopefully ...
-
-10. Skinned Mesh support out of the box
-
-Simple and naive implementation, replaces the vertex shader from the `bevy_pbr::prelude::StandardMaterial`.
-Further work should done along side with the rendering, but hey it works!  
-
-11. Additive Blending
-
-Supports additive blending as defined by the ACL mode Additive 1, that can be found
-[here](https://github.com/nfrechette/acl/blob/develop/docs/additive_clips.md)
-
-12. SIMD support
-
-Clips can now be packed, a packed clip will contain tracks that are sampled using wide types from the `ultraviolet` crate
-thus resulting in a greater sampling throughput.
-
-## Missing Features
-
-1. Nested properties
-
-Right now only the top most properties of each struct can be animated,
-this means `"@CustomComponent.point.x"` isn't valid;
-
-2. Masks
-
-3. Animation events (simple and interval)
-
-4. Morph Targets
-
-5. Dedicated `Transform` animator system
-
-`Transform` is the most common animated component in any game, its the only animated component registered
-by default and it should receive a custom animator system to squeeze every single us that is possible,
-this custom system should be also be capable of performing SIMD blending;
-
-
-## Terminology and Internals
-
-A clip is where all the animation data is stored, it's made out of a hierarchy of entities
-and a list of animated properties, each property is defined by path (`Transform.translation`) and type (`Vec3`)
-and contains a list of all the samplers paired with their respective output entities or channels;
-
-A sampler evaluates the state of a property at any given time. The `Track` is the only sampler currently implemented
-and comes in 3 flavors.
-
-1. `TrackFixed` performant in any operation range, requires a keyframe for every frame of the animation duration;
-
-2. `TrackVariableLinear`, can be used with linear keyframe reduction technique to save memory at runtime,
-most performant when sampled at a higher fps than the track sample rate. 
-
-3. `TrackVariable` very similar to `TrackVariableLinear` but beyond linear it supports step and catmull-rom as interpolations methods,
-because of that it will have a lower performance and require and extra runtime memory to store the keyframes tangents;
-This track is similar to `AnimationCurve` from Unity engine;
-
-## Safety status
-
-Assume that `bevy_reflect::Struct` was correctly implemented
-
-For that to happen unsafe blocks are used, but their safety constrains should be
-self contained within the same file or even with the same function block, with one
-single exception.
-
-Asside from that an animator system can be implemented with only safe code for any
-type that you may want, its a lot of code but mostly is boiler plates. Optionally you can
-add two extra unsafe blocks to improve performance (with very little safety conditions);
\ No newline at end of file
diff --git a/crates/bevy_pbr/src/material.rs b/crates/bevy_pbr/src/material.rs
index 1244d23a11364..83c034e825e56 100644
--- a/crates/bevy_pbr/src/material.rs
+++ b/crates/bevy_pbr/src/material.rs
@@ -1,13 +1,14 @@
 use bevy_asset::{self, Handle};
-use bevy_reflect::TypeUuid;
+use bevy_reflect::{Reflect, TypeUuid};
 use bevy_render::{color::Color, renderer::RenderResources, shader::ShaderDefs, texture::Texture};
 
 /// A material with "standard" properties used in PBR lighting
-#[derive(Debug, RenderResources, ShaderDefs, TypeUuid)]
+#[derive(Debug, RenderResources, ShaderDefs, TypeUuid, Reflect)]
 #[uuid = "dace545e-4bc6-4595-a79d-c224fc694975"]
 pub struct StandardMaterial {
     pub albedo: Color,
     #[shader_def]
+    #[reflect(ignore)]
     pub albedo_texture: Option<Handle<Texture>>,
     #[render_resources(ignore)]
     #[shader_def]
diff --git a/crates/bevy_render/src/mesh/mesh.rs b/crates/bevy_render/src/mesh/mesh.rs
index edc706cd590b8..86616de81da7d 100644
--- a/crates/bevy_render/src/mesh/mesh.rs
+++ b/crates/bevy_render/src/mesh/mesh.rs
@@ -7,7 +7,7 @@ use bevy_asset::{AssetEvent, Assets, Handle};
 use bevy_core::AsBytes;
 use bevy_ecs::{Changed, Entity, Local, Mut, Query, QuerySet, Res, With};
 use bevy_math::*;
-use bevy_reflect::TypeUuid;
+use bevy_reflect::{Reflect, TypeUuid};
 use std::borrow::Cow;
 
 use crate::pipeline::{InputStepMode, VertexAttribute, VertexBufferLayout};
@@ -198,15 +198,25 @@ impl From<&Indices> for IndexFormat {
 }
 
 // TODO: allow values to be unloaded after been submitting to the GPU to conserve memory
-#[derive(Debug, TypeUuid)]
+#[derive(Debug, TypeUuid, Reflect)]
 #[uuid = "8ecbac0f-f545-4473-ad43-e1f4243af51e"]
 pub struct Mesh {
+    #[reflect(ignore)]
     primitive_topology: PrimitiveTopology,
     /// `bevy_utils::HashMap` with all defined vertex attributes (Positions, Normals, ...) for this mesh. Attribute name maps to attribute values.
+    #[reflect(ignore)]
     attributes: HashMap<Cow<'static, str>, VertexAttributeValues>,
+    #[reflect(ignore)]
     indices: Option<Indices>,
 }
 
+impl Default for Mesh {
+    /// Creates a empty triangle list mesh
+    fn default() -> Self {
+        Mesh::new(PrimitiveTopology::TriangleList)
+    }
+}
+
 impl Mesh {
     pub const ATTRIBUTE_COLOR: &'static str = "Vertex_Color";
     pub const ATTRIBUTE_JOINT: &'static str = "Vertex_Join";
diff --git a/examples/animations/material_animation.rs b/examples/animations/material_animation.rs
index ad94065b4cdc1..aa62e0799579a 100644
--- a/examples/animations/material_animation.rs
+++ b/examples/animations/material_animation.rs
@@ -1,5 +1,4 @@
-use bevy::animation::{AddAnimated, Animator, Clip};
-use bevy::asset::AssetServerSettings;
+use bevy::animation::{tracks::TrackVariableLinear, AddAnimated, Animator, Clip};
 use bevy::prelude::*;
 
 fn main() {
@@ -12,42 +11,41 @@ fn main() {
 
 fn setup(
     commands: &mut Commands,
-    asset_server: Res<AssetServer>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut clips: ResMut<Assets<Clip>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    // TODO: create clip here
+    // Create clip
+    let mut clip = Clip::default();
+    clip.add_track_at_path(
+        "@Handle<StandardMaterial>.albedo",
+        TrackVariableLinear::from_line(0.0, 1.0, Color::WHITE, Color::ORANGE_RED),
+    );
+    let clip_handle = clips.add(clip);
 
+    // Create the animator and add the clip
     let mut animator = Animator::default();
-    // TODO: add clip
+    animator.add_layer(clip_handle, 1.0);
 
-    let entity = commands
+    // Animated sphere
+    commands
         .spawn(PbrBundle {
             mesh: meshes.add(Mesh::from(shape::Icosphere {
                 radius: 1.0,
                 subdivisions: 5,
             })),
-            transform: Transform::from_translation(Vec3::new(0.0, -1.0, 0.0)),
+            transform: Transform::from_translation(Vec3::new(0.0, 0.0, 0.0)),
             material: materials.add(Color::rgb(0.1, 0.05, 0.0).into()),
             ..Default::default()
         })
         .with(animator);
 
+    // Camera and Light
     commands
-        // plane
-        .spawn(PbrBundle {
-            mesh: meshes.add(Mesh::from(shape::Plane { size: 20.0 })),
-            transform: Transform::from_translation(Vec3::new(0.0, -1.0, 0.0)),
-            material: materials.add(Color::rgb(0.1, 0.05, 0.0).into()),
-            ..Default::default()
-        })
-        // light
         .spawn(LightBundle {
             transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
             ..Default::default()
         })
-        // camera
         .spawn(PerspectiveCameraBundle {
             transform: Transform::from_matrix(Mat4::face_toward(
                 Vec3::new(-3.0, 5.0, 8.0),
diff --git a/examples/animations/mesh_swap_animation.rs b/examples/animations/mesh_swap_animation.rs
index 1332a9c3e1847..b2e4833ab2b8e 100644
--- a/examples/animations/mesh_swap_animation.rs
+++ b/examples/animations/mesh_swap_animation.rs
@@ -1,5 +1,4 @@
-use bevy::animation::{AddAnimated, Animator, Clip};
-use bevy::asset::AssetServerSettings;
+use bevy::animation::{tracks::TrackVariableLinear, AddAnimated, Animator, Clip};
 use bevy::prelude::*;
 
 fn main() {
@@ -12,13 +11,11 @@ fn main() {
 
 fn setup(
     commands: &mut Commands,
-    asset_server: Res<AssetServer>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut clips: ResMut<Assets<Clip>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
     let cube = meshes.add(Mesh::from(shape::Cube { size: 1.0 }));
-
     let sphere = meshes.add(Mesh::from(shape::Icosphere {
         radius: 1.0,
         subdivisions: 5,
@@ -26,27 +23,35 @@ fn setup(
 
     // TODO: more shapes will be nice!
 
-    // TODO: create clip here
-
+    // Create clip
+    let mut clip = Clip::default();
+    clip.add_track_at_path(
+        "@Handle<Mesh>",
+        TrackVariableLinear::new(
+            vec![0.0, 0.5, 1.0],
+            vec![cube.clone(), sphere.clone(), cube.clone()],
+        ),
+    );
+    let clip_handle = clips.add(clip);
+
+    // Create the animator and add the clip
     let mut animator = Animator::default();
-    // TODO: add clip
+    animator.add_layer(clip_handle, 1.0);
 
-    let entity = commands
+    commands
         .spawn(PbrBundle {
             mesh: cube.clone(),
-            transform: Transform::from_translation(Vec3::new(0.0, -1.0, 0.0)),
-            material: materials.add(Color::rgb(0.1, 0.05, 0.0).into()),
+            transform: Transform::from_translation(Vec3::new(0.0, 0.0, 0.0)),
+            material: materials.add(Color::ANTIQUE_WHITE.into()),
             ..Default::default()
         })
         .with(animator);
 
     commands
-        // light
         .spawn(LightBundle {
             transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
             ..Default::default()
         })
-        // camera
         .spawn(PerspectiveCameraBundle {
             transform: Transform::from_matrix(Mat4::face_toward(
                 Vec3::new(-3.0, 5.0, 8.0),

From 88f26ecdb68e8befac19a5a25a7e65392a9e688e Mon Sep 17 00:00:00 2001
From: lassade <lassade@localhost.localdomain>
Date: Wed, 17 Feb 2021 04:39:53 -0300
Subject: [PATCH 104/153] fixed clippy errors

---
 crates/bevy_animation/src/animator.rs         | 42 +++++++++++++------
 crates/bevy_animation/src/app.rs              |  2 +-
 crates/bevy_animation/src/bench.rs            |  5 +--
 crates/bevy_animation/src/blending.rs         |  5 ++-
 crates/bevy_animation/src/hierarchy.rs        | 11 +++--
 .../interpolate.rs                            |  4 +-
 .../{interpolate => interpolation}/lerp.rs    | 40 +++++++++---------
 .../src/{interpolate => interpolation}/mod.rs |  0
 .../{interpolate => interpolation}/utils.rs   |  2 +-
 crates/bevy_animation/src/lib.rs              | 10 ++---
 crates/bevy_animation/src/reflect.rs          | 16 +++----
 crates/bevy_animation/src/skinned_mesh.rs     |  9 ++--
 crates/bevy_animation/src/tracks/fixed.rs     | 16 ++++---
 crates/bevy_animation/src/tracks/n.rs         |  8 +++-
 crates/bevy_animation/src/tracks/variable.rs  |  8 +++-
 .../src/tracks/variable_linear.rs             | 11 +++--
 crates/bevy_gltf/src/loader.rs                |  9 ++--
 examples/animations/mesh_swap_animation.rs    |  4 +-
 examples/animations/run_animation.rs          |  8 ++--
 19 files changed, 124 insertions(+), 86 deletions(-)
 rename crates/bevy_animation/src/{interpolate => interpolation}/interpolate.rs (99%)
 rename crates/bevy_animation/src/{interpolate => interpolation}/lerp.rs (88%)
 rename crates/bevy_animation/src/{interpolate => interpolation}/mod.rs (100%)
 rename crates/bevy_animation/src/{interpolate => interpolation}/utils.rs (98%)

diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index 9b369f2a43ba5..792f0c5408c0c 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -21,7 +21,7 @@ use tracing::warn;
 use crate::{
     blending::AnimatorBlending,
     hierarchy::Hierarchy,
-    interpolate::Lerp,
+    interpolation::Lerp,
     tracks::{ArrayN, Track, TrackBase, TrackFixed, TrackFixedN, TrackNBase, ValueN},
     wide::{Quatx8, Vec3x8},
 };
@@ -82,6 +82,11 @@ impl<T> Tracks<T> {
         self.tracks.len() + self.n.iter().map(|(_, t)| t.len()).sum::<usize>()
     }
 
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
     #[inline]
     pub fn iter(
         &self,
@@ -275,11 +280,9 @@ impl Clip {
                 let duration = tracks.calculate_duration();
 
                 // Drop the down casted ref and update the parent curve
-                std::mem::drop(tracks);
                 tracks_untyped.duration = duration;
 
                 // Drop the curves untyped (which as a mut borrow) and update the total duration
-                std::mem::drop(tracks_untyped);
                 self.duration = self.calculate_duration();
 
                 return k_index;
@@ -287,7 +290,7 @@ impl Clip {
 
             let search_n = tracks.n.iter().enumerate().find_map(|(i, (_, t))| {
                 t.lanes()
-                    .into_iter()
+                    .iter()
                     .position(|index| *index == entity_index)
                     .map(|o| (i, o))
             });
@@ -309,7 +312,6 @@ impl Clip {
             let duration = track.duration();
             tracks.outputs.push(entity_index);
             tracks.tracks.push((*cache_index, Box::new(track)));
-            std::mem::drop(tracks);
 
             self.len += 1;
             self.duration = self.duration.max(duration);
@@ -425,6 +427,11 @@ impl Clip {
         self.len
     }
 
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
     // /// Returns the property curve property path.
     // ///
     // /// The clip stores a property path in a specific way to improve search performance
@@ -542,8 +549,18 @@ impl Layer {
         unsafe { self.keyframes_unsafe() }
     }
 
+    /// # Safety
+    /// Ensure no other borrows exist along with this one.
+    ///
+    /// Alternatively its also possible to use the `curve_index` for properties that are only borrowed once;
+    /// The curves indexes are unique for each curve and for different properties are also guaranteed to not share the same cache line,
+    /// making possible to access the layer keyframes from multiple threads that doesn't look at the same property at the same time.
+    ///
+    /// Any race condition should only slowdown the animation sampling,
+    /// the `sample_with_cursor` function can recover no matter the input given;
     #[inline]
-    pub unsafe fn keyframes_unsafe(&self) -> &mut [u16] {
+    #[allow(clippy::mut_from_ref)]
+    pub(crate) unsafe fn keyframes_unsafe(&self) -> &mut [u16] {
         std::slice::from_raw_parts_mut(
             self.keyframes_buckets.as_ptr() as *mut _,
             self.keyframes_buckets.len() * KEYFRAMES_PER_CACHE,
@@ -625,7 +642,7 @@ impl Animator {
         &self.clips[..]
     }
 
-    pub fn animate<'a>(&'a self) -> LayerIterator<'a> {
+    pub fn animate(&self) -> LayerIterator {
         LayerIterator {
             index: 0,
             animator: self,
@@ -682,6 +699,7 @@ pub(crate) struct BindingState {
     clips_modified: HashSet<Handle<Clip>, FnvBuildHasher>,
 }
 
+#[allow(clippy::too_many_arguments)]
 pub(crate) fn animator_update_system(
     commands: &mut Commands,
     mut state: Local<BindingState>,
@@ -735,11 +753,11 @@ pub(crate) fn animator_update_system(
             let entity = animator.entities[entity_index];
 
             if let Some(entity) = entity {
-                if entity_deleted_query.get(entity).is_err() {
-                    // Entity deleted
-                    remove_entity = true;
-                } else if parent_or_name_removed_query.get(entity).is_ok() {
-                    // Parent or Name component where removed from entity
+                // Entity deleted
+                // or Parent or Name component where removed from entity
+                if entity_deleted_query.get(entity).is_err()
+                    || parent_or_name_removed_query.get(entity).is_ok()
+                {
                     remove_entity = true;
                 } else if let Ok((entity_parent, entity_name)) =
                     parent_or_name_changed_query.get(entity)
diff --git a/crates/bevy_animation/src/app.rs b/crates/bevy_animation/src/app.rs
index 9646a0b6ae7c9..5699e79e34a1c 100644
--- a/crates/bevy_animation/src/app.rs
+++ b/crates/bevy_animation/src/app.rs
@@ -9,7 +9,7 @@ use std::{
 };
 
 use crate::{
-    animator::AnimatorRegistry, blending::Blend, interpolate::Lerp, reflect, stage,
+    animator::AnimatorRegistry, blending::Blend, interpolation::Lerp, reflect, stage,
     AnimatorPropertyRegistry,
 };
 
diff --git a/crates/bevy_animation/src/bench.rs b/crates/bevy_animation/src/bench.rs
index 9e70aeb991d5f..cf943e8d6f5af 100644
--- a/crates/bevy_animation/src/bench.rs
+++ b/crates/bevy_animation/src/bench.rs
@@ -31,10 +31,7 @@ impl Bench {
             .add_plugin(bevy_app::ScheduleRunnerPlugin::default())
             .add_plugin(bevy_asset::AssetPlugin::default())
             .add_plugin(TransformPlugin::default())
-            .add_plugin(crate::AnimationPlugin {
-                skinning: false,
-                ..Default::default()
-            });
+            .add_plugin(crate::AnimationPlugin { skinning: false });
 
         let mut schedule = Schedule::default();
         schedule.add_stage(ANIMATE, SystemStage::parallel());
diff --git a/crates/bevy_animation/src/blending.rs b/crates/bevy_animation/src/blending.rs
index dfaadb00f06d6..1cb995a54291d 100644
--- a/crates/bevy_animation/src/blending.rs
+++ b/crates/bevy_animation/src/blending.rs
@@ -4,7 +4,7 @@ use bevy_asset::{Asset, Handle, HandleUntyped};
 use bevy_math::prelude::*;
 use bevy_render::color::Color;
 
-use crate::interpolate::{
+use crate::interpolation::{
     utils::{Scale2, Scale3},
     Lerp,
 };
@@ -161,6 +161,9 @@ fn additive_blend_color(a: &Color, b: &Color, w: f32) -> Color {
 pub trait Blend: Sized {
     fn requires_weight_slot() -> bool;
 
+    // TODO: `bit_mask` and `slot` can be grouped into a `PropertyBlendInfo` struct
+    // TODO: `weight` and `additive` can be grouped into a `LayerBlendInfo` struct
+    #[allow(clippy::too_many_arguments)]
     fn blend(
         &mut self,
         entity_index: usize,
diff --git a/crates/bevy_animation/src/hierarchy.rs b/crates/bevy_animation/src/hierarchy.rs
index e1273295349f0..d11bd6e71c20a 100644
--- a/crates/bevy_animation/src/hierarchy.rs
+++ b/crates/bevy_animation/src/hierarchy.rs
@@ -60,9 +60,9 @@ impl<I: Index> Hierarchy<I> {
         children.resize_with(entities.len(), || smallvec![]);
 
         for (entity_index, (parent_index, _)) in entities.iter().enumerate() {
-            children
-                .get_mut(parent_index.as_usize())
-                .map(|c| c.push(I::from_usize_checked(entity_index)));
+            if let Some(c) = children.get_mut(parent_index.as_usize()) {
+                c.push(I::from_usize_checked(entity_index));
+            }
         }
 
         Self { entities, children }
@@ -125,6 +125,11 @@ impl<I: Index> Hierarchy<I> {
         self.entities.len()
     }
 
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
     /// Iterates over each entity parent index, name and children indexes
     #[inline]
     pub fn iter(&self) -> impl Iterator<Item = (&(I, Name), &[I])> {
diff --git a/crates/bevy_animation/src/interpolate/interpolate.rs b/crates/bevy_animation/src/interpolation/interpolate.rs
similarity index 99%
rename from crates/bevy_animation/src/interpolate/interpolate.rs
rename to crates/bevy_animation/src/interpolation/interpolate.rs
index a87adb714b42b..554dd8b75c15f 100644
--- a/crates/bevy_animation/src/interpolate/interpolate.rs
+++ b/crates/bevy_animation/src/interpolation/interpolate.rs
@@ -45,9 +45,9 @@ impl Interpolate for bool {
     fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
         let _ = interp;
         if t > 0.99 {
-            k0.clone()
+            *k0
         } else {
-            k1.clone()
+            *k1
         }
     }
 }
diff --git a/crates/bevy_animation/src/interpolate/lerp.rs b/crates/bevy_animation/src/interpolation/lerp.rs
similarity index 88%
rename from crates/bevy_animation/src/interpolate/lerp.rs
rename to crates/bevy_animation/src/interpolation/lerp.rs
index 9acf7d2ea92c4..1f528b8a5521b 100644
--- a/crates/bevy_animation/src/interpolate/lerp.rs
+++ b/crates/bevy_animation/src/interpolation/lerp.rs
@@ -16,9 +16,9 @@ impl Lerp for bool {
     #[inline]
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
         if t > 0.99 {
-            b.clone()
+            *b
         } else {
-            a.clone()
+            *a
         }
     }
 }
@@ -98,9 +98,9 @@ impl Lerp for Quat {
             b = -b;
         }
 
-        let q = Vec4::lerp((*a).into(), b.into(), t);
-        let d = inv_sqrt(q.dot(q));
-        (q * d).into()
+        let rot = Vec4::lerp((*a).into(), b.into(), t);
+        let inv_mag = inv_sqrt(rot.dot(rot));
+        (rot * inv_mag).into()
     }
 }
 
@@ -114,14 +114,14 @@ impl Lerp for Quatx4 {
         // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
         // Flip b sing if dot product was negative
         let sign: f32x4 = a.0.dot(b) & f32x4::splat(-0.0);
-        b.x = b.x ^ sign;
-        b.y = b.y ^ sign;
-        b.z = b.z ^ sign;
-        b.w = b.w ^ sign;
+        b.x ^= sign;
+        b.y ^= sign;
+        b.z ^= sign;
+        b.w ^= sign;
 
-        let q = Vec4x4::lerp(&a.0, &b, t);
-        let d = inv_sqrt4(q.dot(q));
-        Quatx4(q * d)
+        let rot = Vec4x4::lerp(&a.0, &b, t);
+        let inv_mag = inv_sqrt4(rot.dot(rot));
+        Quatx4(rot * inv_mag)
     }
 }
 
@@ -135,14 +135,14 @@ impl Lerp for Quatx8 {
         // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
         // Flip b sing if dot product was negative
         let sign: f32x8 = a.0.dot(b) & f32x8::splat(-0.0);
-        b.x = b.x ^ sign;
-        b.y = b.y ^ sign;
-        b.z = b.z ^ sign;
-        b.w = b.w ^ sign;
-
-        let q = Vec4x8::lerp(&a.0, &b, t);
-        let d = inv_sqrt8(q.dot(q));
-        Quatx8(q * d)
+        b.x ^= sign;
+        b.y ^= sign;
+        b.z ^= sign;
+        b.w ^= sign;
+
+        let rot = Vec4x8::lerp(&a.0, &b, t);
+        let inv_mag = inv_sqrt8(rot.dot(rot));
+        Quatx8(rot * inv_mag)
     }
 }
 
diff --git a/crates/bevy_animation/src/interpolate/mod.rs b/crates/bevy_animation/src/interpolation/mod.rs
similarity index 100%
rename from crates/bevy_animation/src/interpolate/mod.rs
rename to crates/bevy_animation/src/interpolation/mod.rs
diff --git a/crates/bevy_animation/src/interpolate/utils.rs b/crates/bevy_animation/src/interpolation/utils.rs
similarity index 98%
rename from crates/bevy_animation/src/interpolate/utils.rs
rename to crates/bevy_animation/src/interpolation/utils.rs
index e6f1e97699742..578d9cce44e29 100644
--- a/crates/bevy_animation/src/interpolate/utils.rs
+++ b/crates/bevy_animation/src/interpolation/utils.rs
@@ -45,7 +45,7 @@ pub fn inv_sqrt(x: f32) -> f32 {
 
     let mut i: i32 = y.to_bits() as i32;
     i = 0x5f3759df - (i >> 1);
-    y = unsafe { std::mem::transmute(i) };
+    y = f32::from_bits(i as u32);
 
     y = y * (1.5 - (x2 * y * y));
     y
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index ad6a4eaae354f..34616e688de47 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -13,7 +13,7 @@ mod hierarchy;
 mod skinned_mesh;
 
 pub mod blending;
-pub mod interpolate;
+pub mod interpolation;
 pub mod tracks;
 
 pub use crate::{
@@ -27,7 +27,7 @@ pub mod prelude {
         app::AddAnimated,
         blending::AnimatorBlending,
         hierarchy::Hierarchy,
-        interpolate::Lerp,
+        interpolation::Lerp,
         reflect::AnimatorPropertyRegistry,
         skinned_mesh::{SkinAsset, SkinComponent, SkinDebugger},
     };
@@ -35,14 +35,14 @@ pub mod prelude {
 
 /// Exports wide types
 pub mod wide {
-    pub use crate::interpolate::utils::{Quatx4, Quatx8};
+    pub use crate::interpolation::utils::{Quatx4, Quatx8};
     pub use ultraviolet::vec::{Vec2x4, Vec2x8, Vec3x4, Vec3x8, Vec4x4, Vec4x8};
     pub use wide::*;
 }
 
 pub mod stage {
-    pub const ANIMATE: &'static str = "animate";
-    pub const SKINNING: &'static str = "skinning";
+    pub const ANIMATE: &str = "animate";
+    pub const SKINNING: &str = "skinning";
     pub use bevy_app::stage::{POST_UPDATE, UPDATE};
 }
 
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index db5801354cf2e..d609bbbdd9feb 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -18,7 +18,7 @@ use crate::{
     animator::{Animator, Clip},
     blending::{AnimatorBlendGroup, AnimatorBlending, Blend, Mask, MASK_LIMIT},
     help::shorten_name,
-    interpolate::Lerp,
+    interpolation::Lerp,
 };
 
 // ? NOTE: Generic types like `Option<T>` must be specialized and registered with `register_animated_property_type`
@@ -70,12 +70,7 @@ impl Default for AnimatorPropertyRegistry {
 impl AnimatorPropertyRegistry {
     pub fn register<T: Lerp + Blend + Clone + 'static>(&mut self) {
         let ty = TypeId::of::<T>();
-        if self
-            .animate_functions
-            .iter()
-            .position(|(other, _)| *other == ty)
-            .is_some()
-        {
+        if self.animate_functions.iter().any(|(other, _)| *other == ty) {
             panic!("type '{}' already registered", type_name::<T>());
         }
 
@@ -105,6 +100,7 @@ impl AnimatorPropertyRegistry {
 
 /// Use need to guarantee that `Property` is valid and is owned by same type
 /// of object returned by `get_mut` function
+#[allow(clippy::too_many_arguments)]
 unsafe fn animate<T>(
     get_mut: &mut dyn FnMut(usize) -> Option<*mut u8>,
     entities_map: &[u16],
@@ -149,7 +145,7 @@ unsafe fn animate<T>(
         }
 
         // Handle N lane tracks
-        if tracks_n.len() > 0 {
+        if !tracks_n.is_empty() {
             let assign = &mut |output_lane: u16, v: T| {
                 let entity_index = entities_map[output_lane as usize] as usize;
                 if let Some(component) = (get_mut)(entity_index) {
@@ -531,7 +527,7 @@ pub(crate) fn animate_asset_system<T: Asset>(
 
                     // Handle N lane tracks
                     // ? NOTE: Currently Handle<T> isn't supported but still be implemented where
-                    if tracks_n.len() > 0 {
+                    if !tracks_n.is_empty() {
                         let assign = &mut |output_lane: u16, v: Handle<T>| {
                             let entity_index = entities_map[output_lane as usize] as usize;
                             if let Some(ref mut component) = cached_components[entity_index] {
@@ -560,7 +556,7 @@ pub(crate) fn animate_asset_system<T: Asset>(
         // ? NOTE Only after all asset handles had been settled that, the assets properties can be animated
         // Animate asset properties
 
-        if descriptor.dynamic_properties.len() == 0 {
+        if descriptor.dynamic_properties.is_empty() {
             // This assets have no animated properties
             continue;
         }
diff --git a/crates/bevy_animation/src/skinned_mesh.rs b/crates/bevy_animation/src/skinned_mesh.rs
index 6800938653978..d17f37acced2f 100644
--- a/crates/bevy_animation/src/skinned_mesh.rs
+++ b/crates/bevy_animation/src/skinned_mesh.rs
@@ -143,13 +143,14 @@ pub(crate) fn skinning_setup(
 
 // ? NOTE: You can check the follow link, for more details
 // ? https://github.com/KhronosGroup/glTF-Tutorials/blob/master/gltfTutorial/gltfTutorial_020_Skins.md
+#[allow(clippy::too_many_arguments)]
 pub(crate) fn skinning_update(
     commands: &mut Commands,
     skin_assets: Res<Assets<SkinAsset>>,
     mut skin_instances: ResMut<Assets<SkinInstance>>,
     mut binds_query: Query<(&Handle<SkinAsset>, &mut SkinComponent, &Children)>,
-    mut children_query: Query<&Children>,
-    mut name_query: Query<(&Parent, &Name)>,
+    children_query: Query<&Children>,
+    name_query: Query<(&Parent, &Name)>,
     transforms_query: Query<&GlobalTransform>,
     mut renderers_query: Query<&mut RenderPipelines>,
 ) {
@@ -177,8 +178,8 @@ pub(crate) fn skinning_update(
                 skin_asset.hierarchy.find_entity(
                     entity_index as u16,
                     &mut skin_bind.joint_entities,
-                    &mut children_query,
-                    &mut name_query,
+                    &children_query,
+                    &name_query,
                 );
             }
 
diff --git a/crates/bevy_animation/src/tracks/fixed.rs b/crates/bevy_animation/src/tracks/fixed.rs
index 786669aced286..18f15cce51fb0 100644
--- a/crates/bevy_animation/src/tracks/fixed.rs
+++ b/crates/bevy_animation/src/tracks/fixed.rs
@@ -1,4 +1,4 @@
-use crate::{interpolate::Lerp, tracks::Track};
+use crate::{interpolation::Lerp, tracks::Track};
 
 // TODO: impl Serialize, Deserialize
 /// Fixed frame rate track
@@ -24,13 +24,11 @@ impl<T: Clone> Clone for TrackFixed<T> {
 
 impl<T> TrackFixed<T> {
     pub fn from_keyframes(frame_rate: f32, offset: isize, keyframes: Vec<T>) -> Self {
-        let curve = Self {
+        Self {
             frame_rate,
             negative_offset: -(offset as f32),
             keyframes,
-        };
-
-        curve
+        }
     }
 
     pub fn from_constant(v: T) -> Self {
@@ -52,10 +50,16 @@ impl<T> TrackFixed<T> {
     //assert!(samples.len() > 1, "curve can't be empty");
     // }
 
+    /// Number of keyframes
     pub const fn len(&self) -> usize {
         self.frame_rate as usize
     }
 
+    /// True when doesn't have any keyframe
+    pub const fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
     pub fn frame_rate(&self) -> usize {
         self.keyframes.len()
     }
@@ -85,7 +89,7 @@ where
 
     fn sample(&self, time: f32) -> Self::Output {
         // Make sure to have at least one sample
-        assert!(self.keyframes.len() > 0, "track is empty");
+        assert!(!self.keyframes.is_empty(), "track is empty");
 
         let t = time.mul_add(self.frame_rate, self.negative_offset);
         if t.is_sign_negative() {
diff --git a/crates/bevy_animation/src/tracks/n.rs b/crates/bevy_animation/src/tracks/n.rs
index 86d1610d2844f..4a17bea8fc894 100644
--- a/crates/bevy_animation/src/tracks/n.rs
+++ b/crates/bevy_animation/src/tracks/n.rs
@@ -5,7 +5,7 @@ use bevy_math::prelude::*;
 // use bevy_render::prelude::Color;
 
 use crate::{
-    interpolate::Lerp,
+    interpolation::Lerp,
     tracks::{Track, TrackFixed},
     wide::*,
 };
@@ -79,6 +79,12 @@ pub trait TrackN {
     /// Number of used outputs, may be N or less
     fn len(&self) -> usize;
 
+    /// True when doesn't output anything
+    #[inline]
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
     /// N
     fn size(&self) -> usize;
 }
diff --git a/crates/bevy_animation/src/tracks/variable.rs b/crates/bevy_animation/src/tracks/variable.rs
index 44b546ed7d010..3fd293f71a526 100644
--- a/crates/bevy_animation/src/tracks/variable.rs
+++ b/crates/bevy_animation/src/tracks/variable.rs
@@ -1,5 +1,5 @@
 use crate::{
-    interpolate::{Interpolate, Interpolation},
+    interpolation::{Interpolate, Interpolation},
     tracks::Track,
 };
 
@@ -164,7 +164,11 @@ where
         let i = cursor - 1;
         let previous_time = self.time_stamps[i as usize];
         let t = (time - previous_time) / (self.time_stamps[cursor as usize] - previous_time);
-        debug_assert!(t >= 0.0 && t <= 1.0, "t = {} but should be normalized", t); // Checks if it's required to normalize t
+        debug_assert!(
+            (0.0..=1.0).contains(&t),
+            "t = {} but should be normalized",
+            t
+        ); // Checks if it's required to normalize t
 
         let value = T::interpolate(
             &self.keyframes[i as usize],
diff --git a/crates/bevy_animation/src/tracks/variable_linear.rs b/crates/bevy_animation/src/tracks/variable_linear.rs
index ca8384aa2b967..1c4225f1fcb8b 100644
--- a/crates/bevy_animation/src/tracks/variable_linear.rs
+++ b/crates/bevy_animation/src/tracks/variable_linear.rs
@@ -1,5 +1,5 @@
 use super::Track;
-use crate::interpolate::Lerp;
+use crate::interpolation::Lerp;
 
 // TODO: Curve/Clip need a validation during deserialization because they are
 // structured as SOA (struct of arrays), so the vec's length must match
@@ -36,7 +36,7 @@ impl<T> TrackVariableLinear<T> {
             u16::MAX
         );
 
-        assert!(samples.len() > 0, "empty curve");
+        assert!(!samples.is_empty(), "empty curve");
 
         // Make sure the
         assert!(
@@ -46,6 +46,7 @@ impl<T> TrackVariableLinear<T> {
                 .all(|(a, b)| a < b),
             "time samples must be on ascending order"
         );
+
         Self {
             time_stamps: samples,
             keyframes: values,
@@ -147,7 +148,11 @@ where
         let i = cursor - 1;
         let previous_time = self.time_stamps[i as usize];
         let t = (time - previous_time) / (self.time_stamps[cursor as usize] - previous_time);
-        debug_assert!(t >= 0.0 && t <= 1.0, "t = {} but should be normalized", t); // Checks if it's required to normalize t
+        debug_assert!(
+            (0.0..=1.0).contains(&t),
+            "t = {} but should be normalized",
+            t
+        ); // Checks if it's required to normalize t
         let value = T::lerp(
             &self.keyframes[i as usize],
             &self.keyframes[cursor as usize],
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 2cab5ea9c4808..562d26ba76056 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -303,7 +303,6 @@ async fn load_gltf<'a, 'b>(
         }
 
         let mut clip = Clip::default();
-        clip.warp = true; // Enable warping by default
 
         let mut start_time = f32::MAX;
 
@@ -342,7 +341,7 @@ async fn load_gltf<'a, 'b>(
 
             match reader.read_outputs().unwrap() {
                 ReadOutputs::Translations(values) => {
-                    let values = values.map(|v| Vec3::from(v)).collect::<Vec<_>>();
+                    let values = values.map(Vec3::from).collect::<Vec<_>>();
                     property_path += "@Transform.translation";
                     clip_curves_translation_and_scale
                         .push((property_path, TrackVariableLinear::new(time_stamps, values)));
@@ -350,13 +349,13 @@ async fn load_gltf<'a, 'b>(
                     // TODO: This is a runtime importer so here's no place for further optimizations
                 }
                 ReadOutputs::Rotations(values) => {
-                    let values = values.into_f32().map(|v| Quat::from(v)).collect::<Vec<_>>();
+                    let values = values.into_f32().map(Quat::from).collect::<Vec<_>>();
                     property_path += "@Transform.rotation";
                     clip_curves_rotation
                         .push((property_path, TrackVariableLinear::new(time_stamps, values)));
                 }
                 ReadOutputs::Scales(values) => {
-                    let values = values.map(|v| Vec3::from(v)).collect::<Vec<_>>();
+                    let values = values.map(Vec3::from).collect::<Vec<_>>();
 
                     property_path += "@Transform.scale";
                     clip_curves_translation_and_scale
@@ -381,6 +380,8 @@ async fn load_gltf<'a, 'b>(
             clip.add_track_at_path(&property_path, curve);
         }
 
+        // TODO: Should I use a linear curve fit algorithm to estimate a good sample rate
+        // (probably not, 30 fps is the default sampling rate for many export programs)
         clip.pack(30.0);
 
         load_context.set_labeled_asset(&anim_label, LoadedAsset::new(clip));
diff --git a/examples/animations/mesh_swap_animation.rs b/examples/animations/mesh_swap_animation.rs
index b2e4833ab2b8e..442a0a5721d9d 100644
--- a/examples/animations/mesh_swap_animation.rs
+++ b/examples/animations/mesh_swap_animation.rs
@@ -29,7 +29,7 @@ fn setup(
         "@Handle<Mesh>",
         TrackVariableLinear::new(
             vec![0.0, 0.5, 1.0],
-            vec![cube.clone(), sphere.clone(), cube.clone()],
+            vec![cube.clone(), sphere, cube.clone()],
         ),
     );
     let clip_handle = clips.add(clip);
@@ -40,7 +40,7 @@ fn setup(
 
     commands
         .spawn(PbrBundle {
-            mesh: cube.clone(),
+            mesh: cube,
             transform: Transform::from_translation(Vec3::new(0.0, 0.0, 0.0)),
             material: materials.add(Color::ANTIQUE_WHITE.into()),
             ..Default::default()
diff --git a/examples/animations/run_animation.rs b/examples/animations/run_animation.rs
index f534c4c178309..41442a1b1d3e5 100644
--- a/examples/animations/run_animation.rs
+++ b/examples/animations/run_animation.rs
@@ -44,7 +44,7 @@ fn setup(
 fn anim_set(asset_server: Res<AssetServer>, mut animators_query: Query<(&mut Animator,)>) {
     // Load animations and set them to the animator
     for (mut animator,) in animators_query.iter_mut() {
-        if animator.clips().len() == 0 {
+        if animator.clips().is_empty() {
             animator.add_layer(
                 asset_server.load("models/character_medium/idle.gltf#Anim0"),
                 1.0,
@@ -82,10 +82,8 @@ fn anim_blending(
             if w >= (1.0 - 1e-2) {
                 ping_pong.pong = false;
             }
-        } else {
-            if w <= 1e-2 {
-                ping_pong.pong = true;
-            }
+        } else if w <= 1e-2 {
+            ping_pong.pong = true;
         }
 
         animator.layers[0].weight = w; // Idle animation layer

From 8cc5580f3c41de432f2813632e8f2497cdc98abe Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Thu, 4 Mar 2021 20:50:41 -0300
Subject: [PATCH 105/153] port to CoreStage

---
 crates/bevy_animation/src/lib.rs | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index 34616e688de47..fd47cb1a8c303 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -43,7 +43,6 @@ pub mod wide {
 pub mod stage {
     pub const ANIMATE: &str = "animate";
     pub const SKINNING: &str = "skinning";
-    pub use bevy_app::stage::{POST_UPDATE, UPDATE};
 }
 
 use bevy_ecs::ParallelSystemDescriptorCoercion;
@@ -61,8 +60,12 @@ impl Default for AnimationPlugin {
 
 impl Plugin for AnimationPlugin {
     fn build(&self, app: &mut AppBuilder) {
-        app.add_stage_after(stage::UPDATE, stage::ANIMATE, SystemStage::parallel());
-        app.add_stage_after(stage::POST_UPDATE, stage::SKINNING, SystemStage::parallel());
+        app.add_stage_after(CoreStage::Update, stage::ANIMATE, SystemStage::parallel());
+        app.add_stage_after(
+            CoreStage::PostUpdate,
+            stage::SKINNING,
+            SystemStage::parallel(),
+        );
 
         // Generic animation
         app.insert_resource(animator::AnimatorRegistry::default())

From db5bf87115b84b972027439477ed27cb52608232 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Mon, 5 Apr 2021 19:38:05 -0300
Subject: [PATCH 106/153] update skinning vert shader

---
 crates/bevy_animation/src/forward_skinned.vert | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_animation/src/forward_skinned.vert b/crates/bevy_animation/src/forward_skinned.vert
index 8c4d88f22cfa6..30200bff624ab 100644
--- a/crates/bevy_animation/src/forward_skinned.vert
+++ b/crates/bevy_animation/src/forward_skinned.vert
@@ -3,8 +3,8 @@
 layout(location = 0) in vec3 Vertex_Position;
 layout(location = 1) in vec3 Vertex_Normal;
 layout(location = 2) in vec2 Vertex_Uv;
-layout(location = 3) in vec4 Vertex_Weight;
-layout(location = 4) in uvec4 Vertex_Join;
+layout(location = 3) in vec4 Vertex_JointWeight;
+layout(location = 4) in uvec4 Vertex_JointIndex;
 
 layout(location = 0) out vec3 v_Position;
 layout(location = 1) out vec3 v_Normal;
@@ -19,10 +19,10 @@ layout(set = 2, binding = 0) buffer SkinInstance_joint_matrices {
 };
 
 void main() {
-    mat4 Mat = Vertex_Weight.x * Joints[Vertex_Join.x]
-        + Vertex_Weight.y * Joints[Vertex_Join.y]
-        + Vertex_Weight.z * Joints[Vertex_Join.z]
-        + Vertex_Weight.w * Joints[Vertex_Join.w];
+    mat4 Mat = Vertex_JointWeight.x * Joints[Vertex_JointIndex.x]
+        + Vertex_JointWeight.y * Joints[Vertex_JointIndex.y]
+        + Vertex_JointWeight.z * Joints[Vertex_JointIndex.z]
+        + Vertex_JointWeight.w * Joints[Vertex_JointIndex.w];
 
     v_Normal = (Mat * vec4(Vertex_Normal, 1.0)).xyz;
     v_Normal = mat3(Mat) * Vertex_Normal;

From 511c8bedca702c32dd7a130fcf4904dc94e17a63 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Mon, 5 Apr 2021 20:31:33 -0300
Subject: [PATCH 107/153] named hierachy

---
 crates/bevy_transform/Cargo.toml              |   1 +
 .../hierarchy/{hierarchy.rs => commands.rs}   |   0
 crates/bevy_transform/src/hierarchy/mod.rs    |   7 +-
 .../src/hierarchy/named_hierarchy.rs          | 505 ++++++++++++++++++
 4 files changed, 510 insertions(+), 3 deletions(-)
 rename crates/bevy_transform/src/hierarchy/{hierarchy.rs => commands.rs} (100%)
 create mode 100644 crates/bevy_transform/src/hierarchy/named_hierarchy.rs

diff --git a/crates/bevy_transform/Cargo.toml b/crates/bevy_transform/Cargo.toml
index 3f1584991cc69..2de5f26956bb6 100644
--- a/crates/bevy_transform/Cargo.toml
+++ b/crates/bevy_transform/Cargo.toml
@@ -14,6 +14,7 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
+bevy_core = { path = "../bevy_core", version = "0.4.0" }
 bevy_app = { path = "../bevy_app", version = "0.4.0" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
 bevy_math = { path = "../bevy_math", version = "0.4.0" }
diff --git a/crates/bevy_transform/src/hierarchy/hierarchy.rs b/crates/bevy_transform/src/hierarchy/commands.rs
similarity index 100%
rename from crates/bevy_transform/src/hierarchy/hierarchy.rs
rename to crates/bevy_transform/src/hierarchy/commands.rs
diff --git a/crates/bevy_transform/src/hierarchy/mod.rs b/crates/bevy_transform/src/hierarchy/mod.rs
index 23e9108e2dec2..987df329db7dc 100644
--- a/crates/bevy_transform/src/hierarchy/mod.rs
+++ b/crates/bevy_transform/src/hierarchy/mod.rs
@@ -1,8 +1,9 @@
 mod child_builder;
-#[allow(clippy::module_inception)]
-mod hierarchy;
+mod commands;
 mod hierarchy_maintenance_system;
+mod named_hierarchy;
 
 pub use child_builder::*;
-pub use hierarchy::*;
+pub use commands::*;
 pub use hierarchy_maintenance_system::*;
+pub use named_hierarchy::*;
diff --git a/crates/bevy_transform/src/hierarchy/named_hierarchy.rs b/crates/bevy_transform/src/hierarchy/named_hierarchy.rs
new file mode 100644
index 0000000000000..f2962a8c46738
--- /dev/null
+++ b/crates/bevy_transform/src/hierarchy/named_hierarchy.rs
@@ -0,0 +1,505 @@
+use bevy_core::Name;
+use bevy_ecs::prelude::*;
+//use serde::{Deserialize, Serialize};
+use private::*;
+use smallvec::{smallvec, SmallVec};
+
+use crate::{Children, Parent};
+
+// TODO: Panic if the root entity is not defined prior to a query
+// TODO: Create a simplified version without the children ?!
+// TODO: Should I just use usize? and get done with it?
+
+/// Provides a way of describing a hierarchy or named entities
+/// and means for finding then in the world
+///
+/// By default and to save memory the nodes are indexed using `u16`
+/// but you can change it when needed.
+#[derive(Debug, Clone)]
+pub struct NamedHierarchy<I: Index = u16> {
+    /// Entity identification made by parent index and name
+    entities: Vec<(I, Name)>,
+    // ? NOTE: SmallVec<[u16; 10]> occupy the same 32 bytes as the SmallVec<[u16; 8]>, but the latter
+    // ? should be only take 24 bytes using the "union" feature
+    children: Vec<SmallVec<[I; 10]>>,
+}
+
+impl<I: Index> Default for NamedHierarchy<I> {
+    fn default() -> Self {
+        Self {
+            // ? NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
+            entities: vec![(I::MAX_VALUE, Name::default())],
+            children: vec![smallvec![]],
+        }
+    }
+}
+
+impl<I: Index> NamedHierarchy<I> {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Used when the hierarchy must be in a specific order,
+    /// this function takes an vec of entities defined by their parent index
+    /// (on the same vec) and name.
+    ///
+    /// Any root entity should be indexed using `I::MAX_VALUE` or `I::MAX`.
+    ///
+    /// Many different root nodes are supported although having other roots
+    /// make hard to search entities, please refer to the documentation of
+    /// `find_entity` or `find_entity_in_world` to see how.
+    ///
+    /// **WARNING** Be caution when using this function because it may create a
+    /// an invalid hierarchy
+    pub fn from_ordered_entities(entities: Vec<(I, Name)>) -> Self {
+        assert_eq!(
+            entities[0].0,
+            I::MAX_VALUE,
+            "first entry must be an root entity"
+        );
+
+        let mut children = vec![];
+        children.resize_with(entities.len(), || smallvec![]);
+
+        for (entity_index, (parent_index, _)) in entities.iter().enumerate() {
+            if let Some(c) = children.get_mut(parent_index.as_usize()) {
+                c.push(I::from_usize_checked(entity_index));
+            }
+        }
+
+        Self { entities, children }
+    }
+
+    /// Merge other hierarchy into this one, it will collect the
+    /// new entities indexes of merged hierarchy.
+    pub fn merge(&mut self, other_hierarchy: &NamedHierarchy<I>, mapped_entities: &mut Vec<I>) {
+        mapped_entities.clear();
+        mapped_entities.resize(other_hierarchy.len(), I::MAX_VALUE);
+
+        assert!(
+            other_hierarchy.entities[0].0 == I::MAX_VALUE,
+            "first element isn't the root"
+        );
+
+        let root_index = I::from_usize(0);
+        mapped_entities[0] = root_index;
+
+        // At this point they coincide
+        self.internal_merge(other_hierarchy, root_index, root_index, mapped_entities);
+    }
+
+    // TODO: Expose to allow for merging hierarchies with multiple roots
+    fn internal_merge(
+        &mut self,
+        other_hierarchy: &NamedHierarchy<I>,
+        other_parent_index: I,
+        parent_index: I,
+        mapped_entities: &mut Vec<I>,
+    ) {
+        for other_index in &other_hierarchy.children[other_parent_index.as_usize()] {
+            let (_, other_name) = &other_hierarchy.entities[other_index.as_usize()];
+            let child = (&parent_index, other_name);
+
+            let entity_index =
+                if let Some(i) = self.entities.iter().position(|(i, n)| (i, n) == child) {
+                    let entity_index = I::from_usize(i);
+                    // Found corresponding entity
+                    mapped_entities[other_index.as_usize()] = entity_index;
+                    entity_index
+                } else {
+                    // Add entity
+                    // Soft limit added to save memory, identical to the curve limit
+                    let entity_index = I::from_usize_checked(self.entities.len());
+                    self.entities.push((parent_index, other_name.clone()));
+                    self.children.push(smallvec![]);
+                    self.children[parent_index.as_usize()].push(entity_index);
+                    mapped_entities[other_index.as_usize()] = entity_index;
+                    entity_index
+                };
+
+            self.internal_merge(other_hierarchy, *other_index, entity_index, mapped_entities);
+        }
+    }
+
+    /// Number of entities registered.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.entities.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Iterates over each entity parent index, name and children indexes
+    #[inline]
+    pub fn iter(&self) -> impl Iterator<Item = (&(I, Name), &[I])> {
+        self.entities
+            .iter()
+            .zip(self.children.iter().map(|c| &c[..]))
+    }
+
+    /// Gets the entity parent index and `Name` components
+    #[inline]
+    pub fn get_entity(&self, entity_index: I) -> &(I, Name) {
+        &self.entities[entity_index.as_usize()]
+    }
+
+    pub fn depth_first<F: FnMut(I, &Name)>(&self, entity_index: I, visitor: &mut F) {
+        let i = entity_index.as_usize();
+        let (_, name) = &self.entities[i];
+
+        visitor(entity_index, name);
+
+        for child_index in &self.children[i] {
+            self.depth_first(*child_index, visitor);
+        }
+    }
+
+    /// Adds a new entity hierarchy path separated by backslashes (`'/'`)
+    /// return the entity index and if was or not inserted
+    pub fn get_or_insert_entity(&mut self, entity_path: &str) -> (I, bool) {
+        let mut entity_created = false;
+        let mut entity = I::from_usize(0); // Start search from root
+        for name in entity_path.split('/') {
+            // Ignore the first '/' or '///'
+            if name.is_empty() {
+                continue;
+            }
+
+            if let Some(e) = self
+                .entities
+                .iter()
+                .position(|(p, n)| (*p, n.as_str()) == (entity, name))
+            {
+                // Found entity
+                // ? NOTE: Conversion will never panic because the collection
+                // ? size will only increase in the else branch where a
+                // ? safe cast is performed
+                entity = I::from_usize(e);
+            } else {
+                // Add entity
+                let e = self.entities.len();
+                self.entities.push((entity, Name::new(name.to_string())));
+                self.children.push(smallvec![]);
+                entity_created = true;
+                // Soft limit added to save memory, identical to the curve limit
+                let _parent = entity;
+                entity = I::from_usize_checked(e);
+                self.children[_parent.as_usize()].push(entity)
+            }
+        }
+
+        (entity, entity_created)
+    }
+
+    /// Returns the entity path if found.
+    ///
+    /// The `NamedHierarchy` stores a the entity path in a specific way to improve search performance
+    /// thus it needs to rebuilt in the human readable format
+    pub fn get_entity_path_at(&self, mut entity_index: I) -> Option<String> {
+        let mut path = None;
+
+        while let Some((parent_index, name)) = self.entities.get(entity_index.as_usize()) {
+            if let Some(path) = path.as_mut() {
+                *path = format!("{}/{}", name.as_str(), path);
+            } else {
+                path = Some(name.as_str().to_string());
+            }
+
+            entity_index = *parent_index;
+        }
+
+        path
+    }
+
+    /// Finds an entity given a set of queries, see the example bellow
+    /// how to proper call this function,
+    ///
+    /// ```rust,ignore
+    /// let mut entities_table_cache = vec![];
+    /// entities_table_cache.resize(named_hierarchy.len(), None);
+    /// // Assign the root entity as the first element
+    /// entities_table_cache[0] = Some(root);
+    ///
+    /// let found_entity = named_hierarchy.find_entity(2, &mut entities_table_cache, &children_query, &name_query);
+    /// ```
+    ///
+    /// *NOTE* Keep in mind that you can have as many root as you want
+    /// but each root must be manually find and inserted in the `entities_table_cache`
+    /// before calling this function.
+    pub fn find_entity(
+        &self,
+        entity_index: I,
+        entities_table_cache: &mut Vec<Option<Entity>>,
+        children_query: &Query<&Children>,
+        name_query: &Query<(&Parent, &Name)>,
+    ) -> Option<Entity> {
+        if let Some(entity) = &entities_table_cache[entity_index.as_usize()] {
+            Some(*entity)
+        } else {
+            let (parent_index, entity_name) = &self.entities[entity_index.as_usize()];
+
+            // Use recursion to find the entity parent
+            self.find_entity(
+                *parent_index,
+                entities_table_cache,
+                children_query,
+                name_query,
+            )
+            .and_then(|parent_entity| {
+                if let Ok(children) = children_query.get(parent_entity) {
+                    children
+                        .iter()
+                        .find(|entity| {
+                            if let Ok((current_parent, name)) = name_query.get(**entity) {
+                                // ! FIXME: Parent changes before the children update it self,
+                                // ! to account for that we also must double check entity parent component it self
+                                if current_parent.0 != parent_entity || name != entity_name {
+                                    return false;
+                                }
+
+                                // Update cache
+                                entities_table_cache[entity_index.as_usize()] = Some(**entity);
+                                true
+                            } else {
+                                false
+                            }
+                        })
+                        .copied()
+                } else {
+                    None
+                }
+            })
+        }
+    }
+
+    /// Finds an entity given a reference to the (`World`)[bevy_ecs::World], see the example bellow
+    /// how to proper call this function,
+    ///
+    /// ```rust,ignore
+    /// let mut entities_table_cache = vec![];
+    /// entities_table_cache.resize(named_hierarchy.len(), None);
+    /// // Assign the root entity as the first element
+    /// entities_table_cache[0] = Some(root);
+    ///
+    /// let found_entity = named_hierarchy.find_entity_in_world(2, &mut entities_table_cache, &world);
+    /// ```
+    ///
+    /// *NOTE* Keep in mind that you can have as many root as you want
+    /// but each root must be manually find and inserted in the `entities_table_cache`
+    /// before calling this function.
+    pub fn find_entity_in_world(
+        &self,
+        entity_index: I,
+        entities_table_cache: &mut Vec<Option<Entity>>,
+        world: &World,
+    ) -> Option<Entity> {
+        if let Some(entity) = &entities_table_cache[entity_index.as_usize()] {
+            Some(*entity)
+        } else {
+            let (parent_index, entity_name) = &self.entities[entity_index.as_usize()];
+
+            // Use recursion to find the entity parent
+            self.find_entity_in_world(*parent_index, entities_table_cache, world)
+                .and_then(|parent_entity| {
+                    if let Some(children) = world.get::<Children>(parent_entity) {
+                        children
+                            .iter()
+                            .find(|entity| {
+                                if let Some(entity_ref) = world.get_entity(**entity) {
+                                    let current_parent = entity_ref.get::<Parent>();
+                                    let name = entity_ref.get::<Name>();
+
+                                    // ! FIXME: Parent changes before the children update it self,
+                                    // ! to account for that we also must double check entity parent component it self
+                                    if current_parent != Some(&Parent(parent_entity))
+                                        || name != Some(entity_name)
+                                    {
+                                        return false;
+                                    }
+
+                                    // Update cache
+                                    entities_table_cache[entity_index.as_usize()] = Some(**entity);
+                                    true
+                                } else {
+                                    false
+                                }
+                            })
+                            .copied()
+                    } else {
+                        None
+                    }
+                })
+        }
+    }
+}
+
+mod private {
+    use std::{
+        convert::TryFrom,
+        fmt::{Debug, Display},
+    };
+
+    /// Implemented by unsigned types
+    pub trait Index: Sized + PartialEq + Copy + Clone + Debug + Display {
+        const MAX_VALUE: Self;
+
+        fn as_usize(&self) -> usize;
+        fn from_usize(index: usize) -> Self;
+        fn from_usize_checked(index: usize) -> Self;
+    }
+
+    macro_rules! impl_index {
+        ($t:ty) => {
+            impl Index for $t {
+                const MAX_VALUE: $t = <$t>::MAX;
+
+                fn as_usize(&self) -> usize {
+                    *self as usize
+                }
+
+                fn from_usize(index: usize) -> Self {
+                    index as Self
+                }
+
+                fn from_usize_checked(index: usize) -> Self {
+                    Self::try_from(index).expect(concat!(
+                        "entities limit reached, indexed with ",
+                        stringify!($t)
+                    ))
+                }
+            }
+        };
+    }
+
+    impl_index!(u8);
+    impl_index!(u16);
+    impl_index!(u32);
+    impl_index!(u64);
+    impl_index!(usize);
+}
+
+#[cfg(test)]
+mod tests {
+    use bevy_ecs::{
+        schedule::{Schedule, Stage, SystemStage},
+        system::{CommandQueue, IntoSystem},
+        world::World,
+    };
+
+    use super::*;
+    use crate::{
+        hierarchy::{parent_update_system, BuildChildren},
+        transform_propagate_system::transform_propagate_system,
+    };
+
+    #[test]
+    fn find_entities_in_world() {
+        let mut world = World::default();
+
+        let mut update_stage = SystemStage::parallel();
+        update_stage.add_system(parent_update_system.system());
+        update_stage.add_system(transform_propagate_system.system());
+
+        let mut schedule = Schedule::default();
+        schedule.add_stage("update", update_stage);
+
+        // Add parent entities
+        let mut command_queue = CommandQueue::default();
+        let mut commands = Commands::new(&mut command_queue, &world);
+
+        let mut entities = Vec::new();
+
+        let root = commands.spawn().insert(Name::new("root")).id();
+        entities.push(root);
+
+        commands.entity(root).with_children(|parent| {
+            entities.push(parent.spawn().insert(Name::new("entity_1")).id());
+            entities.push(parent.spawn().insert(Name::new("entity_2")).id());
+        });
+
+        commands.entity(entities[1]).with_children(|parent| {
+            entities.push(parent.spawn().insert(Name::new("entity_3")).id());
+        });
+
+        command_queue.apply(&mut world);
+        schedule.run(&mut world);
+
+        let hierarchy = NamedHierarchy::from_ordered_entities(vec![
+            (u16::MAX_VALUE, Name::new("root")),
+            (0, Name::new("entity_1")),
+            (0, Name::new("entity_2")),
+            (1, Name::new("entity_3")),
+        ]);
+
+        let mut entities_table_cache = vec![];
+        entities_table_cache.resize(hierarchy.len(), None);
+
+        // ? NOTE: The root entity must be know prior the search
+        entities_table_cache[0] = Some(root);
+
+        for (i, entity) in entities.iter().enumerate().skip(1) {
+            let found = hierarchy.find_entity_in_world(i as u16, &mut entities_table_cache, &world);
+            assert_eq!(Some(*entity), found);
+        }
+    }
+
+    #[test]
+    fn merge_different_hierarchies() {
+        let mut hierarchy_a = NamedHierarchy::<u16>::new();
+        hierarchy_a.get_or_insert_entity("/NodeA0/NodeB0");
+        hierarchy_a.get_or_insert_entity("/NodeA1/NodeB1/NodeC0");
+        hierarchy_a.get_or_insert_entity("/NodeA2/NodeB1/NodeC1");
+
+        let mut hierarchy_b = NamedHierarchy::<u16>::new();
+        hierarchy_b.get_or_insert_entity("/NodeA1/NodeB2/NodeC2");
+        hierarchy_b.get_or_insert_entity("/NodeA1/NodeB0/NodeC3");
+
+        let mut mapped_entities = vec![];
+        hierarchy_a.merge(&hierarchy_b, &mut mapped_entities);
+
+        assert!(
+            mapped_entities.iter().all(|index| *index < u16::MAX),
+            "some entities weren't mapped or merged"
+        );
+
+        for i in 0..hierarchy_b.len() {
+            assert_eq!(
+                hierarchy_a.get_entity_path_at(mapped_entities[i]),
+                hierarchy_b.get_entity_path_at(i as u16)
+            );
+        }
+    }
+
+    #[test]
+    fn merge_equal_but_scrambled_hierarchies() {
+        let mut hierarchy_a = NamedHierarchy::<u16>::new();
+        hierarchy_a.get_or_insert_entity("/NodeA0/NodeB0");
+        hierarchy_a.get_or_insert_entity("/NodeA1/NodeB1/NodeC0");
+        hierarchy_a.get_or_insert_entity("/NodeA2/NodeB1/NodeC1");
+        hierarchy_a.get_or_insert_entity("/NodeA1/NodeB0/NodeC3");
+
+        let mut hierarchy_b = NamedHierarchy::<u16>::new();
+        hierarchy_b.get_or_insert_entity("/NodeA2/NodeB1/NodeC1");
+        hierarchy_b.get_or_insert_entity("/NodeA1/NodeB0/NodeC3");
+        hierarchy_b.get_or_insert_entity("/NodeA1/NodeB1/NodeC0");
+        hierarchy_b.get_or_insert_entity("/NodeA0/NodeB0");
+
+        let mut mapped_entities = vec![];
+        hierarchy_a.merge(&hierarchy_b, &mut mapped_entities);
+
+        assert!(
+            mapped_entities.iter().all(|index| *index < u16::MAX),
+            "some entities weren't mapped or merged"
+        );
+
+        for i in 0..hierarchy_b.len() {
+            assert_eq!(
+                hierarchy_a.get_entity_path_at(mapped_entities[i]),
+                hierarchy_b.get_entity_path_at(i as u16)
+            );
+        }
+    }
+}

From b9566b7cac80783cc07c8aa81882207583b4c4d8 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Mon, 5 Apr 2021 23:04:24 -0300
Subject: [PATCH 108/153] clippy fix

---
 .../bevy_transform/src/hierarchy/named_hierarchy.rs  | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_transform/src/hierarchy/named_hierarchy.rs b/crates/bevy_transform/src/hierarchy/named_hierarchy.rs
index f2962a8c46738..ab6cdae977fde 100644
--- a/crates/bevy_transform/src/hierarchy/named_hierarchy.rs
+++ b/crates/bevy_transform/src/hierarchy/named_hierarchy.rs
@@ -465,10 +465,10 @@ mod tests {
             "some entities weren't mapped or merged"
         );
 
-        for i in 0..hierarchy_b.len() {
+        for (index, mapped_index) in mapped_entities.iter().copied().enumerate() {
             assert_eq!(
-                hierarchy_a.get_entity_path_at(mapped_entities[i]),
-                hierarchy_b.get_entity_path_at(i as u16)
+                hierarchy_a.get_entity_path_at(mapped_index),
+                hierarchy_b.get_entity_path_at(index as u16)
             );
         }
     }
@@ -495,10 +495,10 @@ mod tests {
             "some entities weren't mapped or merged"
         );
 
-        for i in 0..hierarchy_b.len() {
+        for (index, mapped_index) in mapped_entities.iter().copied().enumerate() {
             assert_eq!(
-                hierarchy_a.get_entity_path_at(mapped_entities[i]),
-                hierarchy_b.get_entity_path_at(i as u16)
+                hierarchy_a.get_entity_path_at(mapped_index),
+                hierarchy_b.get_entity_path_at(index as u16)
             );
         }
     }

From 3e92132c54b189307522c067a1e82dda6a8aa3d9 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Mon, 5 Apr 2021 23:29:02 -0300
Subject: [PATCH 109/153] mesh vertex attributes for skinning and animation

---
 crates/bevy_render/src/mesh/mesh.rs | 23 +++++++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_render/src/mesh/mesh.rs b/crates/bevy_render/src/mesh/mesh.rs
index aece08891876f..d006e279a50ee 100644
--- a/crates/bevy_render/src/mesh/mesh.rs
+++ b/crates/bevy_render/src/mesh/mesh.rs
@@ -12,7 +12,7 @@ use bevy_ecs::{
     world::Mut,
 };
 use bevy_math::*;
-use bevy_reflect::TypeUuid;
+use bevy_reflect::{Reflect, TypeUuid};
 use std::borrow::Cow;
 
 use crate::pipeline::{InputStepMode, VertexAttribute, VertexBufferLayout};
@@ -37,6 +37,7 @@ pub enum VertexAttributeValues {
     Int4(Vec<[i32; 4]>),
     Uint4(Vec<[u32; 4]>),
     Uchar4Norm(Vec<[u8; 4]>),
+    Ushort4(Vec<[u16; 4]>),
 }
 
 impl VertexAttributeValues {
@@ -57,6 +58,7 @@ impl VertexAttributeValues {
             VertexAttributeValues::Int4(ref values) => values.len(),
             VertexAttributeValues::Uint4(ref values) => values.len(),
             VertexAttributeValues::Uchar4Norm(ref values) => values.len(),
+            VertexAttributeValues::Ushort4(ref values) => values.len(),
         }
     }
 
@@ -83,6 +85,7 @@ impl VertexAttributeValues {
             VertexAttributeValues::Int4(values) => values.as_slice().as_bytes(),
             VertexAttributeValues::Uint4(values) => values.as_slice().as_bytes(),
             VertexAttributeValues::Uchar4Norm(values) => values.as_slice().as_bytes(),
+            VertexAttributeValues::Ushort4(values) => values.as_slice().as_bytes(),
         }
     }
 }
@@ -103,6 +106,7 @@ impl From<&VertexAttributeValues> for VertexFormat {
             VertexAttributeValues::Int4(_) => VertexFormat::Int4,
             VertexAttributeValues::Uint4(_) => VertexFormat::Uint4,
             VertexAttributeValues::Uchar4Norm(_) => VertexFormat::Uchar4Norm,
+            VertexAttributeValues::Ushort4(_) => VertexFormat::Ushort4,
         }
     }
 }
@@ -204,16 +208,26 @@ impl From<&Indices> for IndexFormat {
 }
 
 // TODO: allow values to be unloaded after been submitting to the GPU to conserve memory
-#[derive(Debug, TypeUuid, Clone)]
+#[derive(Debug, TypeUuid, Clone, Reflect)]
 #[uuid = "8ecbac0f-f545-4473-ad43-e1f4243af51e"]
 pub struct Mesh {
+    #[reflect(ignore)]
     primitive_topology: PrimitiveTopology,
     /// `bevy_utils::HashMap` with all defined vertex attributes (Positions, Normals, ...) for this
     /// mesh. Attribute name maps to attribute values.
+    #[reflect(ignore)]
     attributes: HashMap<Cow<'static, str>, VertexAttributeValues>,
+    #[reflect(ignore)]
     indices: Option<Indices>,
 }
 
+impl Default for Mesh {
+    /// Creates a empty triangle list mesh
+    fn default() -> Self {
+        Mesh::new(PrimitiveTopology::TriangleList)
+    }
+}
+
 /// Contains geometry in the form of a mesh.
 ///
 /// Often meshes are automatically generated by bevy's asset loaders or primitives, such as
@@ -245,6 +259,11 @@ impl Mesh {
     /// Texture coordinates for the vertex. Use in conjunction with [`Mesh::set_attribute`]
     pub const ATTRIBUTE_UV_0: &'static str = "Vertex_Uv";
 
+    /// Per vertex joint transform matrix weight. Use in conjunction with [`Mesh::set_attribute`]
+    pub const ATTRIBUTE_WEIGHT: &'static str = "Vertex_JointWeight";
+    /// Per vertex joint transform matrix index. Use in conjunction with [`Mesh::set_attribute`]
+    pub const ATTRIBUTE_JOINT: &'static str = "Vertex_JointIndex";
+
     /// Construct a new mesh. You need to provide a PrimitiveTopology so that the
     /// renderer knows how to treat the vertex data. Most of the time this will be
     /// `PrimitiveTopology::TriangleList`.

From 202ed1d389ed6e13bd61dc43915a41486fc0afbe Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Mon, 5 Apr 2021 23:32:50 -0300
Subject: [PATCH 110/153] better attributes names

---
 crates/bevy_render/src/mesh/mesh.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_render/src/mesh/mesh.rs b/crates/bevy_render/src/mesh/mesh.rs
index d006e279a50ee..04cc106180359 100644
--- a/crates/bevy_render/src/mesh/mesh.rs
+++ b/crates/bevy_render/src/mesh/mesh.rs
@@ -260,9 +260,9 @@ impl Mesh {
     pub const ATTRIBUTE_UV_0: &'static str = "Vertex_Uv";
 
     /// Per vertex joint transform matrix weight. Use in conjunction with [`Mesh::set_attribute`]
-    pub const ATTRIBUTE_WEIGHT: &'static str = "Vertex_JointWeight";
+    pub const ATTRIBUTE_JOINT_WEIGHT: &'static str = "Vertex_JointWeight";
     /// Per vertex joint transform matrix index. Use in conjunction with [`Mesh::set_attribute`]
-    pub const ATTRIBUTE_JOINT: &'static str = "Vertex_JointIndex";
+    pub const ATTRIBUTE_JOINT_INDEX: &'static str = "Vertex_JointIndex";
 
     /// Construct a new mesh. You need to provide a PrimitiveTopology so that the
     /// renderer knows how to treat the vertex data. Most of the time this will be

From 3c3eaca219b8ddc4df3ee4babeee294383303276 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Mon, 5 Apr 2021 23:51:35 -0300
Subject: [PATCH 111/153] curves and lerp

---
 crates/bevy_math/src/curves/fixed.rs          | 120 ++++++++++
 crates/bevy_math/src/curves/mod.rs            |  30 +++
 crates/bevy_math/src/curves/variable.rs       | 223 ++++++++++++++++++
 .../bevy_math/src/curves/variable_linear.rs   | 205 ++++++++++++++++
 .../src/interpolation/interpolate.rs          | 156 ++++++++++++
 crates/bevy_math/src/interpolation/lerp.rs    | 107 +++++++++
 crates/bevy_math/src/interpolation/mod.rs     |   6 +
 crates/bevy_math/src/interpolation/utils.rs   |  62 +++++
 crates/bevy_math/src/lib.rs                   |   3 +
 9 files changed, 912 insertions(+)
 create mode 100644 crates/bevy_math/src/curves/fixed.rs
 create mode 100644 crates/bevy_math/src/curves/mod.rs
 create mode 100644 crates/bevy_math/src/curves/variable.rs
 create mode 100644 crates/bevy_math/src/curves/variable_linear.rs
 create mode 100644 crates/bevy_math/src/interpolation/interpolate.rs
 create mode 100644 crates/bevy_math/src/interpolation/lerp.rs
 create mode 100644 crates/bevy_math/src/interpolation/mod.rs
 create mode 100644 crates/bevy_math/src/interpolation/utils.rs

diff --git a/crates/bevy_math/src/curves/fixed.rs b/crates/bevy_math/src/curves/fixed.rs
new file mode 100644
index 0000000000000..0b1e3dd11689c
--- /dev/null
+++ b/crates/bevy_math/src/curves/fixed.rs
@@ -0,0 +1,120 @@
+use crate::{curves::Curve, interpolation::Lerp};
+
+// TODO: impl Serialize, Deserialize
+/// Fixed frame rate curve, each keyframe is evenly spaced
+#[derive(Default, Debug)]
+pub struct CurveFixed<T> {
+    // ? NOTE: Has I learned from benches casting to f32 is quite expensive
+    // ? so frame rate and offset values must be stored as f32
+    frame_rate: f32,
+    /// Negative number of frames before the curve starts
+    negative_offset: f32,
+    keyframes: Vec<T>,
+}
+
+impl<T: Clone> Clone for CurveFixed<T> {
+    fn clone(&self) -> Self {
+        Self {
+            frame_rate: self.frame_rate,
+            negative_offset: self.negative_offset,
+            keyframes: self.keyframes.clone(),
+        }
+    }
+}
+
+impl<T> CurveFixed<T> {
+    pub fn from_keyframes(frame_rate: f32, offset: isize, keyframes: Vec<T>) -> Self {
+        Self {
+            frame_rate,
+            negative_offset: -(offset as f32),
+            keyframes,
+        }
+    }
+
+    pub fn from_constant(v: T) -> Self {
+        Self {
+            frame_rate: 30.0,
+            negative_offset: 0.0,
+            keyframes: vec![v],
+        }
+    }
+
+    pub fn keyframes_mut(&mut self) -> &mut [T] {
+        &mut self.keyframes[..]
+    }
+
+    // pub fn insert(&mut self, time_sample: f32, value: T) {
+    // }
+
+    // pub fn remove(&mut self, index: usize) {
+    //assert!(samples.len() > 1, "curve can't be empty");
+    // }
+
+    /// Number of keyframes
+    pub fn len(&self) -> usize {
+        self.keyframes.len()
+    }
+
+    /// True when doesn't have any keyframe
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub const fn frame_rate(&self) -> usize {
+        self.frame_rate as usize
+    }
+
+    pub fn offset(&self) -> isize {
+        (-self.negative_offset) as isize
+    }
+
+    // pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
+    //     self.samples.iter().copied().zip(self.keyframes.iter())
+    // }
+
+    // pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
+    //     self.samples.iter().copied().zip(self.keyframes.iter_mut())
+    // }
+}
+
+impl<T> Curve for CurveFixed<T>
+where
+    T: Lerp + Clone,
+{
+    type Output = T;
+
+    fn duration(&self) -> f32 {
+        ((self.keyframes.len() as f32 - 1.0 - self.negative_offset) / self.frame_rate).max(0.0)
+    }
+
+    fn sample(&self, time: f32) -> Self::Output {
+        // Make sure to have at least one sample
+        assert!(!self.keyframes.is_empty(), "track is empty");
+
+        let t = time.mul_add(self.frame_rate, self.negative_offset);
+        if t.is_sign_negative() {
+            // Underflow clamp
+            return self.keyframes[0].clone();
+        }
+
+        let f = t.trunc();
+        let t = t - f;
+
+        let f = f as usize;
+        let f_n = self.keyframes.len() - 1;
+        if f >= f_n {
+            // Overflow clamp
+            return self.keyframes[f_n].clone();
+        }
+
+        // Lerp the value
+        T::lerp(&self.keyframes[f], &self.keyframes[f + 1], t)
+    }
+
+    /// Same as `sample` function
+    #[inline]
+    fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, Self::Output) {
+        let _ = cursor;
+        (0, self.sample(time))
+    }
+}
diff --git a/crates/bevy_math/src/curves/mod.rs b/crates/bevy_math/src/curves/mod.rs
new file mode 100644
index 0000000000000..faf342eaa19ec
--- /dev/null
+++ b/crates/bevy_math/src/curves/mod.rs
@@ -0,0 +1,30 @@
+//! The bread and butter of the animation system tracks are the source of
+//! data at given state and comes in 3 different flavours: [`CurveFixed`], [`CurveVariantLinear`]  
+//! and [`CurveVariant`];
+
+mod fixed;
+mod variable;
+mod variable_linear;
+
+pub use fixed::*;
+pub use variable::*;
+pub use variable_linear::*;
+
+pub trait Curve {
+    type Output;
+
+    fn duration(&self) -> f32;
+
+    /// Easer to use sampling method that don't have time restrictions or needs
+    /// the keyframe cursor, but is more expensive always `O(n)`. Which means
+    /// sampling takes longer to evaluate as much as time get closer to curve duration
+    /// and it get worse with more keyframes.
+    fn sample(&self, time: f32) -> Self::Output;
+
+    /// Samples the curve starting from some keyframe cursor, this make the common case `O(1)`
+    ///
+    /// **NOTE** Each keyframe is indexed by a `u16` to reduce memory usage when using the keyframe caching
+    fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, Self::Output);
+}
+
+pub type CurveBase<T> = Box<dyn Curve<Output = T> + Send + Sync + 'static>;
diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
new file mode 100644
index 0000000000000..43afdd2d7e5a7
--- /dev/null
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -0,0 +1,223 @@
+use crate::{
+    curves::Curve,
+    interpolation::{Interpolate, Interpolation},
+};
+
+// TODO: Curve/Clip need a validation during deserialization because they are
+// structured as SOA (struct of arrays), so the vec's length must match
+
+// https://github.com/niklasfrykholm/blog
+// https://bitsquid.blogspot.com/search?q=animation
+// http://bitsquid.blogspot.com/2009/11/bitsquid-low-level-animation-system.html
+// http://archive.gamedev.net/archive/reference/articles/article1497.html (bit old)
+
+// http://nfrechette.github.io/2016/12/07/anim_compression_key_reduction/
+// https://github.com/nfrechette/acl
+
+// TODO: impl Serialize, Deserialize
+#[derive(Default, Debug)]
+pub struct CurveVariable<T: Interpolate> {
+    time_stamps: Vec<f32>,
+    keyframes: Vec<T>,
+    /// Defines the interpolation for each keyframe pair
+    interpolations: Vec<Interpolation<T::Tangent>>,
+}
+
+impl<T> Clone for CurveVariable<T>
+where
+    T: Interpolate + Clone,
+    <T as Interpolate>::Tangent: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            time_stamps: self.time_stamps.clone(),
+            keyframes: self.keyframes.clone(),
+            interpolations: self.interpolations.clone(),
+        }
+    }
+}
+
+// impl<T> CurveVariableInterpolated<T> {
+//     pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
+//         // TODO: Result?
+
+//         // Make sure both have the same length
+//         assert!(
+//             samples.len() == values.len(),
+//             "samples and values must have the same length"
+//         );
+
+//         assert!(
+//             values.len() <= u16::MAX as usize,
+//             "limit of {} keyframes exceeded",
+//             u16::MAX
+//         );
+
+//         assert!(samples.len() > 0, "empty curve");
+
+//         // Make sure the
+//         assert!(
+//             samples
+//                 .iter()
+//                 .zip(samples.iter().skip(1))
+//                 .all(|(a, b)| a < b),
+//             "time samples must be on ascending order"
+//         );
+//         Self {
+//             time_stamps: samples,
+//             keyframes: values,
+//         }
+//     }
+
+//     pub fn from_line(t0: f32, t1: f32, v0: T, v1: T) -> Self {
+//         Self {
+//             time_stamps: if t1 >= t0 { vec![t0, t1] } else { vec![t1, t0] },
+//             keyframes: vec![v0, v1],
+//         }
+//     }
+
+//     pub fn from_constant(v: T) -> Self {
+//         Self {
+//             time_stamps: vec![0.0],
+//             keyframes: vec![v],
+//         }
+//     }
+
+//     // pub fn insert(&mut self, time_sample: f32, value: T) {
+//     // }
+
+//     // pub fn remove(&mut self, index: usize) {
+//     //assert!(samples.len() > 1, "curve can't be empty");
+//     // }
+
+//     pub fn add_offset_time(&mut self, time_offset: f32) {
+//         self.time_stamps.iter_mut().for_each(|t| *t += time_offset);
+//     }
+
+//     pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
+//         self.time_stamps.iter().copied().zip(self.keyframes.iter())
+//     }
+
+//     pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
+//         self.time_stamps
+//             .iter()
+//             .copied()
+//             .zip(self.keyframes.iter_mut())
+//     }
+// }
+
+impl<T> Curve for CurveVariable<T>
+where
+    T: Interpolate + Clone + 'static,
+{
+    type Output = T;
+
+    fn duration(&self) -> f32 {
+        self.time_stamps.last().copied().unwrap_or(0.0)
+    }
+
+    fn sample(&self, time: f32) -> Self::Output {
+        // Index guessing gives a small search optimization
+        let index = if time < self.duration() * 0.5 {
+            0
+        } else {
+            self.time_stamps.len() - 1
+        };
+
+        self.sample_with_cursor(index as u16, time).1
+    }
+
+    fn sample_with_cursor(&self, mut cursor: u16, time: f32) -> (u16, Self::Output) {
+        // Adjust for the current keyframe cursor
+        let last_cursor = (self.time_stamps.len() - 1) as u16;
+
+        cursor = cursor.max(0).min(last_cursor);
+        if self.time_stamps[cursor as usize] < time {
+            // Forward search
+            loop {
+                if cursor == last_cursor {
+                    return (last_cursor, self.keyframes[last_cursor as usize].clone());
+                }
+                cursor += 1;
+
+                if self.time_stamps[cursor as usize] >= time {
+                    break;
+                }
+            }
+        } else {
+            // Backward search
+            loop {
+                if cursor == 0 {
+                    return (0, self.keyframes[0].clone());
+                }
+
+                let i = cursor - 1;
+                if self.time_stamps[i as usize] <= time {
+                    break;
+                }
+
+                cursor = i;
+            }
+        }
+
+        // Lerp the value
+        let i = cursor - 1;
+        let previous_time = self.time_stamps[i as usize];
+        let t = (time - previous_time) / (self.time_stamps[cursor as usize] - previous_time);
+        debug_assert!(
+            (0.0..=1.0).contains(&t),
+            "t = {} but should be normalized",
+            t
+        ); // Checks if it's required to normalize t
+
+        let value = T::interpolate(
+            &self.keyframes[i as usize],
+            &self.keyframes[cursor as usize],
+            &self.interpolations[i as usize],
+            t,
+        );
+
+        (cursor, value)
+    }
+}
+
+// #[cfg(test)]
+// mod tests {
+//     use super::*;
+
+//     #[test]
+//     fn curve_evaluation() {
+//         let curve = CurveVariableInterpolated::new(
+//             vec![0.0, 0.25, 0.5, 0.75, 1.0],
+//             vec![0.0, 0.5, 1.0, 1.5, 2.0],
+//         );
+//         assert_eq!(curve.sample(0.5), 1.0);
+
+//         let mut i0 = 0;
+//         let mut e0 = 0.0;
+//         for v in &[0.1, 0.3, 0.7, 0.4, 0.2, 0.0, 0.4, 0.85, 1.0] {
+//             let v = *v;
+//             let (i1, e1) = curve.sample_indexed(i0, v);
+//             assert_eq!(e1, 2.0 * v);
+//             if e1 > e0 {
+//                 assert!(i1 >= i0);
+//             } else {
+//                 assert!(i1 <= i0);
+//             }
+//             e0 = e1;
+//             i0 = i1;
+//         }
+//     }
+
+//     #[test]
+//     #[should_panic]
+//     fn curve_bad_length() {
+//         let _ = CurveVariableInterpolated::new(vec![0.0, 0.5, 1.0], vec![0.0, 1.0]);
+//     }
+
+//     #[test]
+//     #[should_panic]
+//     fn curve_time_samples_not_sorted() {
+//         let _ = CurveVariableInterpolated::new(vec![0.0, 1.5, 1.0], vec![0.0, 1.0, 2.0]);
+//     }
+// }
diff --git a/crates/bevy_math/src/curves/variable_linear.rs b/crates/bevy_math/src/curves/variable_linear.rs
new file mode 100644
index 0000000000000..cb0bd944b420d
--- /dev/null
+++ b/crates/bevy_math/src/curves/variable_linear.rs
@@ -0,0 +1,205 @@
+use super::Curve;
+use crate::interpolation::Lerp;
+
+// TODO: Curve/Clip need a validation during deserialization because they are
+// structured as SOA (struct of arrays), so the vec's length must match
+
+// TODO: impl Serialize, Deserialize
+#[derive(Default, Debug)]
+pub struct CurveVariableLinear<T> {
+    time_stamps: Vec<f32>,
+    keyframes: Vec<T>,
+}
+
+impl<T: Clone> Clone for CurveVariableLinear<T> {
+    fn clone(&self) -> Self {
+        Self {
+            time_stamps: self.time_stamps.clone(),
+            keyframes: self.keyframes.clone(),
+        }
+    }
+}
+
+impl<T> CurveVariableLinear<T> {
+    pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
+        // TODO: Result?
+
+        // Make sure both have the same length
+        assert!(
+            samples.len() == values.len(),
+            "samples and values must have the same length"
+        );
+
+        assert!(
+            values.len() <= u16::MAX as usize,
+            "limit of {} keyframes exceeded",
+            u16::MAX
+        );
+
+        assert!(!samples.is_empty(), "empty curve");
+
+        // Make sure the
+        assert!(
+            samples
+                .iter()
+                .zip(samples.iter().skip(1))
+                .all(|(a, b)| a < b),
+            "time samples must be on ascending order"
+        );
+
+        Self {
+            time_stamps: samples,
+            keyframes: values,
+        }
+    }
+
+    pub fn from_line(t0: f32, t1: f32, v0: T, v1: T) -> Self {
+        Self {
+            time_stamps: if t1 >= t0 { vec![t0, t1] } else { vec![t1, t0] },
+            keyframes: vec![v0, v1],
+        }
+    }
+
+    pub fn from_constant(v: T) -> Self {
+        Self {
+            time_stamps: vec![0.0],
+            keyframes: vec![v],
+        }
+    }
+
+    // pub fn insert(&mut self, time_sample: f32, value: T) {
+    // }
+
+    // pub fn remove(&mut self, index: usize) {
+    //assert!(samples.len() > 1, "curve can't be empty");
+    // }
+
+    pub fn add_offset_time(&mut self, time_offset: f32) {
+        self.time_stamps.iter_mut().for_each(|t| *t += time_offset);
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
+        self.time_stamps.iter().copied().zip(self.keyframes.iter())
+    }
+
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
+        self.time_stamps
+            .iter()
+            .copied()
+            .zip(self.keyframes.iter_mut())
+    }
+}
+
+impl<T> Curve for CurveVariableLinear<T>
+where
+    T: Lerp + Clone + 'static,
+{
+    type Output = T;
+
+    fn duration(&self) -> f32 {
+        self.time_stamps.last().copied().unwrap_or(0.0)
+    }
+
+    fn sample(&self, time: f32) -> Self::Output {
+        // Index guessing gives a small search optimization
+        let index = if time < self.duration() * 0.5 {
+            0
+        } else {
+            self.time_stamps.len() - 1
+        };
+
+        self.sample_with_cursor(index as u16, time).1
+    }
+
+    fn sample_with_cursor(&self, mut cursor: u16, time: f32) -> (u16, Self::Output) {
+        // Adjust for the current keyframe index
+        let last_cursor = (self.time_stamps.len() - 1) as u16;
+
+        cursor = cursor.max(0).min(last_cursor);
+        if self.time_stamps[cursor as usize] < time {
+            // Forward search
+            loop {
+                if cursor == last_cursor {
+                    return (last_cursor, self.keyframes[last_cursor as usize].clone());
+                }
+                cursor += 1;
+
+                if self.time_stamps[cursor as usize] >= time {
+                    break;
+                }
+            }
+        } else {
+            // Backward search
+            loop {
+                if cursor == 0 {
+                    return (0, self.keyframes[0].clone());
+                }
+
+                let i = cursor - 1;
+                if self.time_stamps[i as usize] <= time {
+                    break;
+                }
+
+                cursor = i;
+            }
+        }
+
+        // Lerp the value
+        let i = cursor - 1;
+        let previous_time = self.time_stamps[i as usize];
+        let t = (time - previous_time) / (self.time_stamps[cursor as usize] - previous_time);
+        debug_assert!(
+            (0.0..=1.0).contains(&t),
+            "t = {} but should be normalized",
+            t
+        ); // Checks if it's required to normalize t
+        let value = T::lerp(
+            &self.keyframes[i as usize],
+            &self.keyframes[cursor as usize],
+            t,
+        );
+
+        (cursor, value)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn curve_evaluation() {
+        let curve = CurveVariableLinear::new(
+            vec![0.0, 0.25, 0.5, 0.75, 1.0],
+            vec![0.0, 0.5, 1.0, 1.5, 2.0],
+        );
+        assert_eq!(curve.sample(0.5), 1.0);
+
+        let mut i0 = 0;
+        let mut e0 = 0.0;
+        for v in &[0.1, 0.3, 0.7, 0.4, 0.2, 0.0, 0.4, 0.85, 1.0] {
+            let v = *v;
+            let (i1, e1) = curve.sample_with_cursor(i0, v);
+            assert_eq!(e1, 2.0 * v);
+            if e1 > e0 {
+                assert!(i1 >= i0);
+            } else {
+                assert!(i1 <= i0);
+            }
+            e0 = e1;
+            i0 = i1;
+        }
+    }
+
+    #[test]
+    #[should_panic]
+    fn curve_bad_length() {
+        let _ = CurveVariableLinear::new(vec![0.0, 0.5, 1.0], vec![0.0, 1.0]);
+    }
+
+    #[test]
+    #[should_panic]
+    fn curve_time_samples_not_sorted() {
+        let _ = CurveVariableLinear::new(vec![0.0, 1.5, 1.0], vec![0.0, 1.0, 2.0]);
+    }
+}
diff --git a/crates/bevy_math/src/interpolation/interpolate.rs b/crates/bevy_math/src/interpolation/interpolate.rs
new file mode 100644
index 0000000000000..44b34643e3a69
--- /dev/null
+++ b/crates/bevy_math/src/interpolation/interpolate.rs
@@ -0,0 +1,156 @@
+use crate::{interpolation::utils, Quat, Vec2, Vec3, Vec4};
+
+// http://archive.gamedev.net/archive/reference/articles/article1497.html (bit old)
+
+pub struct TangentIgnore;
+
+#[derive(Debug)]
+pub enum Interpolation<T> {
+    Step,
+    Linear,
+    /// Right tangent for the current keyframe and left tangent of the next keyframe
+    Smooth {
+        right: T,
+        left: T,
+    },
+}
+
+impl<T: Clone> Clone for Interpolation<T> {
+    fn clone(&self) -> Self {
+        match self {
+            Interpolation::Step => Interpolation::Step,
+            Interpolation::Linear => Interpolation::Linear,
+            Interpolation::Smooth { right, left } => Interpolation::Smooth {
+                right: right.clone(),
+                left: left.clone(),
+            },
+        }
+    }
+}
+
+pub trait Interpolate {
+    type Tangent;
+
+    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self;
+}
+
+impl Interpolate for bool {
+    type Tangent = TangentIgnore;
+
+    #[inline]
+    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
+        let _ = interp;
+        if t > 0.99 {
+            *k0
+        } else {
+            *k1
+        }
+    }
+}
+
+impl Interpolate for f32 {
+    type Tangent = Self;
+
+    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
+        match interp {
+            Interpolation::Step => utils::step(k0, k1, t),
+            Interpolation::Linear => utils::lerp(t * k0, *k1, t),
+            Interpolation::Smooth { right, left } => utils::catmull_rom(*k0, *right, *k1, *left, t),
+        }
+    }
+}
+
+impl Interpolate for Vec2 {
+    type Tangent = Self;
+
+    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
+        match interp {
+            Interpolation::Step => utils::step(k0, k1, t),
+            Interpolation::Linear => utils::lerp(*k0, *k1, t),
+            Interpolation::Smooth { right, left } => utils::catmull_rom(*k0, *right, *k1, *left, t),
+        }
+    }
+}
+
+impl Interpolate for Vec3 {
+    type Tangent = Self;
+
+    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
+        match interp {
+            Interpolation::Step => utils::step(k0, k1, t),
+            Interpolation::Linear => utils::lerp(*k0, *k1, t),
+            Interpolation::Smooth { right, left } => utils::catmull_rom(*k0, *right, *k1, *left, t),
+        }
+    }
+}
+
+impl Interpolate for Vec4 {
+    type Tangent = Self;
+
+    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
+        match interp {
+            Interpolation::Step => utils::step(k0, k1, t),
+            Interpolation::Linear => utils::lerp(*k0, *k1, t),
+            Interpolation::Smooth { right, left } => utils::catmull_rom(*k0, *right, *k1, *left, t),
+        }
+    }
+}
+
+// impl Interpolate for Color {
+//     type Tangent = Self;
+
+//     fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
+//         match interp {
+//             Interpolation::Step => utils::step(k0, k1, t),
+//             Interpolation::Linear => utils::lerp(*k0, *k1, t),
+//             Interpolation::Smooth { right, left } => utils::catmull_rom::<Vec4>(
+//                 (*k0).into(),
+//                 (*right).into(),
+//                 (*k1).into(),
+//                 (*left).into(),
+//                 t,
+//             )
+//             .into(),
+//         }
+//     }
+// }
+
+impl Interpolate for Quat {
+    type Tangent = Self;
+
+    /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
+    /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
+    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
+        match interp {
+            Interpolation::Step => utils::step(k0, k1, t),
+            Interpolation::Linear => {
+                // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
+                let mut k1 = *k1;
+                if k0.dot(k1) < 0.0 {
+                    k1 = -k1;
+                }
+
+                let q = utils::lerp::<Vec4>((*k0).into(), k1.into(), t);
+                let d = utils::inv_sqrt(q.dot(q));
+                (q * d).into()
+            }
+            Interpolation::Smooth { right, left } => {
+                // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
+                let mut k1 = *k1;
+                if k0.dot(k1) < 0.0 {
+                    k1 = -k1;
+                }
+
+                let q = utils::catmull_rom::<Vec4>(
+                    (*k0).into(),
+                    (*right).into(),
+                    k1.into(),
+                    (*left).into(),
+                    t,
+                );
+                let d = utils::inv_sqrt(q.dot(q));
+                (q * d).into()
+            }
+        }
+    }
+}
diff --git a/crates/bevy_math/src/interpolation/lerp.rs b/crates/bevy_math/src/interpolation/lerp.rs
new file mode 100644
index 0000000000000..ef7e98e97cb5a
--- /dev/null
+++ b/crates/bevy_math/src/interpolation/lerp.rs
@@ -0,0 +1,107 @@
+use crate::{interpolation::utils::*, Quat, Vec2, Vec3, Vec4};
+
+/// Defines how a particular type will be interpolated
+pub trait Lerp {
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self;
+}
+
+impl Lerp for bool {
+    #[inline]
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        if t > 0.99 {
+            *b
+        } else {
+            *a
+        }
+    }
+}
+
+impl Lerp for f32 {
+    #[inline]
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        (*a) * (1.0 - t) + (*b) * t
+    }
+}
+
+impl Lerp for Vec2 {
+    #[inline]
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        (*a) * (1.0 - t) + (*b) * t
+    }
+}
+
+impl Lerp for Vec3 {
+    #[inline]
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        (*a) * (1.0 - t) + (*b) * t
+    }
+}
+
+impl Lerp for Vec4 {
+    #[inline]
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        (*a) * (1.0 - t) + (*b) * t
+    }
+}
+
+// impl Lerp for Color {
+//     #[inline]
+//     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+//         (*a) * (1.0 - t) + (*b) * t
+//     }
+// }
+
+impl Lerp for Quat {
+    /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
+    /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
+    #[inline]
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        let mut b = *b;
+
+        // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
+        if a.dot(b) < 0.0 {
+            b = -b;
+        }
+
+        let rot = Vec4::lerp((*a).into(), b.into(), t);
+        let inv_mag = inv_sqrt(rot.dot(rot));
+        (rot * inv_mag).into()
+    }
+}
+
+// impl<T: Asset + 'static> Lerp for Handle<T> {
+//     #[inline]
+//     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+//         if t > 0.99 {
+//             b.clone()
+//         } else {
+//             a.clone()
+//         }
+//     }
+// }
+
+// impl Lerp for HandleUntyped {
+//     #[inline]
+//     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+//         if t > 0.99 {
+//             b.clone()
+//         } else {
+//             a.clone()
+//         }
+//     }
+// }
+
+impl<T: Lerp + Clone> Lerp for Option<T> {
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        match (a.is_some(), b.is_some()) {
+            (true, true) => Some(T::lerp(a.as_ref().unwrap(), b.as_ref().unwrap(), t)),
+            (false, true) | (true, false) | (false, false) => {
+                if t > 0.99 {
+                    b.clone()
+                } else {
+                    a.clone()
+                }
+            }
+        }
+    }
+}
diff --git a/crates/bevy_math/src/interpolation/mod.rs b/crates/bevy_math/src/interpolation/mod.rs
new file mode 100644
index 0000000000000..15525e32003ee
--- /dev/null
+++ b/crates/bevy_math/src/interpolation/mod.rs
@@ -0,0 +1,6 @@
+mod interpolate;
+mod lerp;
+pub mod utils;
+
+pub use interpolate::*;
+pub use lerp::*;
diff --git a/crates/bevy_math/src/interpolation/utils.rs b/crates/bevy_math/src/interpolation/utils.rs
new file mode 100644
index 0000000000000..1c240910e237c
--- /dev/null
+++ b/crates/bevy_math/src/interpolation/utils.rs
@@ -0,0 +1,62 @@
+use std::ops::{Add, Div, Mul, Sub};
+
+/// Quake 3 fast inverse sqrt
+///
+/// Took this one from piston: https://github.com/PistonDevelopers/skeletal_animation
+#[inline]
+pub fn inv_sqrt(x: f32) -> f32 {
+    let x2: f32 = x * 0.5;
+    let mut y: f32 = x;
+
+    let mut i: i32 = y.to_bits() as i32;
+    i = 0x5f3759df - (i >> 1);
+    y = f32::from_bits(i as u32);
+
+    y = y * (1.5 - (x2 * y * y));
+    y
+}
+
+#[inline]
+pub fn step<T: Clone>(k0: &T, k1: &T, u: f32) -> T {
+    if u > 0.99 {
+        k0.clone()
+    } else {
+        k1.clone()
+    }
+}
+
+#[inline]
+pub fn lerp<T>(k0: T, k1: T, u: f32) -> T
+where
+    T: Add<Output = T> + Mul<f32, Output = T>,
+{
+    k0 * (1.0 - u) + k1 * u
+}
+
+/// Catmull-Rom spline interpolation
+///
+/// Source: http://archive.gamedev.net/archive/reference/articles/article1497.html
+#[inline]
+pub fn catmull_rom<T>(k0: T, t0: T, k1: T, t1: T, u: f32) -> T
+where
+    T: Add<Output = T> + Sub<Output = T> + Mul<f32, Output = T>,
+{
+    let u2 = u * u;
+    let u3 = u2 * u;
+    let _3u2 = 3.0 * u2;
+    let _2u3 = 2.0 * u3;
+
+    k0 * (_2u3 - _3u2 + 1.0) + k1 * (_3u2 - _2u3) + t0 * (u3 - 2.0 * u2 + u) + t1 * (u3 - u2)
+}
+
+/// Finds the tangent gradients for the Catmull-Rom spline
+///
+/// Source: http://archive.gamedev.net/archive/reference/articles/article1497.html
+#[inline]
+pub fn auto_tangent<T>(t0: f32, t1: f32, t2: f32, k0: T, k1: T, k2: T) -> T
+where
+    T: Copy + Add<Output = T> + Sub<Output = T> + Mul<f32, Output = T> + Div<f32, Output = T>,
+{
+    // k'(t) = ½[k(t) - k(t-1)]/δx1 + ½[k(t+1) - k(t)]/δx2
+    ((k1 - k0) / (t1 - t0) + (k2 - k1) / (t2 - t1)) * 0.5
+}
diff --git a/crates/bevy_math/src/lib.rs b/crates/bevy_math/src/lib.rs
index f7315b35d50be..0672a7d2bbbbb 100644
--- a/crates/bevy_math/src/lib.rs
+++ b/crates/bevy_math/src/lib.rs
@@ -1,6 +1,9 @@
 mod face_toward;
 mod geometry;
 
+pub mod curves;
+pub mod interpolation;
+
 pub use face_toward::*;
 pub use geometry::*;
 pub use glam::*;

From 0202fc757550f0a3d2e751d90df83b41db1d5a13 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Tue, 6 Apr 2021 19:37:58 -0300
Subject: [PATCH 112/153] cleanup and NO_PARENT const

---
 .../src/hierarchy/named_hierarchy.rs          | 41 ++++++++++++-------
 1 file changed, 26 insertions(+), 15 deletions(-)

diff --git a/crates/bevy_transform/src/hierarchy/named_hierarchy.rs b/crates/bevy_transform/src/hierarchy/named_hierarchy.rs
index ab6cdae977fde..0e154dad85ef3 100644
--- a/crates/bevy_transform/src/hierarchy/named_hierarchy.rs
+++ b/crates/bevy_transform/src/hierarchy/named_hierarchy.rs
@@ -7,20 +7,18 @@ use smallvec::{smallvec, SmallVec};
 use crate::{Children, Parent};
 
 // TODO: Panic if the root entity is not defined prior to a query
-// TODO: Create a simplified version without the children ?!
-// TODO: Should I just use usize? and get done with it?
 
 /// Provides a way of describing a hierarchy or named entities
 /// and means for finding then in the world
 ///
-/// By default and to save memory the nodes are indexed using `u16`
-/// but you can change it when needed.
+/// By default and to save memory the nodes are indexed using [`u16`],
+/// but you can change to any unsigned type.
 #[derive(Debug, Clone)]
 pub struct NamedHierarchy<I: Index = u16> {
     /// Entity identification made by parent index and name
     entities: Vec<(I, Name)>,
     // ? NOTE: SmallVec<[u16; 10]> occupy the same 32 bytes as the SmallVec<[u16; 8]>, but the latter
-    // ? should be only take 24 bytes using the "union" feature
+    // ? should be only take 24 bytes (same as Vec<u16>) using the "union" feature
     children: Vec<SmallVec<[I; 10]>>,
 }
 
@@ -28,13 +26,16 @@ impl<I: Index> Default for NamedHierarchy<I> {
     fn default() -> Self {
         Self {
             // ? NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
-            entities: vec![(I::MAX_VALUE, Name::default())],
+            entities: vec![(Self::NO_PARENT, Name::default())],
             children: vec![smallvec![]],
         }
     }
 }
 
 impl<I: Index> NamedHierarchy<I> {
+    /// Defines the parent of a root entity
+    pub const NO_PARENT: I = I::MAX_VALUE;
+
     pub fn new() -> Self {
         Default::default()
     }
@@ -43,18 +44,25 @@ impl<I: Index> NamedHierarchy<I> {
     /// this function takes an vec of entities defined by their parent index
     /// (on the same vec) and name.
     ///
-    /// Any root entity should be indexed using `I::MAX_VALUE` or `I::MAX`.
+    /// Root entities should have a parent as [`NamedHierarchy::NO_PARENT`] or [`I::MAX_VALUE`].
+    ///
+    /// ```rust,ignore
+    /// NamedHierarchy::from_ordered_entities(vec![
+    ///     (NamedHierarchy::NO_PARENT, Name::new("root")),
+    ///     ...
+    /// ])
+    /// ```
     ///
     /// Many different root nodes are supported although having other roots
     /// make hard to search entities, please refer to the documentation of
-    /// `find_entity` or `find_entity_in_world` to see how.
+    /// [`find_entity`] or [`find_entity_in_world`] to see how.
     ///
     /// **WARNING** Be caution when using this function because it may create a
     /// an invalid hierarchy
     pub fn from_ordered_entities(entities: Vec<(I, Name)>) -> Self {
         assert_eq!(
             entities[0].0,
-            I::MAX_VALUE,
+            Self::NO_PARENT,
             "first entry must be an root entity"
         );
 
@@ -74,10 +82,10 @@ impl<I: Index> NamedHierarchy<I> {
     /// new entities indexes of merged hierarchy.
     pub fn merge(&mut self, other_hierarchy: &NamedHierarchy<I>, mapped_entities: &mut Vec<I>) {
         mapped_entities.clear();
-        mapped_entities.resize(other_hierarchy.len(), I::MAX_VALUE);
+        mapped_entities.resize(other_hierarchy.len(), Self::NO_PARENT);
 
         assert!(
-            other_hierarchy.entities[0].0 == I::MAX_VALUE,
+            other_hierarchy.entities[0].0 == Self::NO_PARENT,
             "first element isn't the root"
         );
 
@@ -88,7 +96,8 @@ impl<I: Index> NamedHierarchy<I> {
         self.internal_merge(other_hierarchy, root_index, root_index, mapped_entities);
     }
 
-    // TODO: Expose to allow for merging hierarchies with multiple roots
+    // TODO: Merging hierarchies with multiple roots
+
     fn internal_merge(
         &mut self,
         other_hierarchy: &NamedHierarchy<I>,
@@ -220,7 +229,7 @@ impl<I: Index> NamedHierarchy<I> {
     /// ```rust,ignore
     /// let mut entities_table_cache = vec![];
     /// entities_table_cache.resize(named_hierarchy.len(), None);
-    /// // Assign the root entity as the first element
+    /// // Assign the root entity as the first element (all roots if more than one must be assigned)
     /// entities_table_cache[0] = Some(root);
     ///
     /// let found_entity = named_hierarchy.find_entity(2, &mut entities_table_cache, &children_query, &name_query);
@@ -236,6 +245,7 @@ impl<I: Index> NamedHierarchy<I> {
         children_query: &Query<&Children>,
         name_query: &Query<(&Parent, &Name)>,
     ) -> Option<Entity> {
+        assert!(entity_index != Self::NO_PARENT, "root not assigned");
         if let Some(entity) = &entities_table_cache[entity_index.as_usize()] {
             Some(*entity)
         } else {
@@ -275,13 +285,13 @@ impl<I: Index> NamedHierarchy<I> {
         }
     }
 
-    /// Finds an entity given a reference to the (`World`)[bevy_ecs::World], see the example bellow
+    /// Finds an entity given a reference to the [`World`], see the example bellow
     /// how to proper call this function,
     ///
     /// ```rust,ignore
     /// let mut entities_table_cache = vec![];
     /// entities_table_cache.resize(named_hierarchy.len(), None);
-    /// // Assign the root entity as the first element
+    /// // Assign the root entity as the first element (all roots if more than one must be assigned)
     /// entities_table_cache[0] = Some(root);
     ///
     /// let found_entity = named_hierarchy.find_entity_in_world(2, &mut entities_table_cache, &world);
@@ -296,6 +306,7 @@ impl<I: Index> NamedHierarchy<I> {
         entities_table_cache: &mut Vec<Option<Entity>>,
         world: &World,
     ) -> Option<Entity> {
+        assert!(entity_index != Self::NO_PARENT, "root not assigned");
         if let Some(entity) = &entities_table_cache[entity_index.as_usize()] {
             Some(*entity)
         } else {

From acbab8adb941eedfd81e4968e857fb393a7c9198 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Tue, 6 Apr 2021 20:05:34 -0300
Subject: [PATCH 113/153] docs

---
 crates/bevy_math/src/curves/fixed.rs           | 5 ++++-
 crates/bevy_math/src/curves/mod.rs             | 6 ------
 crates/bevy_math/src/curves/variable.rs        | 7 +++++++
 crates/bevy_math/src/curves/variable_linear.rs | 5 +++++
 4 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_math/src/curves/fixed.rs b/crates/bevy_math/src/curves/fixed.rs
index 0b1e3dd11689c..2d306ce07c499 100644
--- a/crates/bevy_math/src/curves/fixed.rs
+++ b/crates/bevy_math/src/curves/fixed.rs
@@ -1,7 +1,10 @@
 use crate::{curves::Curve, interpolation::Lerp};
 
 // TODO: impl Serialize, Deserialize
-/// Fixed frame rate curve, each keyframe is evenly spaced
+/// Curve with evenly spaced keyframes, in another words a curve with a fixed frame rate.
+///
+/// This curve maintains the faster sampling rate over a wide range of frame rates, because
+/// it doesn't rely on keyframe cursor. But as a downside it will have the bigger memory foot print;
 #[derive(Default, Debug)]
 pub struct CurveFixed<T> {
     // ? NOTE: Has I learned from benches casting to f32 is quite expensive
diff --git a/crates/bevy_math/src/curves/mod.rs b/crates/bevy_math/src/curves/mod.rs
index faf342eaa19ec..b490fb0f8adc9 100644
--- a/crates/bevy_math/src/curves/mod.rs
+++ b/crates/bevy_math/src/curves/mod.rs
@@ -1,7 +1,3 @@
-//! The bread and butter of the animation system tracks are the source of
-//! data at given state and comes in 3 different flavours: [`CurveFixed`], [`CurveVariantLinear`]  
-//! and [`CurveVariant`];
-
 mod fixed;
 mod variable;
 mod variable_linear;
@@ -26,5 +22,3 @@ pub trait Curve {
     /// **NOTE** Each keyframe is indexed by a `u16` to reduce memory usage when using the keyframe caching
     fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, Self::Output);
 }
-
-pub type CurveBase<T> = Box<dyn Curve<Output = T> + Send + Sync + 'static>;
diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index 43afdd2d7e5a7..01a407803d7de 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -3,6 +3,8 @@ use crate::{
     interpolation::{Interpolate, Interpolation},
 };
 
+// TODO: Smooth interpolation are untested
+
 // TODO: Curve/Clip need a validation during deserialization because they are
 // structured as SOA (struct of arrays), so the vec's length must match
 
@@ -15,6 +17,11 @@ use crate::{
 // https://github.com/nfrechette/acl
 
 // TODO: impl Serialize, Deserialize
+/// Curve with sparse keyframes frames, in another words a curve with variable frame rate;
+///
+/// Similar in design to the [`CurveVariableLinear`](super::CurveVariableLinear) but allows
+/// for smoother catmull-rom interpolations using tangents, which can further reduce the number of keyframes at
+/// the cost of performance.
 #[derive(Default, Debug)]
 pub struct CurveVariable<T: Interpolate> {
     time_stamps: Vec<f32>,
diff --git a/crates/bevy_math/src/curves/variable_linear.rs b/crates/bevy_math/src/curves/variable_linear.rs
index cb0bd944b420d..cd34e78c9669e 100644
--- a/crates/bevy_math/src/curves/variable_linear.rs
+++ b/crates/bevy_math/src/curves/variable_linear.rs
@@ -5,6 +5,11 @@ use crate::interpolation::Lerp;
 // structured as SOA (struct of arrays), so the vec's length must match
 
 // TODO: impl Serialize, Deserialize
+/// Curve with sparse keyframes frames, in another words a curve with variable frame rate;
+///
+/// Very useful curve, because can accommodate the output of a linear reduction keyframe algorithm
+/// to lower the memory foot print. But as a down side require the use of keyframe cursor, and
+/// loses performance when the curve frame rate is higher than the curve sampling frame rate
 #[derive(Default, Debug)]
 pub struct CurveVariableLinear<T> {
     time_stamps: Vec<f32>,

From e18b222cbec3fbee39c831694fa5a921e4d218cf Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Wed, 7 Apr 2021 13:33:24 -0300
Subject: [PATCH 114/153] lerp unclamped, lerp handle, fix clippy errors

---
 crates/bevy_asset/Cargo.toml                  |  1 +
 crates/bevy_asset/src/handle.rs               | 15 +++++
 crates/bevy_math/src/curves/fixed.rs          |  2 +-
 .../bevy_math/src/curves/variable_linear.rs   |  6 +-
 crates/bevy_math/src/interpolation/lerp.rs    | 60 ++++++++-----------
 crates/bevy_math/src/interpolation/utils.rs   |  2 +-
 6 files changed, 47 insertions(+), 39 deletions(-)

diff --git a/crates/bevy_asset/Cargo.toml b/crates/bevy_asset/Cargo.toml
index 6abbe968c938f..c09ddaa56f1d5 100644
--- a/crates/bevy_asset/Cargo.toml
+++ b/crates/bevy_asset/Cargo.toml
@@ -25,6 +25,7 @@ bevy_log = { path = "../bevy_log", version = "0.5.0" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.5.0", features = ["bevy"] }
 bevy_tasks = { path = "../bevy_tasks", version = "0.5.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
+bevy_math = { path = "../bevy_math", version = "0.5.0" }
 
 # other
 serde = { version = "1", features = ["derive"] }
diff --git a/crates/bevy_asset/src/handle.rs b/crates/bevy_asset/src/handle.rs
index d02cfa71ea3bd..441a3c928358d 100644
--- a/crates/bevy_asset/src/handle.rs
+++ b/crates/bevy_asset/src/handle.rs
@@ -10,6 +10,7 @@ use crate::{
     Asset, Assets,
 };
 use bevy_ecs::reflect::ReflectComponent;
+use bevy_math::interpolation::{utils::step, Lerp};
 use bevy_reflect::{Reflect, ReflectDeserialize};
 use bevy_utils::Uuid;
 use crossbeam_channel::{Receiver, Sender};
@@ -233,6 +234,13 @@ impl<T: Asset> Clone for Handle<T> {
 unsafe impl<T: Asset> Send for Handle<T> {}
 unsafe impl<T: Asset> Sync for Handle<T> {}
 
+impl<T: Asset + 'static> Lerp for Handle<T> {
+    #[inline(always)]
+    fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {
+        step(a, b, t)
+    }
+}
+
 /// A non-generic version of [Handle]
 ///
 /// This allows handles to be mingled in a cross asset context. For example, storing `Handle<A>` and
@@ -340,6 +348,13 @@ impl Clone for HandleUntyped {
     }
 }
 
+impl Lerp for HandleUntyped {
+    #[inline(always)]
+    fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {
+        step(a, b, t)
+    }
+}
+
 pub(crate) enum RefChange {
     Increment(HandleId),
     Decrement(HandleId),
diff --git a/crates/bevy_math/src/curves/fixed.rs b/crates/bevy_math/src/curves/fixed.rs
index 2d306ce07c499..ac0249a1c765a 100644
--- a/crates/bevy_math/src/curves/fixed.rs
+++ b/crates/bevy_math/src/curves/fixed.rs
@@ -111,7 +111,7 @@ where
         }
 
         // Lerp the value
-        T::lerp(&self.keyframes[f], &self.keyframes[f + 1], t)
+        T::lerp_unclamped(&self.keyframes[f], &self.keyframes[f + 1], t)
     }
 
     /// Same as `sample` function
diff --git a/crates/bevy_math/src/curves/variable_linear.rs b/crates/bevy_math/src/curves/variable_linear.rs
index cd34e78c9669e..29d88c6ba7655 100644
--- a/crates/bevy_math/src/curves/variable_linear.rs
+++ b/crates/bevy_math/src/curves/variable_linear.rs
@@ -158,7 +158,7 @@ where
             "t = {} but should be normalized",
             t
         ); // Checks if it's required to normalize t
-        let value = T::lerp(
+        let value = T::lerp_unclamped(
             &self.keyframes[i as usize],
             &self.keyframes[cursor as usize],
             t,
@@ -178,14 +178,14 @@ mod tests {
             vec![0.0, 0.25, 0.5, 0.75, 1.0],
             vec![0.0, 0.5, 1.0, 1.5, 2.0],
         );
-        assert_eq!(curve.sample(0.5), 1.0);
+        assert!((curve.sample(0.5) - 1.0).abs() < f32::EPSILON);
 
         let mut i0 = 0;
         let mut e0 = 0.0;
         for v in &[0.1, 0.3, 0.7, 0.4, 0.2, 0.0, 0.4, 0.85, 1.0] {
             let v = *v;
             let (i1, e1) = curve.sample_with_cursor(i0, v);
-            assert_eq!(e1, 2.0 * v);
+            assert!((e1 - (2.0 * v)).abs() < f32::EPSILON);
             if e1 > e0 {
                 assert!(i1 >= i0);
             } else {
diff --git a/crates/bevy_math/src/interpolation/lerp.rs b/crates/bevy_math/src/interpolation/lerp.rs
index ef7e98e97cb5a..27ff8d6ffee51 100644
--- a/crates/bevy_math/src/interpolation/lerp.rs
+++ b/crates/bevy_math/src/interpolation/lerp.rs
@@ -1,13 +1,20 @@
 use crate::{interpolation::utils::*, Quat, Vec2, Vec3, Vec4};
 
 /// Defines how a particular type will be interpolated
-pub trait Lerp {
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self;
+pub trait Lerp: Sized {
+    /// Lerp, `t` is unclamped
+    fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self;
+
+    /// Lerp, `t` is clamped in [0; 1] range
+    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+        let t = t.min(1.0).max(0.0);
+        Self::lerp_unclamped(a, b, t)
+    }
 }
 
 impl Lerp for bool {
     #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+    fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {
         if t > 0.99 {
             *b
         } else {
@@ -18,35 +25,35 @@ impl Lerp for bool {
 
 impl Lerp for f32 {
     #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+    fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
 }
 
 impl Lerp for Vec2 {
     #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+    fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
 }
 
 impl Lerp for Vec3 {
     #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+    fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
 }
 
 impl Lerp for Vec4 {
     #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+    fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {
         (*a) * (1.0 - t) + (*b) * t
     }
 }
 
 // impl Lerp for Color {
 //     #[inline]
-//     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+//     fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {
 //         (*a) * (1.0 - t) + (*b) * t
 //     }
 // }
@@ -55,7 +62,7 @@ impl Lerp for Quat {
     /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
     /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
     #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+    fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {
         let mut b = *b;
 
         // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
@@ -63,38 +70,23 @@ impl Lerp for Quat {
             b = -b;
         }
 
-        let rot = Vec4::lerp((*a).into(), b.into(), t);
+        let a: Vec4 = (*a).into();
+        let b: Vec4 = b.into();
+
+        let rot = Vec4::lerp_unclamped(&a, &b, t);
         let inv_mag = inv_sqrt(rot.dot(rot));
         (rot * inv_mag).into()
     }
 }
 
-// impl<T: Asset + 'static> Lerp for Handle<T> {
-//     #[inline]
-//     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-//         if t > 0.99 {
-//             b.clone()
-//         } else {
-//             a.clone()
-//         }
-//     }
-// }
-
-// impl Lerp for HandleUntyped {
-//     #[inline]
-//     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-//         if t > 0.99 {
-//             b.clone()
-//         } else {
-//             a.clone()
-//         }
-//     }
-// }
-
 impl<T: Lerp + Clone> Lerp for Option<T> {
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
+    fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {
         match (a.is_some(), b.is_some()) {
-            (true, true) => Some(T::lerp(a.as_ref().unwrap(), b.as_ref().unwrap(), t)),
+            (true, true) => Some(T::lerp_unclamped(
+                a.as_ref().unwrap(),
+                b.as_ref().unwrap(),
+                t,
+            )),
             (false, true) | (true, false) | (false, false) => {
                 if t > 0.99 {
                     b.clone()
diff --git a/crates/bevy_math/src/interpolation/utils.rs b/crates/bevy_math/src/interpolation/utils.rs
index 1c240910e237c..078768ac03cfa 100644
--- a/crates/bevy_math/src/interpolation/utils.rs
+++ b/crates/bevy_math/src/interpolation/utils.rs
@@ -18,7 +18,7 @@ pub fn inv_sqrt(x: f32) -> f32 {
 
 #[inline]
 pub fn step<T: Clone>(k0: &T, k1: &T, u: f32) -> T {
-    if u > 0.99 {
+    if u > 0.999 {
         k0.clone()
     } else {
         k1.clone()

From 3fdaf9e741c19440b6b4b102cf0e86fdf7201dd4 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 11 Apr 2021 01:11:16 -0300
Subject: [PATCH 115/153] upgrate to 0.5, depend of pr's #1830 #1837 #1831

---
 crates/bevy_animation/Cargo.toml              |  25 +-
 crates/bevy_animation/src/animator.rs         | 283 +++--------
 crates/bevy_animation/src/app.rs              |  22 +-
 crates/bevy_animation/src/bench.rs            |  23 +-
 crates/bevy_animation/src/blending.rs         |  40 +-
 crates/bevy_animation/src/hierarchy.rs        | 441 ------------------
 .../src/interpolation/interpolate.rs          | 160 -------
 .../bevy_animation/src/interpolation/lerp.rs  | 198 --------
 .../bevy_animation/src/interpolation/mod.rs   |   6 -
 .../bevy_animation/src/interpolation/utils.rs | 125 -----
 crates/bevy_animation/src/lib.rs              |  60 +--
 crates/bevy_animation/src/reflect.rs          |  68 +--
 crates/bevy_animation/src/skinned_mesh.rs     |  52 ++-
 crates/bevy_animation/src/tracks/fixed.rs     | 120 -----
 crates/bevy_animation/src/tracks/mod.rs       |  37 --
 crates/bevy_animation/src/tracks/n.rs         | 231 ---------
 crates/bevy_animation/src/tracks/variable.rs  | 223 ---------
 .../src/tracks/variable_linear.rs             | 205 --------
 crates/bevy_gltf/Cargo.toml                   |   4 +-
 crates/bevy_gltf/src/loader.rs                | 150 +++---
 crates/bevy_render/src/mesh/mesh.rs           |   6 -
 examples/animations/material_animation.rs     |  38 +-
 examples/animations/mesh_swap_animation.rs    |  38 +-
 examples/animations/run_animation.rs          |  52 ++-
 24 files changed, 331 insertions(+), 2276 deletions(-)
 delete mode 100644 crates/bevy_animation/src/hierarchy.rs
 delete mode 100644 crates/bevy_animation/src/interpolation/interpolate.rs
 delete mode 100644 crates/bevy_animation/src/interpolation/lerp.rs
 delete mode 100644 crates/bevy_animation/src/interpolation/mod.rs
 delete mode 100644 crates/bevy_animation/src/interpolation/utils.rs
 delete mode 100644 crates/bevy_animation/src/tracks/fixed.rs
 delete mode 100644 crates/bevy_animation/src/tracks/mod.rs
 delete mode 100644 crates/bevy_animation/src/tracks/n.rs
 delete mode 100644 crates/bevy_animation/src/tracks/variable.rs
 delete mode 100644 crates/bevy_animation/src/tracks/variable_linear.rs

diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index c173a76ca75a3..118683e7fd802 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -1,22 +1,22 @@
 [package]
 name = "bevy_animation"
-version = "0.4.0"
+version = "0.5.0"
 authors = ["Felipe Jorge <felipe.jorge.pereira@gmail.com>"]
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy_app = { path = "../bevy_app", version = "0.4.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.4.0" }
-bevy_core = { path = "../bevy_core", version = "0.4.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
-bevy_pbr = { path = "../bevy_pbr", version = "0.4.0" }
-bevy_math = { path = "../bevy_math", version = "0.4.0" }
-bevy_render = { path = "../bevy_render", version = "0.4.0" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.4.0" }
-bevy_transform = { path = "../bevy_transform", version = "0.4.0" }
-bevy_reflect = { path = "../bevy_reflect", version = "0.4.0", features = ["bevy"] }
+bevy_app = { path = "../bevy_app", version = "0.5.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.5.0" }
+bevy_core = { path = "../bevy_core", version = "0.5.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.5.0" }
+bevy_pbr = { path = "../bevy_pbr", version = "0.5.0" }
+bevy_math = { path = "../bevy_math", version = "0.5.0" }
+bevy_render = { path = "../bevy_render", version = "0.5.0" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.5.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.5.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.5.0", features = ["bevy"] }
 
 # other
 serde = { version = "1.0", features = ["derive"] }
@@ -26,8 +26,5 @@ float-cmp = "0.8.0"
 fnv = "1.0.7"
 tracing = "0.1.21"
 
-ultraviolet = "0.7.5"
-wide = "0.5.5" # not the latest version of wide but maches the one used by ultravilet
-
 [features]
 default = []
\ No newline at end of file
diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index 792f0c5408c0c..3524d71ec265d 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -2,29 +2,24 @@ use std::{
     any::{type_name, Any, TypeId},
     borrow::Cow,
     collections::{HashMap, HashSet},
-    convert::{TryFrom, TryInto},
     fmt,
 };
 
 use anyhow::Result;
-use bevy_app::{prelude::Events, ManualEventReader};
+use bevy_app::{Events, ManualEventReader};
 use bevy_asset::{AssetEvent, Assets, Handle};
 use bevy_core::prelude::*;
 use bevy_ecs::prelude::*;
-use bevy_math::prelude::*;
-use bevy_reflect::{Reflect, ReflectComponent, TypeUuid};
+use bevy_math::{curves::Curve, interpolation::Lerp};
+use bevy_reflect::{Reflect, TypeUuid};
 use bevy_transform::prelude::*;
 use fnv::FnvBuildHasher;
 use smallvec::{smallvec, SmallVec};
 use tracing::warn;
 
-use crate::{
-    blending::AnimatorBlending,
-    hierarchy::Hierarchy,
-    interpolation::Lerp,
-    tracks::{ArrayN, Track, TrackBase, TrackFixed, TrackFixedN, TrackNBase, ValueN},
-    wide::{Quatx8, Vec3x8},
-};
+use crate::blending::AnimatorBlending;
+
+pub type TrackBase<T> = Box<dyn Curve<Output = T> + Send + Sync + 'static>;
 
 // TODO: Load Clip name from gltf
 
@@ -53,10 +48,6 @@ pub struct Tracks<T> {
     outputs: SmallVec<[u16; 8]>,
     /// Tuple of track and it's index
     tracks: Vec<(usize, TrackBase<T>)>,
-    /// Similar to `tracks` but simultaneously has many outputs
-    ///
-    /// **NOTE** It has its own `outputs` stored inside
-    n: Vec<(usize, TrackNBase<T>)>,
 }
 
 impl<T> fmt::Debug for Tracks<T> {
@@ -73,13 +64,12 @@ impl<T> Tracks<T> {
         self.tracks
             .iter()
             .map(|(_, track)| track.duration())
-            .chain(self.n.iter().map(|(_, track)| track.duration()))
             .fold(0.0f32, |acc, d| acc.max(d))
     }
 
     /// Number of curves inside
     pub fn len(&self) -> usize {
-        self.tracks.len() + self.n.iter().map(|(_, t)| t.len()).sum::<usize>()
+        self.tracks.len()
     }
 
     #[inline]
@@ -88,16 +78,8 @@ impl<T> Tracks<T> {
     }
 
     #[inline]
-    pub fn iter(
-        &self,
-    ) -> (
-        impl Iterator<Item = (u16, &(usize, TrackBase<T>))>,
-        &[(usize, TrackNBase<T>)],
-    ) {
-        (
-            self.outputs.iter().copied().zip(self.tracks.iter()),
-            &self.n,
-        )
+    pub fn iter(&self) -> impl Iterator<Item = (u16, &(usize, TrackBase<T>))> {
+        self.outputs.iter().copied().zip(self.tracks.iter())
     }
 }
 
@@ -159,25 +141,6 @@ impl TracksUntyped {
     }
 }
 
-// Pros:
-//  - Can limit to only the entities that we really want to animate, from deep nested hierarchies
-//  - Entities names don't matter
-//  - Hierarchy don't matter with can be nice if you keep changing it
-//  - Easer to design a LayerMask around it
-//  - Bit less memory
-// Cons:
-//  - Harder to modify and manipulate clips
-//  - Harder to find entities
-//  - Harder to mix clips with different hierarchies
-//  - Hierarchy don't matter which can lead to a giant mess, and will make impossible to parallelize
-//    over Animators
-// /// Defines a reusable entity hierarchy
-// #[derive(Debug, TypeUuid)]
-// #[uuid = "9d524787-1fbf-46c6-b34f-f2ae196664c5"]
-// pub struct AnimatorHierarchy {
-//     pub entities: Vec<String>,
-// }
-
 // TODO: impl Serialize, Deserialize using bevy reflect for that
 // the hierarchy, this animated entity asset must match the one been used in the animator
 // this could help retarget animations, but will mess the clip
@@ -195,7 +158,7 @@ pub struct Clip {
     duration: f32,
     // ! FIXME: Limit to only entities that have animations to avoid
     // ! fetching extra components that aren't been used
-    hierarchy: Hierarchy,
+    hierarchy: NamedHierarchy,
     // ? NOTE: AHash performed worse than FnvHasher
     // TODO: Change to the hashbrown::raw::RawTable and use a `label!()` to make hashes constants
     /// Each curve and keyframe cache index mapped by property name
@@ -217,7 +180,7 @@ impl Default for Clip {
             name: String::new(),
             warp: true,
             duration: 0.0,
-            hierarchy: Hierarchy::default(),
+            hierarchy: NamedHierarchy::default(),
             properties: HashMap::default(),
             len: 0,
             keyframes_cache_buckets: 0,
@@ -238,8 +201,8 @@ impl Clip {
     /// The return value is the assigned curve index in cache line bucket.
     pub fn add_track_at_path<T>(&mut self, path: &str, track: T) -> usize
     where
-        T: Track + Send + Sync + 'static,
-        <T as Track>::Output: Lerp + Clone + Send + Sync + 'static,
+        T: Curve + Send + Sync + 'static,
+        <T as Curve>::Output: Lerp + Clone + Send + Sync + 'static,
     {
         // Split in entity and attribute path,
         // NOTE: use rfind because it's expected the latter to be generally shorter
@@ -258,7 +221,7 @@ impl Clip {
 
         if let Some((cache_index, tracks_untyped)) = self.properties.get_mut(property_path) {
             let tracks = tracks_untyped
-                .downcast_mut::<<T as Track>::Output>()
+                .downcast_mut::<<T as Curve>::Output>()
                 .expect("properties can't have the same name and different curve types");
 
             let search = tracks
@@ -271,7 +234,7 @@ impl Clip {
                 let (kf_index, source) = &mut tracks.tracks[track_index];
                 let k_index = *kf_index;
 
-                let mut track: TrackBase<<T as Track>::Output> = Box::new(track);
+                let mut track: TrackBase<<T as Curve>::Output> = Box::new(track);
 
                 // Found a property equal to the one been inserted, next replace the curve
                 std::mem::swap(source, &mut track);
@@ -288,17 +251,6 @@ impl Clip {
                 return k_index;
             }
 
-            let search_n = tracks.n.iter().enumerate().find_map(|(i, (_, t))| {
-                t.lanes()
-                    .iter()
-                    .position(|index| *index == entity_index)
-                    .map(|o| (i, o))
-            });
-
-            if let Some((_track_index, _lane_index)) = search_n {
-                panic!("replacing a single lane in multi lane track isn't supported");
-            }
-
             *cache_index += 1;
             if (*cache_index % KEYFRAMES_PER_CACHE) == 0 {
                 // No more spaces left in the current cache line
@@ -332,7 +284,6 @@ impl Clip {
                 TracksUntyped::new(Tracks {
                     outputs: smallvec![entity_index],
                     tracks: vec![(cache_index, Box::new(track))],
-                    n: vec![],
                 }),
             ),
         );
@@ -340,87 +291,6 @@ impl Clip {
         cache_index
     }
 
-    #[inline]
-    fn pack_by_type<V>(sampling_rate: f32, tracks: &mut Tracks<V::Value>) -> usize
-    where
-        V: ValueN + Lerp + Clone + Send + Sync + 'static,
-        <V as ValueN>::Value: Default + Send + Sync + 'static,
-        <V as ValueN>::Outputs: Default + Copy + Send + Sync + 'static,
-        <V as ValueN>::Lanes: for<'a> TryFrom<&'a [u16]> + Send + Sync + 'static,
-    {
-        let mut total = 0;
-        let mut left = tracks.tracks.len();
-
-        while left >= V::size() {
-            let lanes: V::Lanes = if let Ok(lanes) = tracks.outputs[0..V::size()].try_into() {
-                lanes
-            } else {
-                panic!("not enough output lanes");
-            };
-
-            let group = &tracks.tracks[0..8];
-            let d = group
-                .iter()
-                .fold(0.0f32, |acc, (_, t)| acc.max(t.duration()));
-
-            let f = (d * sampling_rate).trunc();
-            // Actual frame rate, is approximated the desired sampling rate,
-            // but isn't always equal to avoid loop seams
-            let frame_rate = d / f;
-            let frame_count = f as usize;
-
-            let mut v = V::Outputs::default();
-            let mut keyframes: Vec<V> = Vec::with_capacity(frame_count);
-            for frame_index in 0..frame_count {
-                let time = (frame_index as f32) * frame_rate;
-
-                for (i, (_, t)) in group.iter().enumerate() {
-                    *v.get_mut(i) = t.sample(time);
-                }
-
-                keyframes.push(V::pack(v));
-            }
-
-            let track_packed = TrackFixedN {
-                lanes,
-                len: V::size() as u16,
-                track: TrackFixed::from_keyframes(1.0 / frame_rate, 0, keyframes),
-            };
-
-            tracks.n.push((group[0].0, Box::new(track_packed)));
-
-            tracks.outputs.drain(0..V::size());
-            tracks.tracks.drain(0..V::size());
-            left -= V::size();
-
-            total += 1;
-        }
-
-        total
-    }
-
-    /// Packs single lane tracks into multi lane tracks, increases the performance trading memory
-    /// so the sampling mechanism can issue as many SIMD instruction as possible;
-    ///
-    /// **NOTE** Only a handful of types can be packed, like `Vec3` and `Quat`, more should
-    /// be added in the future;
-    ///
-    /// **NOTE** This is a very expensive function, it works by re-sampling each
-    /// curve at approximately the desired `sampling_rate`, it will preserve the clip total duration
-    /// but can't handle start offsets, so make sure all the tracks starts at time 0.0;
-    pub fn pack(&mut self, sampling_rate: f32) {
-        // println!("packing clip '{}'", self.name);
-
-        for (_, (_, tracks_untyped)) in self.properties.iter_mut() {
-            // TODO: Support more types
-            if let Some(tracks) = tracks_untyped.downcast_mut::<Vec3>() {
-                Self::pack_by_type::<Vec3x8>(sampling_rate, tracks);
-            } else if let Some(tracks) = tracks_untyped.downcast_mut::<Quat>() {
-                Self::pack_by_type::<Quatx8>(sampling_rate, tracks);
-            }
-        }
-    }
-
     /// Number of animated properties in this clip
     #[inline]
     pub fn len(&self) -> usize {
@@ -465,7 +335,7 @@ impl Clip {
     }
 
     #[inline]
-    pub fn hierarchy(&self) -> &Hierarchy {
+    pub fn hierarchy(&self) -> &NamedHierarchy {
         &self.hierarchy
     }
 
@@ -581,7 +451,7 @@ pub struct Animator {
     #[reflect(ignore)]
     bind_clips: Vec<Option<Bind>>,
     #[reflect(ignore)]
-    hierarchy: Hierarchy,
+    hierarchy: NamedHierarchy,
     #[reflect(ignore)]
     missing_entities: bool,
     #[reflect(ignore)]
@@ -595,7 +465,7 @@ impl Default for Animator {
         Self {
             clips: vec![],
             bind_clips: vec![],
-            hierarchy: Hierarchy::default(),
+            hierarchy: NamedHierarchy::default(),
             missing_entities: false,
             entities: vec![],
             time_scale: 1.0,
@@ -701,7 +571,7 @@ pub(crate) struct BindingState {
 
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn animator_update_system(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut state: Local<BindingState>,
     clip_events: Res<Events<AssetEvent<Clip>>>,
     animator_registry: Res<AnimatorRegistry>,
@@ -736,7 +606,9 @@ pub(crate) fn animator_update_system(
         let animator = &mut *animator;
 
         if animator_blending.is_none() {
-            commands.insert_one(animator_entity, AnimatorBlending::default());
+            commands
+                .entity(animator_entity)
+                .insert(AnimatorBlending::default());
         }
 
         // Time scales by component
@@ -924,9 +796,8 @@ pub(crate) fn animator_update_system(
 #[allow(dead_code)]
 mod tests {
     use super::*;
-    use crate::tracks::TrackVariableLinear;
     use bevy_asset::AddAsset;
-    use bevy_math::prelude::{Quat, Vec3};
+    use bevy_math::{curves::CurveVariableLinear, Quat, Vec3};
     use bevy_pbr::prelude::StandardMaterial;
     use bevy_render::prelude::Mesh;
 
@@ -939,7 +810,6 @@ mod tests {
         fn new() -> Self {
             let mut app_builder = bevy_app::App::build();
             app_builder
-                .add_plugin(bevy_reflect::ReflectPlugin::default())
                 .add_plugin(bevy_core::CorePlugin::default())
                 .add_plugin(bevy_app::ScheduleRunnerPlugin::default())
                 .add_plugin(bevy_asset::AssetPlugin::default())
@@ -949,7 +819,6 @@ mod tests {
                 .add_plugin(crate::AnimationPlugin { skinning: false });
 
             let mut world = World::new();
-            let mut world_builder = world.build();
             let base = (
                 GlobalTransform::default(),
                 Transform::from_translation(Vec3::new(0.0, 1.0, 0.0)),
@@ -961,9 +830,9 @@ mod tests {
                 let mut clip_a = Clip::default();
                 clip_a.add_track_at_path(
                     "@Transform.translation",
-                    TrackVariableLinear::from_line(0.0, 1.0, Vec3::unit_x(), -Vec3::unit_x()),
+                    CurveVariableLinear::from_line(0.0, 1.0, Vec3::X, -Vec3::X),
                 );
-                let rot = TrackVariableLinear::from_constant(Quat::identity());
+                let rot = CurveVariableLinear::from_constant(Quat::IDENTITY);
                 clip_a.add_track_at_path("@Transform.rotation", rot.clone());
                 clip_a.add_track_at_path("/Node1@Transform.rotation", rot.clone());
                 clip_a.add_track_at_path("/Node1/Node2@Transform.rotation", rot);
@@ -971,21 +840,21 @@ mod tests {
                 let mut clip_b = Clip::default();
                 clip_b.add_track_at_path(
                     "@Transform.translation",
-                    TrackVariableLinear::from_constant(Vec3::zero()),
+                    CurveVariableLinear::from_constant(Vec3::ZERO),
                 );
-                let rot = TrackVariableLinear::from_line(
+                let rot = CurveVariableLinear::from_line(
                     0.0,
                     1.0,
-                    Quat::from_axis_angle(Vec3::unit_z(), 0.1),
-                    Quat::from_axis_angle(Vec3::unit_z(), -0.1),
+                    Quat::from_axis_angle(Vec3::Z, 0.1),
+                    Quat::from_axis_angle(Vec3::Z, -0.1),
                 );
                 clip_b.add_track_at_path("@Transform.rotation", rot.clone());
                 clip_b.add_track_at_path("/Node1@Transform.rotation", rot.clone());
                 clip_b.add_track_at_path("/Node1/Node2@Transform.rotation", rot);
 
                 let mut clips = app_builder
-                    .resources_mut()
-                    .get_mut::<Assets<Clip>>()
+                    .world_mut()
+                    .get_resource_mut::<Assets<Clip>>()
                     .unwrap();
                 let clip_a = clips.add(clip_a);
                 let clip_b = clips.add(clip_b);
@@ -995,39 +864,40 @@ mod tests {
             }
 
             let mut entities = vec![];
-            entities.push(
-                world_builder
-                    .spawn(base.clone())
-                    .with(Name::new("Root"))
-                    .with(animator)
-                    .current_entity
-                    .unwrap(),
-            );
-            world_builder.with_children(|world_builder| {
+
+            let root = world
+                .spawn()
+                .insert_bundle(base.clone())
+                .insert(Name::new("Root"))
+                .insert(animator)
+                .id();
+
+            entities.push(root);
+
+            world.entity_mut(root).with_children(|world_builder| {
                 entities.push(
                     world_builder
-                        .spawn(base.clone())
-                        .with(Name::new("Node1"))
-                        .current_entity()
-                        .unwrap(),
+                        .spawn_bundle(base.clone())
+                        .insert(Name::new("Node1"))
+                        .id(),
                 );
 
                 world_builder.with_children(|world_builder| {
                     entities.push(
                         world_builder
-                            .spawn(base.clone())
-                            .with(Name::new("Node2"))
-                            .current_entity()
-                            .unwrap(),
+                            .spawn()
+                            .insert_bundle(base.clone())
+                            .insert(Name::new("Node2"))
+                            .id(),
                     );
 
                     world_builder.with_children(|world_builder| {
                         entities.push(
                             world_builder
-                                .spawn(base.clone())
-                                .with(Name::new("Node3"))
-                                .current_entity()
-                                .unwrap(),
+                                .spawn()
+                                .insert_bundle(base.clone())
+                                .insert(Name::new("Node3"))
+                                .id(),
                         );
                     });
                 });
@@ -1067,11 +937,7 @@ mod tests {
             .for_each(|(index, entity)| assert!(entity.is_some(), "missing entity {}", index,));
 
         // delete "Node1"
-        test_bench
-            .app
-            .world
-            .despawn(test_bench.entities[1])
-            .unwrap();
+        test_bench.app.world.despawn(test_bench.entities[1]);
 
         // Tick
         test_bench.run();
@@ -1090,15 +956,14 @@ mod tests {
         test_bench.entities[1] = test_bench
             .app
             .world
-            .build()
-            .spawn((
+            .spawn()
+            .insert_bundle((
                 GlobalTransform::default(),
                 Transform::from_translation(Vec3::new(0.0, 1.0, 0.0)),
                 Name::new("Node1"),
                 Parent(test_bench.entities[0]),
             ))
-            .current_entity
-            .unwrap();
+            .id();
 
         *test_bench
             .app
@@ -1133,13 +998,7 @@ mod tests {
             .for_each(|(index, entity)| assert!(entity.is_some(), "missing entity {}", index,));
 
         // Change parent of node "Node1"
-        let new_parent = test_bench
-            .app
-            .world
-            .build()
-            .spawn(())
-            .current_entity
-            .unwrap();
+        let new_parent = test_bench.app.world.spawn().id();
 
         *test_bench
             .app
@@ -1196,7 +1055,8 @@ mod tests {
         test_bench
             .app
             .world
-            .remove_one::<Parent>(test_bench.entities[1])
+            .entity_mut(test_bench.entities[1])
+            .remove::<Parent>()
             .unwrap();
 
         // Tick
@@ -1216,8 +1076,8 @@ mod tests {
         test_bench
             .app
             .world
-            .insert_one(test_bench.entities[1], Parent(test_bench.entities[0]))
-            .unwrap();
+            .entity_mut(test_bench.entities[1])
+            .insert(Parent(test_bench.entities[0]));
 
         // Tick
         // ! FIXME: Takes one frame to bind the missing properties because
@@ -1299,7 +1159,8 @@ mod tests {
         test_bench
             .app
             .world
-            .remove_one::<Name>(test_bench.entities[1])
+            .entity_mut(test_bench.entities[1])
+            .remove::<Name>()
             .unwrap();
 
         // Tick
@@ -1318,8 +1179,8 @@ mod tests {
         test_bench
             .app
             .world
-            .insert_one(test_bench.entities[1], Name::new("Node1"))
-            .unwrap();
+            .entity_mut(test_bench.entities[1])
+            .insert(Name::new("Node1"));
 
         // Tick
         // ! FIXME: Takes one frame to bind the missing properties because
@@ -1352,11 +1213,15 @@ mod tests {
         // Modify clip
         {
             let clip_a_handle = test_bench.animator().clips()[0].clone();
-            let mut clips = test_bench.app.resources.get_mut::<Assets<Clip>>().unwrap();
+            let mut clips = test_bench
+                .app
+                .world
+                .get_resource_mut::<Assets<Clip>>()
+                .unwrap();
             let clip_a = clips.get_mut(clip_a_handle).unwrap();
             clip_a.add_track_at_path(
                 "/Node3/@Transform.translation",
-                TrackVariableLinear::from_line(0.0, 1.0, Vec3::unit_z(), -Vec3::unit_z()),
+                CurveVariableLinear::from_line(0.0, 1.0, Vec3::Z, -Vec3::Z),
             );
         }
 
@@ -1365,7 +1230,7 @@ mod tests {
         assert_eq!(test_bench.animator().entities().len(), 4);
 
         // Spawn entity
-        test_bench.app.world.build().spawn((
+        test_bench.app.world.spawn().insert_bundle((
             GlobalTransform::default(),
             Transform::from_translation(Vec3::new(0.0, 1.0, 0.0)),
             Name::new("Node3"),
@@ -1385,7 +1250,7 @@ mod tests {
 
     #[test]
     fn clip_property_index_are_grouped_into_cache_line_buckets() {
-        let curve = TrackVariableLinear::from_constant(0.0);
+        let curve = CurveVariableLinear::from_constant(0.0);
         let mut clip = Clip::default();
         assert_eq!(clip.add_track_at_path("a@T.t", curve.clone()), 0);
         assert_eq!(clip.add_track_at_path("b@T.t", curve.clone()), 1);
diff --git a/crates/bevy_animation/src/app.rs b/crates/bevy_animation/src/app.rs
index 5699e79e34a1c..a4096fd235352 100644
--- a/crates/bevy_animation/src/app.rs
+++ b/crates/bevy_animation/src/app.rs
@@ -1,6 +1,7 @@
 use bevy_app::AppBuilder;
 use bevy_asset::{Asset, Handle};
-use bevy_ecs::prelude::*;
+use bevy_ecs::{component::Component, prelude::*};
+use bevy_math::interpolation::Lerp;
 use bevy_reflect::prelude::*;
 use std::{
     any::{type_name, TypeId},
@@ -9,8 +10,7 @@ use std::{
 };
 
 use crate::{
-    animator::AnimatorRegistry, blending::Blend, interpolation::Lerp, reflect, stage,
-    AnimatorPropertyRegistry,
+    animator::AnimatorRegistry, blending::Blend, reflect, AnimationStage, AnimatorPropertyRegistry,
 };
 
 // TODO: Find a way of lifting the `Default` bound on `register_animated_component` and `register_animated_asset` functions
@@ -25,8 +25,8 @@ impl AddAnimated for AppBuilder {
     /// Registry an property type that can be animated
     fn register_animated_property_type<T: Lerp + Blend + Clone + 'static>(&mut self) -> &mut Self {
         let mut property_registry = self
-            .resources_mut()
-            .get_or_insert_with(AnimatorPropertyRegistry::default);
+            .world_mut()
+            .get_resource_or_insert_with(AnimatorPropertyRegistry::default);
 
         property_registry.register::<T>();
         drop(property_registry);
@@ -37,8 +37,8 @@ impl AddAnimated for AppBuilder {
     /// Registry an component `T` to be animated
     fn register_animated_component<T: Component + Struct + Default>(&mut self) -> &mut Self {
         let mut registry = self
-            .resources_mut()
-            .get_or_insert_with(AnimatorRegistry::default);
+            .world_mut()
+            .get_resource_or_insert_with(AnimatorRegistry::default);
 
         if registry.targets.insert(TypeId::of::<T>()) {
             let component = T::default();
@@ -54,7 +54,7 @@ impl AddAnimated for AppBuilder {
 
             self.insert_resource(descriptor);
             self.add_system_to_stage(
-                stage::ANIMATE,
+                AnimationStage::Animate,
                 reflect::animate_component_system::<T>
                     .system()
                     .after("animator_update"),
@@ -73,8 +73,8 @@ impl AddAnimated for AppBuilder {
     /// **NOTE** `Handle<T>` and `Option<Handle<T>>` are also registered as animated properties
     fn register_animated_asset<T: Asset + Struct + Default>(&mut self) -> &mut Self {
         let mut registry = self
-            .resources_mut()
-            .get_or_insert_with(AnimatorRegistry::default);
+            .world_mut()
+            .get_resource_or_insert_with(AnimatorRegistry::default);
 
         if registry.targets.insert(TypeId::of::<T>()) {
             let asset = T::default();
@@ -94,7 +94,7 @@ impl AddAnimated for AppBuilder {
 
             self.insert_resource(descriptor);
             self.add_system_to_stage(
-                stage::ANIMATE,
+                AnimationStage::Animate,
                 reflect::animate_asset_system::<T>
                     .system()
                     .after("animator_update"),
diff --git a/crates/bevy_animation/src/bench.rs b/crates/bevy_animation/src/bench.rs
index cf943e8d6f5af..451fe0299a210 100644
--- a/crates/bevy_animation/src/bench.rs
+++ b/crates/bevy_animation/src/bench.rs
@@ -1,10 +1,15 @@
-use crate::{app::AddAnimated, stage::ANIMATE};
 use bevy_app::{App, AppBuilder};
 use bevy_asset::{Asset, AssetServerSettings};
-use bevy_ecs::{Component, IntoSystem, ParallelSystemDescriptorCoercion, Schedule, SystemStage};
+use bevy_ecs::{
+    component::Component,
+    schedule::{ParallelSystemDescriptorCoercion, Schedule, SystemStage},
+    system::IntoSystem,
+};
 use bevy_reflect::Struct;
 use bevy_transform::prelude::*;
 
+use crate::{app::AddAnimated, AnimationStage};
+
 /// Bench utility
 pub struct Bench {
     pub builder: AppBuilder,
@@ -26,7 +31,6 @@ impl Bench {
         let mut builder = App::build();
         builder
             .insert_resource(AssetServerSettings { asset_folder })
-            .add_plugin(bevy_reflect::ReflectPlugin::default())
             .add_plugin(bevy_core::CorePlugin::default())
             .add_plugin(bevy_app::ScheduleRunnerPlugin::default())
             .add_plugin(bevy_asset::AssetPlugin::default())
@@ -34,15 +38,15 @@ impl Bench {
             .add_plugin(crate::AnimationPlugin { skinning: false });
 
         let mut schedule = Schedule::default();
-        schedule.add_stage(ANIMATE, SystemStage::parallel());
+        schedule.add_stage(AnimationStage::Animate, SystemStage::parallel());
         schedule.add_system_to_stage(
-            ANIMATE,
+            AnimationStage::Animate,
             crate::animator::animator_update_system
                 .system()
                 .label("animator_update"),
         );
         schedule.add_system_to_stage(
-            ANIMATE,
+            AnimationStage::Animate,
             crate::reflect::animate_component_system::<Transform>
                 .system()
                 .after("animator_update"),
@@ -61,7 +65,7 @@ impl Bench {
     pub fn register_animated_asset<T: Asset + Struct + Default>(&mut self) -> &mut Self {
         self.builder.register_animated_asset::<T>();
         self.schedule.add_system_to_stage(
-            ANIMATE,
+            AnimationStage::Animate,
             crate::reflect::animate_asset_system::<T>
                 .system()
                 .after("animator_update"),
@@ -73,7 +77,7 @@ impl Bench {
     pub fn register_animated_component<T: Component + Struct + Default>(&mut self) -> &mut Self {
         self.builder.register_animated_component::<T>();
         self.schedule.add_system_to_stage(
-            ANIMATE,
+            AnimationStage::Animate,
             crate::reflect::animate_component_system::<T>
                 .system()
                 .after("animator_update"),
@@ -86,10 +90,9 @@ impl Bench {
     pub fn run(&mut self, iterations: usize) -> &mut Self {
         let app = &mut self.builder.app;
         let world = &mut app.world;
-        let resources = &mut app.resources;
 
         for _ in 0..iterations {
-            self.schedule.run_once(world, resources);
+            self.schedule.run_once(world);
         }
 
         self
diff --git a/crates/bevy_animation/src/blending.rs b/crates/bevy_animation/src/blending.rs
index 1cb995a54291d..b5954606aac51 100644
--- a/crates/bevy_animation/src/blending.rs
+++ b/crates/bevy_animation/src/blending.rs
@@ -1,13 +1,8 @@
 use std::mem::size_of;
 
 use bevy_asset::{Asset, Handle, HandleUntyped};
-use bevy_math::prelude::*;
-use bevy_render::color::Color;
-
-use crate::interpolation::{
-    utils::{Scale2, Scale3},
-    Lerp,
-};
+use bevy_math::{interpolation::Lerp, prelude::*};
+//use bevy_render::color::Color;
 
 /// Mask size used to blend properties, each bit corresponds to a single property
 pub type Mask = u32;
@@ -115,20 +110,20 @@ fn additive_blend_quat(a: &Quat, b: &Quat, w: f32) -> Quat {
     (*b * w) * *a
 }
 
-#[inline]
-fn additive_blend_scale2(a: &Scale2, b: &Scale2, w: f32) -> Scale2 {
-    Scale2((Vec2::one() + (b.0 * w)) * a.0)
-}
+// #[inline]
+// fn additive_blend_scale2(a: &Scale2, b: &Scale2, w: f32) -> Scale2 {
+//     Scale2((Vec2::one() + (b.0 * w)) * a.0)
+// }
 
-#[inline]
-fn additive_blend_scale3(a: &Scale3, b: &Scale3, w: f32) -> Scale3 {
-    Scale3((Vec3::one() + (b.0 * w)) * a.0)
-}
+// #[inline]
+// fn additive_blend_scale3(a: &Scale3, b: &Scale3, w: f32) -> Scale3 {
+//     Scale3((Vec3::one() + (b.0 * w)) * a.0)
+// }
 
-#[inline]
-fn additive_blend_color(a: &Color, b: &Color, w: f32) -> Color {
-    (Vec4::from(*a) + (Vec4::from(*b) * w)).into()
-}
+// #[inline]
+// fn additive_blend_color(a: &Color, b: &Color, w: f32) -> Color {
+//     (Vec4::from(*a) + (Vec4::from(*b) * w)).into()
+// }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -210,9 +205,10 @@ impl_blend!(Vec2, Lerp::lerp, additive_blend_vec2);
 impl_blend!(Vec3, Lerp::lerp, additive_blend_vec3);
 impl_blend!(Vec4, Lerp::lerp, additive_blend_vec4);
 impl_blend!(Quat, Lerp::lerp, additive_blend_quat);
-impl_blend!(Scale2, Lerp::lerp, additive_blend_scale2);
-impl_blend!(Scale3, Lerp::lerp, additive_blend_scale3);
-impl_blend!(Color, Lerp::lerp, additive_blend_color);
+// impl_blend!(Scale2, Lerp::lerp, additive_blend_scale2);
+// impl_blend!(Scale3, Lerp::lerp, additive_blend_scale3);
+// TODO: impl Blend for Color
+//impl_blend!(Color, Lerp::lerp, additive_blend_color);
 
 ///////////////////////////////////////////////////////////////////////////////
 
diff --git a/crates/bevy_animation/src/hierarchy.rs b/crates/bevy_animation/src/hierarchy.rs
deleted file mode 100644
index d11bd6e71c20a..0000000000000
--- a/crates/bevy_animation/src/hierarchy.rs
+++ /dev/null
@@ -1,441 +0,0 @@
-use bevy_core::prelude::*;
-use bevy_ecs::prelude::*;
-use bevy_transform::prelude::*;
-//use serde::{Deserialize, Serialize};
-use private::*;
-use smallvec::{smallvec, SmallVec};
-
-// TODO: Create a simplified version without the children ?!
-// TODO: Should I just use usize? and get done with it?
-
-/// Provides a way of describing a hierarchy or named entities
-/// and means for finding then in the world
-///
-/// By default and to save memory the nodes are indexed using `u16`
-/// but you can change it when needed.
-#[derive(Debug, Clone)]
-pub struct Hierarchy<I: Index = u16> {
-    /// Entity identification made by parent index and name
-    entities: Vec<(I, Name)>,
-    // ? NOTE: SmallVec<[u16; 10]> occupy the same 32 bytes as the SmallVec<[u16; 8]>, but the latter
-    // ? should be only take 24 bytes using the "union" feature
-    children: Vec<SmallVec<[I; 10]>>,
-}
-
-impl<I: Index> Default for Hierarchy<I> {
-    fn default() -> Self {
-        Self {
-            // ? NOTE: Since the root has no parent in this context it points to a place outside the vec bounds
-            entities: vec![(I::MAX_VALUE, Name::default())],
-            children: vec![smallvec![]],
-        }
-    }
-}
-
-impl<I: Index> Hierarchy<I> {
-    pub fn new() -> Self {
-        Default::default()
-    }
-
-    /// Used when the hierarchy must be in a specific order,
-    /// this function takes an vec of entities defined by their parent index
-    /// (on the same vec) and name.
-    ///
-    /// Any root entity should be indexed using `I::MAX_VALUE` or `I::MAX`.
-    ///
-    /// Many different root nodes are supported although having other roots
-    /// make hard to search entities, please refer to the documentation of
-    /// `find_entity` or `find_entity_in_world` to see how.
-    ///
-    /// **WARNING** Be caution when using this function because it may create a
-    /// an invalid hierarchy
-    pub fn from_ordered_entities(entities: Vec<(I, Name)>) -> Self {
-        assert_eq!(
-            entities[0].0,
-            I::MAX_VALUE,
-            "first entry must be an root entity"
-        );
-
-        let mut children = vec![];
-        children.resize_with(entities.len(), || smallvec![]);
-
-        for (entity_index, (parent_index, _)) in entities.iter().enumerate() {
-            if let Some(c) = children.get_mut(parent_index.as_usize()) {
-                c.push(I::from_usize_checked(entity_index));
-            }
-        }
-
-        Self { entities, children }
-    }
-
-    /// Merge other hierarchy into this one, it will collect the
-    /// new entities indexes of merged hierarchy.
-    pub fn merge(&mut self, other_hierarchy: &Hierarchy<I>, mapped_entities: &mut Vec<I>) {
-        mapped_entities.clear();
-        mapped_entities.resize(other_hierarchy.len(), I::MAX_VALUE);
-
-        assert!(
-            other_hierarchy.entities[0].0 == I::MAX_VALUE,
-            "first element isn't the root"
-        );
-
-        let root_index = I::from_usize(0);
-        mapped_entities[0] = root_index;
-
-        // At this point they coincide
-        self.internal_merge(other_hierarchy, root_index, root_index, mapped_entities);
-    }
-
-    // TODO: Expose to allow for merging hierarchies with multiple roots
-    fn internal_merge(
-        &mut self,
-        other_hierarchy: &Hierarchy<I>,
-        other_parent_index: I,
-        parent_index: I,
-        mapped_entities: &mut Vec<I>,
-    ) {
-        for other_index in &other_hierarchy.children[other_parent_index.as_usize()] {
-            let (_, other_name) = &other_hierarchy.entities[other_index.as_usize()];
-            let child = (&parent_index, other_name);
-
-            let entity_index =
-                if let Some(i) = self.entities.iter().position(|(i, n)| (i, n) == child) {
-                    let entity_index = I::from_usize(i);
-                    // Found corresponding entity
-                    mapped_entities[other_index.as_usize()] = entity_index;
-                    entity_index
-                } else {
-                    // Add entity
-                    // Soft limit added to save memory, identical to the curve limit
-                    let entity_index = I::from_usize_checked(self.entities.len());
-                    self.entities.push((parent_index, other_name.clone()));
-                    self.children.push(smallvec![]);
-                    self.children[parent_index.as_usize()].push(entity_index);
-                    mapped_entities[other_index.as_usize()] = entity_index;
-                    entity_index
-                };
-
-            self.internal_merge(other_hierarchy, *other_index, entity_index, mapped_entities);
-        }
-    }
-
-    /// Number of entities registered.
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.entities.len()
-    }
-
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    /// Iterates over each entity parent index, name and children indexes
-    #[inline]
-    pub fn iter(&self) -> impl Iterator<Item = (&(I, Name), &[I])> {
-        self.entities
-            .iter()
-            .zip(self.children.iter().map(|c| &c[..]))
-    }
-
-    /// Gets the entity parent index and `Name` components
-    #[inline]
-    pub fn get_entity(&self, entity_index: I) -> &(I, Name) {
-        &self.entities[entity_index.as_usize()]
-    }
-
-    pub fn depth_first<F: FnMut(I, &Name)>(&self, entity_index: I, visitor: &mut F) {
-        let i = entity_index.as_usize();
-        let (_, name) = &self.entities[i];
-
-        visitor(entity_index, name);
-
-        for child_index in &self.children[i] {
-            self.depth_first(*child_index, visitor);
-        }
-    }
-
-    /// Adds a new entity hierarchy path separated by backslashes (`'/'`)
-    /// return the entity index and if was or not inserted
-    pub fn get_or_insert_entity(&mut self, entity_path: &str) -> (I, bool) {
-        let mut entity_created = false;
-        let mut entity = I::from_usize(0); // Start search from root
-        for name in entity_path.split('/') {
-            // Ignore the first '/' or '///'
-            if name.is_empty() {
-                continue;
-            }
-
-            if let Some(e) = self
-                .entities
-                .iter()
-                .position(|(p, n)| (*p, n.as_str()) == (entity, name))
-            {
-                // Found entity
-                // ? NOTE: Conversion will never panic because the collection
-                // ? size will only increase in the else branch where a
-                // ? safe cast is performed
-                entity = I::from_usize(e);
-            } else {
-                // Add entity
-                let e = self.entities.len();
-                self.entities.push((entity, Name::new(name.to_string())));
-                self.children.push(smallvec![]);
-                entity_created = true;
-                // Soft limit added to save memory, identical to the curve limit
-                let _parent = entity;
-                entity = I::from_usize_checked(e);
-                self.children[_parent.as_usize()].push(entity)
-            }
-        }
-
-        (entity, entity_created)
-    }
-
-    /// Returns the entity path if found.
-    ///
-    /// The `NamedHierarchy` stores a the entity path in a specific way to improve search performance
-    /// thus it needs to rebuilt in the human readable format
-    pub fn get_entity_path_at(&self, mut entity_index: I) -> Option<String> {
-        let mut path = None;
-
-        while let Some((parent_index, name)) = self.entities.get(entity_index.as_usize()) {
-            if let Some(path) = path.as_mut() {
-                *path = format!("{}/{}", name.as_str(), path);
-            } else {
-                path = Some(name.as_str().to_string());
-            }
-
-            entity_index = *parent_index;
-        }
-
-        path
-    }
-
-    // TODO: find_all_entities_inspired in the `internal_merge` function
-
-    /// Finds an entity given a set of queries, see the example bellow
-    /// how to proper call this function,
-    ///
-    /// ```rust,ignore
-    /// let mut entities_table_cache = vec![];
-    /// entities_table_cache.resize(clip.hierarchy.len(), None);
-    /// // Assign the root entity as the first element
-    /// entities_table_cache[0] = Some(root);
-    ///
-    /// let found_entity = named_hierarchy.find_entity(2, &mut entities_table_cache, children_query, name_query);
-    /// ```
-    ///
-    /// *NOTE* Keep in mind that you can have as many root as you want
-    /// but each root must be manually find and inserted in the `entities_table_cache`
-    /// before calling this function.
-    pub fn find_entity(
-        &self,
-        entity_index: I,
-        entities_table_cache: &mut Vec<Option<Entity>>,
-        children_query: &Query<&Children>,
-        name_query: &Query<(&Parent, &Name)>,
-    ) -> Option<Entity> {
-        if let Some(entity) = &entities_table_cache[entity_index.as_usize()] {
-            Some(*entity)
-        } else {
-            let (parent_index, entity_name) = &self.entities[entity_index.as_usize()];
-
-            // Use recursion to find the entity parent
-            self.find_entity(
-                *parent_index,
-                entities_table_cache,
-                children_query,
-                name_query,
-            )
-            .and_then(|parent_entity| {
-                if let Ok(children) = children_query.get(parent_entity) {
-                    children
-                        .iter()
-                        .find(|entity| {
-                            if let Ok((current_parent, name)) = name_query.get(**entity) {
-                                // ! FIXME: Parent changes before the children update it self,
-                                // ! to account for that we also must double check entity parent component it self
-                                if current_parent.0 != parent_entity || name != entity_name {
-                                    return false;
-                                }
-
-                                // Update cache
-                                entities_table_cache[entity_index.as_usize()] = Some(**entity);
-                                true
-                            } else {
-                                false
-                            }
-                        })
-                        .copied()
-                } else {
-                    None
-                }
-            })
-        }
-    }
-
-    /// Finds an entity given a reference to the (`World`)[bevy_ecs::World], see the example bellow
-    /// how to proper call this function,
-    ///
-    /// ```rust,ignore
-    /// let mut entities_table_cache = vec![];
-    /// entities_table_cache.resize(clip.hierarchy.len(), None);
-    /// // Assign the root entity as the first element
-    /// entities_table_cache[0] = Some(root);
-    ///
-    /// let found_entity = named_hierarchy.find_entity_in_world(2, &mut entities_table_cache, &world);
-    /// ```
-    ///
-    /// *NOTE* Keep in mind that you can have as many root as you want
-    /// but each root must be manually find and inserted in the `entities_table_cache`
-    /// before calling this function.
-    pub fn find_entity_in_world(
-        &self,
-        entity_index: I,
-        entities_table_cache: &mut Vec<Option<Entity>>,
-        world: &World,
-    ) -> Option<Entity> {
-        if let Some(entity) = &entities_table_cache[entity_index.as_usize()] {
-            Some(*entity)
-        } else {
-            let (parent_index, entity_name) = &self.entities[entity_index.as_usize()];
-
-            // Use recursion to find the entity parent
-            self.find_entity_in_world(*parent_index, entities_table_cache, world)
-                .and_then(|parent_entity| {
-                    if let Ok(children) = world.get::<Children>(parent_entity) {
-                        children
-                            .iter()
-                            .find(|entity| {
-                                if let Ok((current_parent, name)) =
-                                    world.query_one::<(&Parent, &Name)>(**entity)
-                                {
-                                    // ! FIXME: Parent changes before the children update it self,
-                                    // ! to account for that we also must double check entity parent component it self
-                                    if current_parent.0 != parent_entity || name != entity_name {
-                                        return false;
-                                    }
-
-                                    // Update cache
-                                    entities_table_cache[entity_index.as_usize()] = Some(**entity);
-                                    true
-                                } else {
-                                    false
-                                }
-                            })
-                            .copied()
-                    } else {
-                        None
-                    }
-                })
-        }
-    }
-}
-
-mod private {
-    use std::{
-        convert::TryFrom,
-        fmt::{Debug, Display},
-    };
-
-    /// Implemented by unsigned types
-    pub trait Index: Sized + PartialEq + Copy + Clone + Debug + Display {
-        const MAX_VALUE: Self;
-
-        fn as_usize(&self) -> usize;
-        fn from_usize(index: usize) -> Self;
-        fn from_usize_checked(index: usize) -> Self;
-    }
-
-    macro_rules! impl_index {
-        ($t:ty) => {
-            impl Index for $t {
-                const MAX_VALUE: $t = <$t>::MAX;
-
-                fn as_usize(&self) -> usize {
-                    *self as usize
-                }
-
-                fn from_usize(index: usize) -> Self {
-                    index as Self
-                }
-
-                fn from_usize_checked(index: usize) -> Self {
-                    Self::try_from(index).expect(concat!(
-                        "entities limit reached, indexed with ",
-                        stringify!($t)
-                    ))
-                }
-            }
-        };
-    }
-
-    impl_index!(u8);
-    impl_index!(u16);
-    impl_index!(u32);
-    impl_index!(u64);
-    impl_index!(usize);
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn merge_different_hierarchies() {
-        let mut hierarchy_a = Hierarchy::<u16>::new();
-        hierarchy_a.get_or_insert_entity("/NodeA0/NodeB0");
-        hierarchy_a.get_or_insert_entity("/NodeA1/NodeB1/NodeC0");
-        hierarchy_a.get_or_insert_entity("/NodeA2/NodeB1/NodeC1");
-
-        let mut hierarchy_b = Hierarchy::<u16>::new();
-        hierarchy_b.get_or_insert_entity("/NodeA1/NodeB2/NodeC2");
-        hierarchy_b.get_or_insert_entity("/NodeA1/NodeB0/NodeC3");
-
-        let mut mapped_entities = vec![];
-        hierarchy_a.merge(&hierarchy_b, &mut mapped_entities);
-
-        assert!(
-            mapped_entities.iter().all(|index| *index < u16::MAX),
-            "some entities weren't mapped or merged"
-        );
-
-        for i in 0..hierarchy_b.len() {
-            assert_eq!(
-                hierarchy_a.get_entity_path_at(mapped_entities[i]),
-                hierarchy_b.get_entity_path_at(i as u16)
-            );
-        }
-    }
-
-    #[test]
-    fn merge_equal_but_scrambled_hierarchies() {
-        let mut hierarchy_a = Hierarchy::<u16>::new();
-        hierarchy_a.get_or_insert_entity("/NodeA0/NodeB0");
-        hierarchy_a.get_or_insert_entity("/NodeA1/NodeB1/NodeC0");
-        hierarchy_a.get_or_insert_entity("/NodeA2/NodeB1/NodeC1");
-        hierarchy_a.get_or_insert_entity("/NodeA1/NodeB0/NodeC3");
-
-        let mut hierarchy_b = Hierarchy::<u16>::new();
-        hierarchy_b.get_or_insert_entity("/NodeA2/NodeB1/NodeC1");
-        hierarchy_b.get_or_insert_entity("/NodeA1/NodeB0/NodeC3");
-        hierarchy_b.get_or_insert_entity("/NodeA1/NodeB1/NodeC0");
-        hierarchy_b.get_or_insert_entity("/NodeA0/NodeB0");
-
-        let mut mapped_entities = vec![];
-        hierarchy_a.merge(&hierarchy_b, &mut mapped_entities);
-
-        assert!(
-            mapped_entities.iter().all(|index| *index < u16::MAX),
-            "some entities weren't mapped or merged"
-        );
-
-        for i in 0..hierarchy_b.len() {
-            assert_eq!(
-                hierarchy_a.get_entity_path_at(mapped_entities[i]),
-                hierarchy_b.get_entity_path_at(i as u16)
-            );
-        }
-    }
-}
diff --git a/crates/bevy_animation/src/interpolation/interpolate.rs b/crates/bevy_animation/src/interpolation/interpolate.rs
deleted file mode 100644
index 554dd8b75c15f..0000000000000
--- a/crates/bevy_animation/src/interpolation/interpolate.rs
+++ /dev/null
@@ -1,160 +0,0 @@
-//use bevy_asset::{Asset, Handle, HandleUntyped};
-use bevy_math::prelude::*;
-use bevy_render::color::Color;
-
-use super::utils;
-
-// http://archive.gamedev.net/archive/reference/articles/article1497.html (bit old)
-
-pub struct TangentIgnore;
-
-#[derive(Debug)]
-pub enum Interpolation<T> {
-    Step,
-    Linear,
-    /// Right tangent for the current keyframe and left tangent of the next keyframe
-    Smooth {
-        right: T,
-        left: T,
-    },
-}
-
-impl<T: Clone> Clone for Interpolation<T> {
-    fn clone(&self) -> Self {
-        match self {
-            Interpolation::Step => Interpolation::Step,
-            Interpolation::Linear => Interpolation::Linear,
-            Interpolation::Smooth { right, left } => Interpolation::Smooth {
-                right: right.clone(),
-                left: left.clone(),
-            },
-        }
-    }
-}
-
-pub trait Interpolate {
-    type Tangent;
-
-    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self;
-}
-
-impl Interpolate for bool {
-    type Tangent = TangentIgnore;
-
-    #[inline]
-    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
-        let _ = interp;
-        if t > 0.99 {
-            *k0
-        } else {
-            *k1
-        }
-    }
-}
-
-impl Interpolate for f32 {
-    type Tangent = Self;
-
-    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
-        match interp {
-            Interpolation::Step => utils::step(k0, k1, t),
-            Interpolation::Linear => utils::lerp(t * k0, *k1, t),
-            Interpolation::Smooth { right, left } => utils::catmull_rom(*k0, *right, *k1, *left, t),
-        }
-    }
-}
-
-impl Interpolate for Vec2 {
-    type Tangent = Self;
-
-    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
-        match interp {
-            Interpolation::Step => utils::step(k0, k1, t),
-            Interpolation::Linear => utils::lerp(*k0, *k1, t),
-            Interpolation::Smooth { right, left } => utils::catmull_rom(*k0, *right, *k1, *left, t),
-        }
-    }
-}
-
-impl Interpolate for Vec3 {
-    type Tangent = Self;
-
-    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
-        match interp {
-            Interpolation::Step => utils::step(k0, k1, t),
-            Interpolation::Linear => utils::lerp(*k0, *k1, t),
-            Interpolation::Smooth { right, left } => utils::catmull_rom(*k0, *right, *k1, *left, t),
-        }
-    }
-}
-
-impl Interpolate for Vec4 {
-    type Tangent = Self;
-
-    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
-        match interp {
-            Interpolation::Step => utils::step(k0, k1, t),
-            Interpolation::Linear => utils::lerp(*k0, *k1, t),
-            Interpolation::Smooth { right, left } => utils::catmull_rom(*k0, *right, *k1, *left, t),
-        }
-    }
-}
-
-impl Interpolate for Color {
-    type Tangent = Self;
-
-    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
-        match interp {
-            Interpolation::Step => utils::step(k0, k1, t),
-            Interpolation::Linear => utils::lerp(*k0, *k1, t),
-            Interpolation::Smooth { right, left } => utils::catmull_rom::<Vec4>(
-                (*k0).into(),
-                (*right).into(),
-                (*k1).into(),
-                (*left).into(),
-                t,
-            )
-            .into(),
-        }
-    }
-}
-
-impl Interpolate for Quat {
-    type Tangent = Self;
-
-    /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
-    /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
-    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
-        match interp {
-            Interpolation::Step => utils::step(k0, k1, t),
-            Interpolation::Linear => {
-                // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
-                let mut k1 = *k1;
-                if k0.dot(k1) < 0.0 {
-                    k1 = -k1;
-                }
-
-                let q = utils::lerp::<Vec4>((*k0).into(), k1.into(), t);
-                let d = utils::inv_sqrt(q.dot(q));
-                (q * d).into()
-            }
-            Interpolation::Smooth { right, left } => {
-                // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
-                let mut k1 = *k1;
-                if k0.dot(k1) < 0.0 {
-                    k1 = -k1;
-                }
-
-                let q = utils::catmull_rom::<Vec4>(
-                    (*k0).into(),
-                    (*right).into(),
-                    k1.into(),
-                    (*left).into(),
-                    t,
-                );
-                let d = utils::inv_sqrt(q.dot(q));
-                (q * d).into()
-            }
-        }
-    }
-}
diff --git a/crates/bevy_animation/src/interpolation/lerp.rs b/crates/bevy_animation/src/interpolation/lerp.rs
deleted file mode 100644
index 1f528b8a5521b..0000000000000
--- a/crates/bevy_animation/src/interpolation/lerp.rs
+++ /dev/null
@@ -1,198 +0,0 @@
-use bevy_asset::{Asset, Handle, HandleUntyped};
-use bevy_math::prelude::*;
-use bevy_render::color::Color;
-use ultraviolet::{f32x4, f32x8, Vec3x4, Vec3x8, Vec4x4, Vec4x8};
-
-use super::utils::*;
-
-// TODO: add Rotors?
-
-/// Defines how a particular type will be interpolated
-pub trait Lerp {
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self;
-}
-
-impl Lerp for bool {
-    #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        if t > 0.99 {
-            *b
-        } else {
-            *a
-        }
-    }
-}
-
-impl Lerp for f32 {
-    #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        (*a) * (1.0 - t) + (*b) * t
-    }
-}
-
-impl Lerp for Vec2 {
-    #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        (*a) * (1.0 - t) + (*b) * t
-    }
-}
-
-impl Lerp for Vec3 {
-    #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        (*a) * (1.0 - t) + (*b) * t
-    }
-}
-
-impl Lerp for Vec3x4 {
-    #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        (*a) * f32x4::splat(1.0 - t) + (*b) * f32x4::splat(t)
-    }
-}
-
-impl Lerp for Vec3x8 {
-    #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        (*a) * f32x8::splat(1.0 - t) + (*b) * f32x8::splat(t)
-    }
-}
-
-impl Lerp for Vec4 {
-    #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        (*a) * (1.0 - t) + (*b) * t
-    }
-}
-
-impl Lerp for Vec4x4 {
-    #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        (*a) * f32x4::splat(1.0 - t) + (*b) * f32x4::splat(t)
-    }
-}
-
-impl Lerp for Vec4x8 {
-    #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        (*a) * f32x8::splat(1.0 - t) + (*b) * f32x8::splat(t)
-    }
-}
-
-impl Lerp for Color {
-    #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        (*a) * (1.0 - t) + (*b) * t
-    }
-}
-
-impl Lerp for Quat {
-    /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
-    /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
-    #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        let mut b = *b;
-
-        // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
-        if a.dot(b) < 0.0 {
-            b = -b;
-        }
-
-        let rot = Vec4::lerp((*a).into(), b.into(), t);
-        let inv_mag = inv_sqrt(rot.dot(rot));
-        (rot * inv_mag).into()
-    }
-}
-
-impl Lerp for Quatx4 {
-    /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
-    /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
-    #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        let mut b = b.0;
-
-        // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
-        // Flip b sing if dot product was negative
-        let sign: f32x4 = a.0.dot(b) & f32x4::splat(-0.0);
-        b.x ^= sign;
-        b.y ^= sign;
-        b.z ^= sign;
-        b.w ^= sign;
-
-        let rot = Vec4x4::lerp(&a.0, &b, t);
-        let inv_mag = inv_sqrt4(rot.dot(rot));
-        Quatx4(rot * inv_mag)
-    }
-}
-
-impl Lerp for Quatx8 {
-    /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
-    /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
-    #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        let mut b = b.0;
-
-        // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
-        // Flip b sing if dot product was negative
-        let sign: f32x8 = a.0.dot(b) & f32x8::splat(-0.0);
-        b.x ^= sign;
-        b.y ^= sign;
-        b.z ^= sign;
-        b.w ^= sign;
-
-        let rot = Vec4x8::lerp(&a.0, &b, t);
-        let inv_mag = inv_sqrt8(rot.dot(rot));
-        Quatx8(rot * inv_mag)
-    }
-}
-
-impl Lerp for Scale2 {
-    #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        Scale2(Vec2::lerp(a.0, b.0, t))
-    }
-}
-
-impl Lerp for Scale3 {
-    #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        Scale3(Vec3::lerp(a.0, b.0, t))
-    }
-}
-
-impl<T: Asset + 'static> Lerp for Handle<T> {
-    #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        if t > 0.99 {
-            b.clone()
-        } else {
-            a.clone()
-        }
-    }
-}
-
-impl Lerp for HandleUntyped {
-    #[inline]
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        if t > 0.99 {
-            b.clone()
-        } else {
-            a.clone()
-        }
-    }
-}
-
-impl<T: Lerp + Clone> Lerp for Option<T> {
-    fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        match (a.is_some(), b.is_some()) {
-            (true, true) => Some(T::lerp(a.as_ref().unwrap(), b.as_ref().unwrap(), t)),
-            (false, true) | (true, false) | (false, false) => {
-                if t > 0.99 {
-                    b.clone()
-                } else {
-                    a.clone()
-                }
-            }
-        }
-    }
-}
diff --git a/crates/bevy_animation/src/interpolation/mod.rs b/crates/bevy_animation/src/interpolation/mod.rs
deleted file mode 100644
index 15525e32003ee..0000000000000
--- a/crates/bevy_animation/src/interpolation/mod.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-mod interpolate;
-mod lerp;
-pub mod utils;
-
-pub use interpolate::*;
-pub use lerp::*;
diff --git a/crates/bevy_animation/src/interpolation/utils.rs b/crates/bevy_animation/src/interpolation/utils.rs
deleted file mode 100644
index 578d9cce44e29..0000000000000
--- a/crates/bevy_animation/src/interpolation/utils.rs
+++ /dev/null
@@ -1,125 +0,0 @@
-use std::ops::{Add, Div, Mul, Sub};
-
-use bevy_math::{Vec2, Vec3};
-use ultraviolet::{f32x4, f32x8, Vec4x4, Vec4x8};
-use wide::{i32x4, i32x8};
-
-// TODO: Add Quat support to ultraviolet?
-
-/// Wide quaternion
-#[derive(Debug, Clone)]
-pub struct Quatx4(pub Vec4x4);
-
-/// Wide quaternion
-#[derive(Debug, Clone)]
-pub struct Quatx8(pub Vec4x8);
-
-// macro_rules! wide_quat {
-//     ($t:tt, $) => {
-//         impl $t {
-//             pub fn identity() -> $t {
-//                 $t::splat(Vec4::new(0.0, 0.0, 0.0, 0.1))
-//             }
-//         }
-//     };
-// }
-
-// wide_quat!(Quat4);
-// wide_quat!(Quat8);
-
-/// Used to change the blending semantics of a `Vec2`
-#[derive(Debug, Clone)]
-pub struct Scale2(pub Vec2);
-
-/// Used to change the blending semantics of a `Vec3`
-#[derive(Debug, Clone)]
-pub struct Scale3(pub Vec3);
-
-/// Quake 3 fast inverse sqrt
-///
-/// Took this one from piston: https://github.com/PistonDevelopers/skeletal_animation
-#[inline]
-pub fn inv_sqrt(x: f32) -> f32 {
-    let x2: f32 = x * 0.5;
-    let mut y: f32 = x;
-
-    let mut i: i32 = y.to_bits() as i32;
-    i = 0x5f3759df - (i >> 1);
-    y = f32::from_bits(i as u32);
-
-    y = y * (1.5 - (x2 * y * y));
-    y
-}
-
-/// Quake 3 fast inverse sqrt for `f32x4`
-#[inline]
-pub fn inv_sqrt4(x: f32x4) -> f32x4 {
-    let x2: f32x4 = x * 0.5;
-    let mut y: f32x4 = x;
-
-    let mut i: i32x4 = unsafe { std::mem::transmute(y) };
-    i = i32x4::splat(0x5f3759df) - (i >> 1);
-    y = unsafe { std::mem::transmute(i) };
-
-    y = y * (f32x4::splat(1.5) - (x2 * y * y));
-    y
-}
-
-/// Quake 3 fast inverse sqrt for `f32x8`
-#[inline]
-pub fn inv_sqrt8(x: f32x8) -> f32x8 {
-    let x2: f32x8 = x * 0.5;
-    let mut y: f32x8 = x;
-
-    let mut i: i32x8 = unsafe { std::mem::transmute(y) };
-    i = i32x8::splat(0x5f3759df) - (i >> 1);
-    y = unsafe { std::mem::transmute(i) };
-
-    y = y * (f32x8::splat(1.5) - (x2 * y * y));
-    y
-}
-
-#[inline]
-pub fn step<T: Clone>(k0: &T, k1: &T, u: f32) -> T {
-    if u > 0.99 {
-        k0.clone()
-    } else {
-        k1.clone()
-    }
-}
-
-#[inline]
-pub fn lerp<T>(k0: T, k1: T, u: f32) -> T
-where
-    T: Add<Output = T> + Mul<f32, Output = T>,
-{
-    k0 * (1.0 - u) + k1 * u
-}
-
-/// Catmull-Rom spline interpolation
-///
-/// Source: http://archive.gamedev.net/archive/reference/articles/article1497.html
-#[inline]
-pub fn catmull_rom<T>(k0: T, t0: T, k1: T, t1: T, u: f32) -> T
-where
-    T: Add<Output = T> + Sub<Output = T> + Mul<f32, Output = T>,
-{
-    let u2 = u * u;
-    let u3 = u2 * u;
-    let _3u2 = 3.0 * u2;
-    let _2u3 = 2.0 * u3;
-
-    k0 * (_2u3 - _3u2 + 1.0) + k1 * (_3u2 - _2u3) + t0 * (u3 - 2.0 * u2 + u) + t1 * (u3 - u2)
-}
-
-/// Finds the tangent gradients for the Catmull-Rom spline
-///
-/// Source: http://archive.gamedev.net/archive/reference/articles/article1497.html
-#[inline]
-pub fn auto_tangent<T>(t0: f32, t1: f32, t2: f32, k0: T, k1: T, k2: T) -> T
-where
-    T: Copy + Add<Output = T> + Sub<Output = T> + Mul<f32, Output = T> + Div<f32, Output = T>,
-{
-    // k'(t) = ½[k(t) - k(t-1)]/δx1 + ½[k(t+1) - k(t)]/δx2
-    ((k1 - k0) / (t1 - t0) + (k2 - k1) / (t2 - t1)) * 0.5
-}
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index fd47cb1a8c303..23667f3d0c9d9 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -1,7 +1,10 @@
 use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Assets};
-use bevy_ecs::{IntoSystem, SystemStage};
-use bevy_reflect::RegisterTypeBuilder;
+use bevy_ecs::{
+    schedule::{ParallelSystemDescriptorCoercion, StageLabel, SystemLabel, SystemStage},
+    system::IntoSystem,
+};
+//use bevy_reflect::TypeRegistration;
 
 mod animator;
 mod app;
@@ -9,16 +12,12 @@ mod help;
 mod reflect;
 //mod experimental;
 mod bench;
-mod hierarchy;
 mod skinned_mesh;
 
 pub mod blending;
-pub mod interpolation;
-pub mod tracks;
 
 pub use crate::{
-    animator::*, app::*, bench::*, blending::AnimatorBlending, hierarchy::Hierarchy,
-    reflect::AnimatorPropertyRegistry,
+    animator::*, app::*, bench::*, blending::AnimatorBlending, reflect::AnimatorPropertyRegistry,
 };
 
 pub mod prelude {
@@ -26,27 +25,24 @@ pub mod prelude {
         animator::{Animator, Clip},
         app::AddAnimated,
         blending::AnimatorBlending,
-        hierarchy::Hierarchy,
-        interpolation::Lerp,
         reflect::AnimatorPropertyRegistry,
         skinned_mesh::{SkinAsset, SkinComponent, SkinDebugger},
     };
 }
 
-/// Exports wide types
-pub mod wide {
-    pub use crate::interpolation::utils::{Quatx4, Quatx8};
-    pub use ultraviolet::vec::{Vec2x4, Vec2x8, Vec3x4, Vec3x8, Vec4x4, Vec4x8};
-    pub use wide::*;
+#[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
+pub enum AnimationStage {
+    Animate,
+    Skinning,
 }
 
-pub mod stage {
-    pub const ANIMATE: &str = "animate";
-    pub const SKINNING: &str = "skinning";
+#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemLabel)]
+pub enum AnimationSystem {
+    Animate,
+    ClipEvents,
+    Skinning,
 }
 
-use bevy_ecs::ParallelSystemDescriptorCoercion;
-
 pub struct AnimationPlugin {
     /// Enables or disables the built in skinning
     pub skinning: bool,
@@ -60,10 +56,14 @@ impl Default for AnimationPlugin {
 
 impl Plugin for AnimationPlugin {
     fn build(&self, app: &mut AppBuilder) {
-        app.add_stage_after(CoreStage::Update, stage::ANIMATE, SystemStage::parallel());
+        app.add_stage_after(
+            CoreStage::Update,
+            AnimationStage::Animate,
+            SystemStage::parallel(),
+        );
         app.add_stage_after(
             CoreStage::PostUpdate,
-            stage::SKINNING,
+            AnimationStage::Skinning,
             SystemStage::parallel(),
         );
 
@@ -73,17 +73,17 @@ impl Plugin for AnimationPlugin {
             //.add_asset_loader(ClipLoader)
             .register_type::<Animator>()
             .add_system_to_stage(
-                stage::ANIMATE,
+                AnimationStage::Animate,
                 Assets::<Clip>::asset_event_system
                     .system()
-                    .label("clip_event_system"),
+                    .label(AnimationSystem::ClipEvents),
             ) // ? NOTE: Fix asset event handle
             .add_system_to_stage(
-                stage::ANIMATE,
+                AnimationStage::Animate,
                 animator::animator_update_system
                     .system()
-                    .label("animator_update")
-                    .after("clip_event_system"),
+                    .label(AnimationSystem::Animate)
+                    .after(AnimationSystem::ClipEvents),
             );
 
         // ! FIXME: Each added animated component or asset will add a bit of overhead in the animation
@@ -100,16 +100,16 @@ impl Plugin for AnimationPlugin {
         if self.skinning {
             app.add_startup_system(skinned_mesh::skinning_setup.system())
                 .add_system_to_stage(
-                    stage::SKINNING,
+                    AnimationStage::Skinning,
                     skinned_mesh::skinning_update
                         .system()
-                        .label("skinning_update"),
+                        .label(AnimationSystem::Skinning),
                 )
                 .add_system_to_stage(
-                    stage::SKINNING,
+                    AnimationStage::Skinning,
                     skinned_mesh::skinning_debugger_update
                         .system()
-                        .after("skinning_update"),
+                        .after(AnimationSystem::Skinning),
                 );
         }
     }
diff --git a/crates/bevy_animation/src/reflect.rs b/crates/bevy_animation/src/reflect.rs
index d609bbbdd9feb..acdc2e0428f58 100644
--- a/crates/bevy_animation/src/reflect.rs
+++ b/crates/bevy_animation/src/reflect.rs
@@ -8,17 +8,16 @@ use std::{
 };
 
 use bevy_asset::{prelude::*, Asset};
-use bevy_ecs::prelude::*;
-use bevy_math::prelude::*;
+use bevy_ecs::{component::Component, prelude::*};
+use bevy_math::{interpolation::Lerp, prelude::*};
 use bevy_reflect::prelude::*;
-use bevy_render::prelude::Color;
+//use bevy_render::prelude::Color;
 use tracing::warn;
 
 use crate::{
     animator::{Animator, Clip},
     blending::{AnimatorBlendGroup, AnimatorBlending, Blend, Mask, MASK_LIMIT},
     help::shorten_name,
-    interpolation::Lerp,
 };
 
 // ? NOTE: Generic types like `Option<T>` must be specialized and registered with `register_animated_property_type`
@@ -61,7 +60,8 @@ impl Default for AnimatorPropertyRegistry {
                 (TypeId::of::<Vec3>(), animate::<Vec3>),
                 (TypeId::of::<Vec4>(), animate::<Vec4>),
                 (TypeId::of::<Quat>(), animate::<Quat>),
-                (TypeId::of::<Color>(), animate::<Color>),
+                // TODO: Color can't be animated right now :(
+                //(TypeId::of::<Color>(), animate::<Color>),
             ],
         }
     }
@@ -121,7 +121,7 @@ unsafe fn animate<T>(
         .map(|curve_untyped| curve_untyped.downcast_ref::<T>())
         .flatten()
     {
-        let (tracks, tracks_n) = tracks.iter();
+        let tracks = tracks.iter();
 
         for (entity_index, (curve_index, track)) in tracks {
             let entity_index = entities_map[entity_index as usize] as usize;
@@ -143,31 +143,6 @@ unsafe fn animate<T>(
                 );
             }
         }
-
-        // Handle N lane tracks
-        if !tracks_n.is_empty() {
-            let assign = &mut |output_lane: u16, v: T| {
-                let entity_index = entities_map[output_lane as usize] as usize;
-                if let Some(component) = (get_mut)(entity_index) {
-                    // Unsafe portion
-                    let value = &mut *(component.offset(prop.offset) as *mut T);
-                    value.blend(
-                        entity_index,
-                        prop.mask,
-                        prop.slot,
-                        blend_group,
-                        v,
-                        w,
-                        additive,
-                    );
-                }
-            };
-
-            for (curve_index, track_n) in tracks_n {
-                let cursor = &mut keyframes[*curve_index];
-                *cursor = track_n.sample(*cursor, time, assign);
-            }
-        }
     }
 }
 
@@ -333,7 +308,7 @@ pub(crate) fn animate_component_system<T: Component>(
             for entity in animator.entities() {
                 cached_components.push(
                     entity
-                        .map(|entity| components_query.get_unsafe(entity).ok())
+                        .map(|entity| components_query.get_unchecked(entity).ok())
                         .flatten(),
                 );
             }
@@ -448,7 +423,7 @@ pub(crate) fn animate_asset_system<T: Asset>(
             for entity in animator.entities() {
                 cached_components.push(
                     entity
-                        .map(|entity| components_query.get_unsafe(entity).ok())
+                        .map(|entity| components_query.get_unchecked(entity).ok())
                         .flatten(),
                 );
             }
@@ -503,7 +478,7 @@ pub(crate) fn animate_asset_system<T: Asset>(
                     .map(|curve_untyped| curve_untyped.downcast_ref::<Handle<T>>())
                     .flatten()
                 {
-                    let (tracks, tracks_n) = tracks.iter();
+                    let tracks = tracks.iter();
 
                     for (entity_index, (curve_index, curve)) in tracks {
                         let entity_index = entities_map[entity_index as usize] as usize;
@@ -524,31 +499,6 @@ pub(crate) fn animate_asset_system<T: Asset>(
                             );
                         }
                     }
-
-                    // Handle N lane tracks
-                    // ? NOTE: Currently Handle<T> isn't supported but still be implemented where
-                    if !tracks_n.is_empty() {
-                        let assign = &mut |output_lane: u16, v: Handle<T>| {
-                            let entity_index = entities_map[output_lane as usize] as usize;
-                            if let Some(ref mut component) = cached_components[entity_index] {
-                                let value = &mut **component;
-                                value.blend(
-                                    entity_index,
-                                    prop_mask,
-                                    prop_slot,
-                                    &mut blend_group,
-                                    v,
-                                    w,
-                                    layer.additive,
-                                );
-                            }
-                        };
-
-                        for (curve_index, curve) in tracks_n {
-                            let cursor = &mut keyframes[*curve_index];
-                            *cursor = curve.sample(*cursor, time, assign);
-                        }
-                    }
                 }
             }
         }
diff --git a/crates/bevy_animation/src/skinned_mesh.rs b/crates/bevy_animation/src/skinned_mesh.rs
index d17f37acced2f..93d2fd47ff138 100644
--- a/crates/bevy_animation/src/skinned_mesh.rs
+++ b/crates/bevy_animation/src/skinned_mesh.rs
@@ -1,11 +1,14 @@
 // TODO: Later merge with bevy_animation
-use crate::hierarchy::Hierarchy;
 use bevy_asset::{Assets, Handle, HandleUntyped};
 use bevy_core::Name;
-use bevy_ecs::{prelude::*, MapEntities};
+use bevy_ecs::{
+    entity::{EntityMap, MapEntities, MapEntitiesError},
+    prelude::*,
+    reflect::{ReflectComponent, ReflectMapEntities},
+};
 use bevy_math::Mat4;
 use bevy_pbr::prelude::*;
-use bevy_reflect::{Reflect, ReflectComponent, ReflectMapEntities, TypeUuid};
+use bevy_reflect::{Reflect, TypeUuid};
 use bevy_render::{
     mesh::{shape, Indices, Mesh, VertexAttributeValues},
     pipeline::{PipelineDescriptor, PrimitiveTopology, RenderPipelines},
@@ -30,7 +33,7 @@ pub struct SkinAsset {
     /// Inverse bind matrices in root node space
     pub inverse_bind_matrices: Vec<Mat4>,
     /// Skin joint hierarchy, plus one extra the root node as the first entry.
-    pub hierarchy: Hierarchy,
+    pub hierarchy: NamedHierarchy,
 }
 
 #[derive(Default, Debug, Clone, TypeUuid, RenderResources)]
@@ -87,17 +90,14 @@ impl SkinComponent {
     }
 }
 
-impl FromResources for SkinComponent {
-    fn from_resources(_resources: &bevy_ecs::Resources) -> Self {
+impl Default for SkinComponent {
+    fn default() -> Self {
         SkinComponent::with_root(Entity::new(u32::MAX))
     }
 }
 
 impl MapEntities for SkinComponent {
-    fn map_entities(
-        &mut self,
-        entity_map: &bevy_ecs::EntityMap,
-    ) -> Result<(), bevy_ecs::MapEntitiesError> {
+    fn map_entities(&mut self, entity_map: &EntityMap) -> Result<(), MapEntitiesError> {
         for renderer in &mut self.renderers {
             *renderer = entity_map.get(*renderer)?;
         }
@@ -115,7 +115,7 @@ pub(crate) fn skinning_setup(
     let __guard = __span.enter();
 
     let mut forward_skinned_pipeline = pipelines
-        .get(bevy_pbr::render_graph::FORWARD_PIPELINE_HANDLE)
+        .get(bevy_pbr::render_graph::PBR_PIPELINE_HANDLE)
         .expect("missing forward pipeline")
         .clone();
 
@@ -145,7 +145,7 @@ pub(crate) fn skinning_setup(
 // ? https://github.com/KhronosGroup/glTF-Tutorials/blob/master/gltfTutorial/gltfTutorial_020_Skins.md
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn skinning_update(
-    commands: &mut Commands,
+    mut commands: Commands,
     skin_assets: Res<Assets<SkinAsset>>,
     mut skin_instances: ResMut<Assets<SkinInstance>>,
     mut binds_query: Query<(&Handle<SkinAsset>, &mut SkinComponent, &Children)>,
@@ -188,7 +188,7 @@ pub(crate) fn skinning_update(
                 let mut joint_matrices = vec![];
                 joint_matrices.resize(
                     skin_asset.inverse_bind_matrices.len(),
-                    Mat4::identity().to_cols_array(),
+                    Mat4::IDENTITY.to_cols_array(),
                 );
                 skin_bind.instance = Some(skin_instances.add(SkinInstance { joint_matrices }));
             }
@@ -202,7 +202,9 @@ pub(crate) fn skinning_update(
 
             for renderer_entity in skin_bind.renderers.iter().chain(skin_children.iter()) {
                 // Insert right skinning info
-                commands.insert_one(*renderer_entity, skin_instance_handle.clone());
+                commands
+                    .entity(*renderer_entity)
+                    .insert(skin_instance_handle.clone());
 
                 // Change render pipeline
                 if let Ok(mut renderer) = renderers_query.get_mut(*renderer_entity) {
@@ -256,7 +258,7 @@ pub struct SkinDebugger {
 }
 
 pub(crate) fn skinning_debugger_update(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     skins: Res<Assets<SkinAsset>>,
     mut debugger_query: Query<(&Handle<SkinAsset>, &SkinComponent, &mut SkinDebugger)>,
@@ -285,11 +287,11 @@ pub(crate) fn skinning_debugger_update(
                 for bone in skinner.joint_entities.iter() {
                     if let Some(entity) = bone {
                         commands
-                            .spawn(PbrBundle {
+                            .spawn_bundle(PbrBundle {
                                 mesh: bone_mesh.clone(),
                                 ..Default::default()
                             })
-                            .with(Parent(*entity));
+                            .insert(Parent(*entity));
                     }
                 }
 
@@ -300,13 +302,15 @@ pub(crate) fn skinning_debugger_update(
             let mesh = meshes.get_mut(mesh_handle).unwrap();
 
             if debugger.entity.is_none() {
-                debugger.entity = commands
-                    .spawn(PbrBundle {
-                        mesh: mesh_handle.clone(),
-                        // TODO: Ignore depth test and draw skeleton on top of everything
-                        ..Default::default()
-                    })
-                    .current_entity()
+                debugger.entity = Some(
+                    commands
+                        .spawn_bundle(PbrBundle {
+                            mesh: mesh_handle.clone(),
+                            // TODO: Ignore depth test and draw skeleton on top of everything
+                            ..Default::default()
+                        })
+                        .id(),
+                )
             }
 
             let positions = skinner
diff --git a/crates/bevy_animation/src/tracks/fixed.rs b/crates/bevy_animation/src/tracks/fixed.rs
deleted file mode 100644
index 18f15cce51fb0..0000000000000
--- a/crates/bevy_animation/src/tracks/fixed.rs
+++ /dev/null
@@ -1,120 +0,0 @@
-use crate::{interpolation::Lerp, tracks::Track};
-
-// TODO: impl Serialize, Deserialize
-/// Fixed frame rate track
-#[derive(Default, Debug)]
-pub struct TrackFixed<T> {
-    // ? NOTE: Has I learned from benches casting to f32 is quite expensive
-    // ? so frame rate and offset values must be stored as f32
-    frame_rate: f32,
-    /// Negative number of frames before the curve starts
-    negative_offset: f32,
-    keyframes: Vec<T>,
-}
-
-impl<T: Clone> Clone for TrackFixed<T> {
-    fn clone(&self) -> Self {
-        Self {
-            frame_rate: self.frame_rate,
-            negative_offset: self.negative_offset,
-            keyframes: self.keyframes.clone(),
-        }
-    }
-}
-
-impl<T> TrackFixed<T> {
-    pub fn from_keyframes(frame_rate: f32, offset: isize, keyframes: Vec<T>) -> Self {
-        Self {
-            frame_rate,
-            negative_offset: -(offset as f32),
-            keyframes,
-        }
-    }
-
-    pub fn from_constant(v: T) -> Self {
-        Self {
-            frame_rate: 30.0,
-            negative_offset: 0.0,
-            keyframes: vec![v],
-        }
-    }
-
-    pub fn keyframes_mut(&mut self) -> &mut [T] {
-        &mut self.keyframes[..]
-    }
-
-    // pub fn insert(&mut self, time_sample: f32, value: T) {
-    // }
-
-    // pub fn remove(&mut self, index: usize) {
-    //assert!(samples.len() > 1, "curve can't be empty");
-    // }
-
-    /// Number of keyframes
-    pub const fn len(&self) -> usize {
-        self.frame_rate as usize
-    }
-
-    /// True when doesn't have any keyframe
-    pub const fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    pub fn frame_rate(&self) -> usize {
-        self.keyframes.len()
-    }
-
-    pub fn offset(&self) -> isize {
-        (-self.negative_offset) as isize
-    }
-
-    // pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
-    //     self.samples.iter().copied().zip(self.keyframes.iter())
-    // }
-
-    // pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
-    //     self.samples.iter().copied().zip(self.keyframes.iter_mut())
-    // }
-}
-
-impl<T> Track for TrackFixed<T>
-where
-    T: Lerp + Clone,
-{
-    type Output = T;
-
-    fn duration(&self) -> f32 {
-        ((self.keyframes.len() as f32 - 1.0 - self.negative_offset) / self.frame_rate).max(0.0)
-    }
-
-    fn sample(&self, time: f32) -> Self::Output {
-        // Make sure to have at least one sample
-        assert!(!self.keyframes.is_empty(), "track is empty");
-
-        let t = time.mul_add(self.frame_rate, self.negative_offset);
-        if t.is_sign_negative() {
-            // Underflow clamp
-            return self.keyframes[0].clone();
-        }
-
-        let f = t.trunc();
-        let t = t - f;
-
-        let f = f as usize;
-        let f_n = self.keyframes.len() - 1;
-        if f >= f_n {
-            // Overflow clamp
-            return self.keyframes[f_n].clone();
-        }
-
-        // Lerp the value
-        T::lerp(&self.keyframes[f], &self.keyframes[f + 1], t)
-    }
-
-    /// Same as `sample` function
-    #[inline]
-    fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, Self::Output) {
-        let _ = cursor;
-        (0, self.sample(time))
-    }
-}
diff --git a/crates/bevy_animation/src/tracks/mod.rs b/crates/bevy_animation/src/tracks/mod.rs
deleted file mode 100644
index a50a9946d8a2c..0000000000000
--- a/crates/bevy_animation/src/tracks/mod.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-//! The bread and butter of the animation system tracks are the source of
-//! data at given state and comes in 3 different flavours: `TrackFixed`, `TrackVariantLinear`  
-//! and `TrackVariant`;
-//!
-//! Each track implements the `Track` trait but the animation system it self uses
-//! the `TrackN` trait which implements a wide track type capable of outputting
-//! multiple values for each sampling call, they can also be used for narrow track as well
-//! (only a single output).
-
-mod fixed;
-mod n;
-mod variable;
-mod variable_linear;
-
-pub use fixed::*;
-pub use n::*;
-pub use variable::*;
-pub use variable_linear::*;
-
-pub trait Track {
-    type Output;
-
-    fn duration(&self) -> f32;
-
-    /// Easer to use sampling method that don't have time restrictions or needs
-    /// the keyframe cursor, but is more expensive always `O(n)`. Which means
-    /// sampling takes longer to evaluate as much as time get closer to curve duration
-    /// and it get worse with more keyframes.
-    fn sample(&self, time: f32) -> Self::Output;
-
-    /// Samples the curve starting from some keyframe cursor, this make the common case `O(1)`
-    ///
-    /// **NOTE** Each keyframe is indexed by a `u16` to reduce memory usage when using the keyframe caching
-    fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, Self::Output);
-}
-
-pub type TrackBase<T> = Box<dyn Track<Output = T> + Send + Sync + 'static>;
diff --git a/crates/bevy_animation/src/tracks/n.rs b/crates/bevy_animation/src/tracks/n.rs
deleted file mode 100644
index 4a17bea8fc894..0000000000000
--- a/crates/bevy_animation/src/tracks/n.rs
+++ /dev/null
@@ -1,231 +0,0 @@
-use std::mem::transmute;
-
-use bevy_math::prelude::*;
-// TODO: `bevy_render::prelude::Color` can be implemented the same way as Quatx4
-// use bevy_render::prelude::Color;
-
-use crate::{
-    interpolation::Lerp,
-    tracks::{Track, TrackFixed},
-    wide::*,
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-// ? NOTE: Index and IndexMut are only available in rust 1.50.0
-
-/// Array of N elements
-pub unsafe trait ArrayN {
-    type Item;
-
-    fn size() -> usize;
-
-    fn get(&self, index: usize) -> &Self::Item;
-
-    fn get_mut(&mut self, index: usize) -> &mut Self::Item;
-
-    fn as_slice(&self) -> &[Self::Item];
-
-    fn as_slice_mut(&mut self) -> &mut [Self::Item];
-}
-
-macro_rules! arrayn(
-    ($($size:expr),+) => {
-        $(
-            unsafe impl<T> ArrayN for [T; $size] {
-                type Item = T;
-                fn size() -> usize { $size }
-                fn get(&self, index: usize) -> &Self::Item { &self[index] }
-                fn get_mut(&mut self, index: usize) -> &mut Self::Item { &mut self[index] }
-                fn as_slice(&self) -> &[Self::Item] { &self[..] }
-                fn as_slice_mut(&mut self) -> &mut [Self::Item] { &mut self[..] }
-            }
-        )+
-    }
-);
-
-arrayn!(1, 4, 8);
-
-///////////////////////////////////////////////////////////////////////////////
-
-/// N length value
-pub trait ValueN {
-    type Value: Copy;
-
-    /// [u16; N]
-    type Lanes: ArrayN<Item = u16>;
-
-    /// [Self::Value; N]
-    type Outputs: ArrayN<Item = Self::Value>;
-
-    fn pack(values: Self::Outputs) -> Self;
-
-    fn unpack(self) -> Self::Outputs;
-
-    /// N
-    fn size() -> usize;
-}
-
-/// Tack with N output lanes
-pub trait TrackN {
-    type Output;
-
-    fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Output)) -> u16;
-
-    fn duration(&self) -> f32;
-
-    fn lanes(&self) -> &[u16];
-
-    /// Number of used outputs, may be N or less
-    fn len(&self) -> usize;
-
-    /// True when doesn't output anything
-    #[inline]
-    fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    /// N
-    fn size(&self) -> usize;
-}
-
-pub struct TrackFixedN<V: ValueN> {
-    pub lanes: V::Lanes,
-    /// Only applicable when `outputs.len() > 0`, defines how many of the output lanes are actually assigned;
-    /// In the case of `len == 0` this track doesn't output anything and should be deleted to preserve performance
-    pub len: u16,
-    pub track: TrackFixed<V>,
-}
-
-impl<V: ValueN + Lerp + Clone> TrackN for TrackFixedN<V> {
-    type Output = V::Value;
-
-    fn sample(&self, cursor: u16, time: f32, assign: &mut dyn FnMut(u16, Self::Output)) -> u16 {
-        let (cursor, x) = self.track.sample_with_cursor(cursor, time);
-        let x = x.unpack();
-        for i in 0..self.len() {
-            (assign)(*self.lanes.get(i), *x.get(i));
-        }
-        cursor
-    }
-
-    fn duration(&self) -> f32 {
-        self.track.duration()
-    }
-
-    fn len(&self) -> usize {
-        (self.len as usize).min(V::size())
-    }
-
-    fn lanes(&self) -> &[u16] {
-        &self.lanes.as_slice()[0..self.len()]
-    }
-
-    fn size(&self) -> usize {
-        V::size()
-    }
-}
-
-// impl<V: ValueN + Lerp + Clone> TrackFixedN<V> {
-//     // TODO: Function to edit each lane
-//     // pub fn add_track
-
-//     pub fn add_track_resampled(&mut self, track: &dyn Track<Output = <V as ValueN>::Value>) {
-//         let i = self.len as usize;
-//         if i >= V::size() {
-//             panic!("track is full");
-//         }
-
-//         self.len += 1;
-
-//         let mut cursor = 0;
-//         let f = 1.0 / (self.track.frame_rate() as f32);
-//         let offset = self.track.offset() as f32 * f;
-//         let s = self.track.len();
-//         let keyframes = self.track.keyframes_mut();
-
-//         for frame in 0..s {
-//             let time = offset + f * frame as f32;
-//             let (k, v) = track.sample_with_cursor(cursor, time);
-//             keyframes[frame].set(v, i);
-//             cursor = k;
-//         }
-//     }
-
-//     // pub fn remove_track
-// }
-
-pub type TrackNBase<T> = Box<dyn TrackN<Output = T> + Send + Sync + 'static>;
-
-///////////////////////////////////////////////////////////////////////////////
-
-macro_rules! valuen {
-    ($t:ty, $i:ty, $o:ty, $s:tt) => {
-        impl ValueN for $t {
-            type Lanes = [u16; $s];
-            type Outputs = [Self::Value; $s];
-            type Value = $o;
-
-            #[inline]
-            fn pack(values: Self::Outputs) -> Self {
-                unsafe { transmute::<_, [$i; $s]>(values).into() }
-            }
-
-            #[inline]
-            fn unpack(self) -> Self::Outputs {
-                unsafe { transmute::<[$i; $s], _>(self.into()) }
-            }
-
-            fn size() -> usize {
-                $s
-            }
-        }
-    };
-}
-
-valuen!(f32x4, f32, f32, 4);
-valuen!(f32x8, f32, f32, 8);
-valuen!(Vec3x4, ultraviolet::Vec3, Vec3, 4);
-valuen!(Vec3x8, ultraviolet::Vec3, Vec3, 8);
-valuen!(Vec4x4, ultraviolet::Vec4, Vec4, 4);
-valuen!(Vec4x8, ultraviolet::Vec4, Vec4, 8);
-
-impl ValueN for Quatx4 {
-    type Lanes = [u16; 4];
-    type Outputs = [Self::Value; 4];
-    type Value = Quat;
-
-    #[inline]
-    fn pack(values: Self::Outputs) -> Self {
-        Quatx4(unsafe { transmute::<_, [ultraviolet::Vec4; 4]>(values).into() })
-    }
-
-    #[inline]
-    fn unpack(self) -> Self::Outputs {
-        unsafe { transmute::<[ultraviolet::Vec4; 4], _>(self.0.into()) }
-    }
-
-    fn size() -> usize {
-        4
-    }
-}
-
-impl ValueN for Quatx8 {
-    type Lanes = [u16; 8];
-    type Outputs = [Self::Value; 8];
-    type Value = Quat;
-
-    #[inline]
-    fn pack(values: Self::Outputs) -> Self {
-        Quatx8(unsafe { transmute::<_, [ultraviolet::Vec4; 8]>(values).into() })
-    }
-
-    #[inline]
-    fn unpack(self) -> Self::Outputs {
-        unsafe { transmute::<[ultraviolet::Vec4; 8], _>(self.0.into()) }
-    }
-
-    fn size() -> usize {
-        8
-    }
-}
diff --git a/crates/bevy_animation/src/tracks/variable.rs b/crates/bevy_animation/src/tracks/variable.rs
deleted file mode 100644
index 3fd293f71a526..0000000000000
--- a/crates/bevy_animation/src/tracks/variable.rs
+++ /dev/null
@@ -1,223 +0,0 @@
-use crate::{
-    interpolation::{Interpolate, Interpolation},
-    tracks::Track,
-};
-
-// TODO: Curve/Clip need a validation during deserialization because they are
-// structured as SOA (struct of arrays), so the vec's length must match
-
-// https://github.com/niklasfrykholm/blog
-// https://bitsquid.blogspot.com/search?q=animation
-// http://bitsquid.blogspot.com/2009/11/bitsquid-low-level-animation-system.html
-// http://archive.gamedev.net/archive/reference/articles/article1497.html (bit old)
-
-// http://nfrechette.github.io/2016/12/07/anim_compression_key_reduction/
-// https://github.com/nfrechette/acl
-
-// TODO: impl Serialize, Deserialize
-#[derive(Default, Debug)]
-pub struct TrackVariable<T: Interpolate> {
-    time_stamps: Vec<f32>,
-    keyframes: Vec<T>,
-    /// Defines the interpolation for each keyframe pair
-    interpolations: Vec<Interpolation<T::Tangent>>,
-}
-
-impl<T> Clone for TrackVariable<T>
-where
-    T: Interpolate + Clone,
-    <T as Interpolate>::Tangent: Clone,
-{
-    fn clone(&self) -> Self {
-        Self {
-            time_stamps: self.time_stamps.clone(),
-            keyframes: self.keyframes.clone(),
-            interpolations: self.interpolations.clone(),
-        }
-    }
-}
-
-// impl<T> TrackVariableInterpolated<T> {
-//     pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
-//         // TODO: Result?
-
-//         // Make sure both have the same length
-//         assert!(
-//             samples.len() == values.len(),
-//             "samples and values must have the same length"
-//         );
-
-//         assert!(
-//             values.len() <= u16::MAX as usize,
-//             "limit of {} keyframes exceeded",
-//             u16::MAX
-//         );
-
-//         assert!(samples.len() > 0, "empty curve");
-
-//         // Make sure the
-//         assert!(
-//             samples
-//                 .iter()
-//                 .zip(samples.iter().skip(1))
-//                 .all(|(a, b)| a < b),
-//             "time samples must be on ascending order"
-//         );
-//         Self {
-//             time_stamps: samples,
-//             keyframes: values,
-//         }
-//     }
-
-//     pub fn from_line(t0: f32, t1: f32, v0: T, v1: T) -> Self {
-//         Self {
-//             time_stamps: if t1 >= t0 { vec![t0, t1] } else { vec![t1, t0] },
-//             keyframes: vec![v0, v1],
-//         }
-//     }
-
-//     pub fn from_constant(v: T) -> Self {
-//         Self {
-//             time_stamps: vec![0.0],
-//             keyframes: vec![v],
-//         }
-//     }
-
-//     // pub fn insert(&mut self, time_sample: f32, value: T) {
-//     // }
-
-//     // pub fn remove(&mut self, index: usize) {
-//     //assert!(samples.len() > 1, "curve can't be empty");
-//     // }
-
-//     pub fn add_offset_time(&mut self, time_offset: f32) {
-//         self.time_stamps.iter_mut().for_each(|t| *t += time_offset);
-//     }
-
-//     pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
-//         self.time_stamps.iter().copied().zip(self.keyframes.iter())
-//     }
-
-//     pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
-//         self.time_stamps
-//             .iter()
-//             .copied()
-//             .zip(self.keyframes.iter_mut())
-//     }
-// }
-
-impl<T> Track for TrackVariable<T>
-where
-    T: Interpolate + Clone + 'static,
-{
-    type Output = T;
-
-    fn duration(&self) -> f32 {
-        self.time_stamps.last().copied().unwrap_or(0.0)
-    }
-
-    fn sample(&self, time: f32) -> Self::Output {
-        // Index guessing gives a small search optimization
-        let index = if time < self.duration() * 0.5 {
-            0
-        } else {
-            self.time_stamps.len() - 1
-        };
-
-        self.sample_with_cursor(index as u16, time).1
-    }
-
-    fn sample_with_cursor(&self, mut cursor: u16, time: f32) -> (u16, Self::Output) {
-        // Adjust for the current keyframe cursor
-        let last_cursor = (self.time_stamps.len() - 1) as u16;
-
-        cursor = cursor.max(0).min(last_cursor);
-        if self.time_stamps[cursor as usize] < time {
-            // Forward search
-            loop {
-                if cursor == last_cursor {
-                    return (last_cursor, self.keyframes[last_cursor as usize].clone());
-                }
-                cursor += 1;
-
-                if self.time_stamps[cursor as usize] >= time {
-                    break;
-                }
-            }
-        } else {
-            // Backward search
-            loop {
-                if cursor == 0 {
-                    return (0, self.keyframes[0].clone());
-                }
-
-                let i = cursor - 1;
-                if self.time_stamps[i as usize] <= time {
-                    break;
-                }
-
-                cursor = i;
-            }
-        }
-
-        // Lerp the value
-        let i = cursor - 1;
-        let previous_time = self.time_stamps[i as usize];
-        let t = (time - previous_time) / (self.time_stamps[cursor as usize] - previous_time);
-        debug_assert!(
-            (0.0..=1.0).contains(&t),
-            "t = {} but should be normalized",
-            t
-        ); // Checks if it's required to normalize t
-
-        let value = T::interpolate(
-            &self.keyframes[i as usize],
-            &self.keyframes[cursor as usize],
-            &self.interpolations[i as usize],
-            t,
-        );
-
-        (cursor, value)
-    }
-}
-
-// #[cfg(test)]
-// mod tests {
-//     use super::*;
-
-//     #[test]
-//     fn curve_evaluation() {
-//         let curve = TrackVariableInterpolated::new(
-//             vec![0.0, 0.25, 0.5, 0.75, 1.0],
-//             vec![0.0, 0.5, 1.0, 1.5, 2.0],
-//         );
-//         assert_eq!(curve.sample(0.5), 1.0);
-
-//         let mut i0 = 0;
-//         let mut e0 = 0.0;
-//         for v in &[0.1, 0.3, 0.7, 0.4, 0.2, 0.0, 0.4, 0.85, 1.0] {
-//             let v = *v;
-//             let (i1, e1) = curve.sample_indexed(i0, v);
-//             assert_eq!(e1, 2.0 * v);
-//             if e1 > e0 {
-//                 assert!(i1 >= i0);
-//             } else {
-//                 assert!(i1 <= i0);
-//             }
-//             e0 = e1;
-//             i0 = i1;
-//         }
-//     }
-
-//     #[test]
-//     #[should_panic]
-//     fn curve_bad_length() {
-//         let _ = TrackVariableInterpolated::new(vec![0.0, 0.5, 1.0], vec![0.0, 1.0]);
-//     }
-
-//     #[test]
-//     #[should_panic]
-//     fn curve_time_samples_not_sorted() {
-//         let _ = TrackVariableInterpolated::new(vec![0.0, 1.5, 1.0], vec![0.0, 1.0, 2.0]);
-//     }
-// }
diff --git a/crates/bevy_animation/src/tracks/variable_linear.rs b/crates/bevy_animation/src/tracks/variable_linear.rs
deleted file mode 100644
index 1c4225f1fcb8b..0000000000000
--- a/crates/bevy_animation/src/tracks/variable_linear.rs
+++ /dev/null
@@ -1,205 +0,0 @@
-use super::Track;
-use crate::interpolation::Lerp;
-
-// TODO: Curve/Clip need a validation during deserialization because they are
-// structured as SOA (struct of arrays), so the vec's length must match
-
-// TODO: impl Serialize, Deserialize
-#[derive(Default, Debug)]
-pub struct TrackVariableLinear<T> {
-    time_stamps: Vec<f32>,
-    keyframes: Vec<T>,
-}
-
-impl<T: Clone> Clone for TrackVariableLinear<T> {
-    fn clone(&self) -> Self {
-        Self {
-            time_stamps: self.time_stamps.clone(),
-            keyframes: self.keyframes.clone(),
-        }
-    }
-}
-
-impl<T> TrackVariableLinear<T> {
-    pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
-        // TODO: Result?
-
-        // Make sure both have the same length
-        assert!(
-            samples.len() == values.len(),
-            "samples and values must have the same length"
-        );
-
-        assert!(
-            values.len() <= u16::MAX as usize,
-            "limit of {} keyframes exceeded",
-            u16::MAX
-        );
-
-        assert!(!samples.is_empty(), "empty curve");
-
-        // Make sure the
-        assert!(
-            samples
-                .iter()
-                .zip(samples.iter().skip(1))
-                .all(|(a, b)| a < b),
-            "time samples must be on ascending order"
-        );
-
-        Self {
-            time_stamps: samples,
-            keyframes: values,
-        }
-    }
-
-    pub fn from_line(t0: f32, t1: f32, v0: T, v1: T) -> Self {
-        Self {
-            time_stamps: if t1 >= t0 { vec![t0, t1] } else { vec![t1, t0] },
-            keyframes: vec![v0, v1],
-        }
-    }
-
-    pub fn from_constant(v: T) -> Self {
-        Self {
-            time_stamps: vec![0.0],
-            keyframes: vec![v],
-        }
-    }
-
-    // pub fn insert(&mut self, time_sample: f32, value: T) {
-    // }
-
-    // pub fn remove(&mut self, index: usize) {
-    //assert!(samples.len() > 1, "curve can't be empty");
-    // }
-
-    pub fn add_offset_time(&mut self, time_offset: f32) {
-        self.time_stamps.iter_mut().for_each(|t| *t += time_offset);
-    }
-
-    pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
-        self.time_stamps.iter().copied().zip(self.keyframes.iter())
-    }
-
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
-        self.time_stamps
-            .iter()
-            .copied()
-            .zip(self.keyframes.iter_mut())
-    }
-}
-
-impl<T> Track for TrackVariableLinear<T>
-where
-    T: Lerp + Clone + 'static,
-{
-    type Output = T;
-
-    fn duration(&self) -> f32 {
-        self.time_stamps.last().copied().unwrap_or(0.0)
-    }
-
-    fn sample(&self, time: f32) -> Self::Output {
-        // Index guessing gives a small search optimization
-        let index = if time < self.duration() * 0.5 {
-            0
-        } else {
-            self.time_stamps.len() - 1
-        };
-
-        self.sample_with_cursor(index as u16, time).1
-    }
-
-    fn sample_with_cursor(&self, mut cursor: u16, time: f32) -> (u16, Self::Output) {
-        // Adjust for the current keyframe index
-        let last_cursor = (self.time_stamps.len() - 1) as u16;
-
-        cursor = cursor.max(0).min(last_cursor);
-        if self.time_stamps[cursor as usize] < time {
-            // Forward search
-            loop {
-                if cursor == last_cursor {
-                    return (last_cursor, self.keyframes[last_cursor as usize].clone());
-                }
-                cursor += 1;
-
-                if self.time_stamps[cursor as usize] >= time {
-                    break;
-                }
-            }
-        } else {
-            // Backward search
-            loop {
-                if cursor == 0 {
-                    return (0, self.keyframes[0].clone());
-                }
-
-                let i = cursor - 1;
-                if self.time_stamps[i as usize] <= time {
-                    break;
-                }
-
-                cursor = i;
-            }
-        }
-
-        // Lerp the value
-        let i = cursor - 1;
-        let previous_time = self.time_stamps[i as usize];
-        let t = (time - previous_time) / (self.time_stamps[cursor as usize] - previous_time);
-        debug_assert!(
-            (0.0..=1.0).contains(&t),
-            "t = {} but should be normalized",
-            t
-        ); // Checks if it's required to normalize t
-        let value = T::lerp(
-            &self.keyframes[i as usize],
-            &self.keyframes[cursor as usize],
-            t,
-        );
-
-        (cursor, value)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn curve_evaluation() {
-        let curve = TrackVariableLinear::new(
-            vec![0.0, 0.25, 0.5, 0.75, 1.0],
-            vec![0.0, 0.5, 1.0, 1.5, 2.0],
-        );
-        assert_eq!(curve.sample(0.5), 1.0);
-
-        let mut i0 = 0;
-        let mut e0 = 0.0;
-        for v in &[0.1, 0.3, 0.7, 0.4, 0.2, 0.0, 0.4, 0.85, 1.0] {
-            let v = *v;
-            let (i1, e1) = curve.sample_with_cursor(i0, v);
-            assert_eq!(e1, 2.0 * v);
-            if e1 > e0 {
-                assert!(i1 >= i0);
-            } else {
-                assert!(i1 <= i0);
-            }
-            e0 = e1;
-            i0 = i1;
-        }
-    }
-
-    #[test]
-    #[should_panic]
-    fn curve_bad_length() {
-        let _ = TrackVariableLinear::new(vec![0.0, 0.5, 1.0], vec![0.0, 1.0]);
-    }
-
-    #[test]
-    #[should_panic]
-    fn curve_time_samples_not_sorted() {
-        let _ = TrackVariableLinear::new(vec![0.0, 1.5, 1.0], vec![0.0, 1.0, 2.0]);
-    }
-}
diff --git a/crates/bevy_gltf/Cargo.toml b/crates/bevy_gltf/Cargo.toml
index 364ec81f25469..938a8bf181c53 100644
--- a/crates/bevy_gltf/Cargo.toml
+++ b/crates/bevy_gltf/Cargo.toml
@@ -24,9 +24,7 @@ bevy_render = { path = "../bevy_render", version = "0.5.0" }
 bevy_transform = { path = "../bevy_transform", version = "0.5.0" }
 bevy_math = { path = "../bevy_math", version = "0.5.0" }
 bevy_scene = { path = "../bevy_scene", version = "0.5.0" }
-
-# bevy (contrib)
-bevy_animation = { path = "../bevy_animation", version = "0.4.0" }
+bevy_animation = { path = "../bevy_animation", version = "0.5.0" }
 
 # other
 gltf = { version = "0.15.2", default-features = false, features = ["utils", "names", "KHR_materials_unlit"] }
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index c26e05b30b28d..ebe00ac639309 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -1,11 +1,11 @@
 use anyhow::Result;
-use bevy_animation::{prelude::*, tracks::*};
+use bevy_animation::prelude::*;
 use bevy_asset::{
     AssetIoError, AssetLoader, AssetPath, BoxedFuture, Handle, LoadContext, LoadedAsset,
 };
 use bevy_core::Name;
-use bevy_ecs::world::World;
-use bevy_math::Mat4;
+use bevy_ecs::{prelude::Entity, world::World};
+use bevy_math::{curves::CurveVariableLinear, Mat4, Quat, Vec3};
 use bevy_pbr::prelude::{PbrBundle, StandardMaterial};
 use bevy_render::{
     camera::{
@@ -19,7 +19,7 @@ use bevy_render::{
 };
 use bevy_scene::Scene;
 use bevy_transform::{
-    hierarchy::{BuildWorldChildren, WorldChildBuilder},
+    hierarchy::{BuildWorldChildren, NamedHierarchy, WorldChildBuilder},
     prelude::{GlobalTransform, Transform},
 };
 use gltf::{
@@ -159,25 +159,26 @@ async fn load_gltf<'a, 'b>(
                     mesh.set_indices(Some(Indices::U32(indices.into_u32().collect())));
                 };
 
-                if let Some(color_attribute) = reader
-                    .read_colors(0)
-                    .map(|v| VertexAttributeValues::Uchar4(v.into_rgba_u8().collect()))
-                {
-                    mesh.set_attribute(Mesh::ATTRIBUTE_COLOR, color_attribute);
-                }
+                // TODO: Missing Uchar4
+                // if let Some(color_attribute) = reader
+                //     .read_colors(0)
+                //     .map(|v| VertexAttributeValues::Uchar4(v.into_rgba_u8().collect()))
+                // {
+                //     mesh.set_attribute(Mesh::ATTRIBUTE_COLOR, color_attribute);
+                // }
 
                 if let Some(weight_attribute) = reader
                     .read_weights(0)
                     .map(|v| VertexAttributeValues::Float4(v.into_f32().collect()))
                 {
-                    mesh.set_attribute(Mesh::ATTRIBUTE_WEIGHT, weight_attribute);
+                    mesh.set_attribute(Mesh::ATTRIBUTE_JOINT_WEIGHT, weight_attribute);
                 }
 
                 if let Some(joint_attribute) = reader
                     .read_joints(0)
                     .map(|v| VertexAttributeValues::Ushort4(v.into_u16().collect()))
                 {
-                    mesh.set_attribute(Mesh::ATTRIBUTE_JOINT, joint_attribute);
+                    mesh.set_attribute(Mesh::ATTRIBUTE_JOINT_INDEX, joint_attribute);
                 }
 
                 let mesh = load_context.set_labeled_asset(&primitive_label, LoadedAsset::new(mesh));
@@ -277,7 +278,7 @@ async fn load_gltf<'a, 'b>(
                     inverse_bind_matrices: inverse_bind_matrices
                         .map(|x| Mat4::from_cols_array_2d(&x))
                         .collect(),
-                    hierarchy: Hierarchy::from_ordered_entities(entities_parent_and_name),
+                    hierarchy: NamedHierarchy::from_ordered_entities(entities_parent_and_name),
                 }),
             );
         }
@@ -362,7 +363,7 @@ async fn load_gltf<'a, 'b>(
                     let values = values.map(Vec3::from).collect::<Vec<_>>();
                     property_path += "@Transform.translation";
                     clip_curves_translation_and_scale
-                        .push((property_path, TrackVariableLinear::new(time_stamps, values)));
+                        .push((property_path, CurveVariableLinear::new(time_stamps, values)));
 
                     // TODO: This is a runtime importer so here's no place for further optimizations
                 }
@@ -370,14 +371,14 @@ async fn load_gltf<'a, 'b>(
                     let values = values.into_f32().map(Quat::from).collect::<Vec<_>>();
                     property_path += "@Transform.rotation";
                     clip_curves_rotation
-                        .push((property_path, TrackVariableLinear::new(time_stamps, values)));
+                        .push((property_path, CurveVariableLinear::new(time_stamps, values)));
                 }
                 ReadOutputs::Scales(values) => {
                     let values = values.map(Vec3::from).collect::<Vec<_>>();
 
                     property_path += "@Transform.scale";
                     clip_curves_translation_and_scale
-                        .push((property_path, TrackVariableLinear::new(time_stamps, values)));
+                        .push((property_path, CurveVariableLinear::new(time_stamps, values)));
                 }
                 ReadOutputs::MorphTargetWeights(_) => {
                     unimplemented!("morph targets aren't current supported")
@@ -387,65 +388,75 @@ async fn load_gltf<'a, 'b>(
 
         // Make sure the start frame is always 0.0
         for (property_path, mut curve) in clip_curves_rotation {
-            TrackVariableLinear::<Quat>::add_offset_time(&mut curve, -start_time);
-            //curve.add_time_offset(-start_time);
+            curve.add_offset_time(-start_time);
             clip.add_track_at_path(&property_path, curve);
         }
 
         for (property_path, mut curve) in clip_curves_translation_and_scale {
-            TrackVariableLinear::<Vec3>::add_offset_time(&mut curve, -start_time);
-            //curve.add_time_offset(-start_time);
+            curve.add_offset_time(-start_time);
             clip.add_track_at_path(&property_path, curve);
         }
 
-        // TODO: Should I use a linear curve fit algorithm to estimate a good sample rate
-        // (probably not, 30 fps is the default sampling rate for many export programs)
-        clip.pack(30.0);
-
         load_context.set_labeled_asset(&anim_label, LoadedAsset::new(clip));
 
         let path = AssetPath::new_ref(load_context.path(), Some(&anim_label));
         clips_handles.push(load_context.get_handle(path));
     }
 
-    // Each node will be mapped to a slot inside this `entity_lookup`
-    let mut entity_lookup = vec![];
-    entity_lookup.resize_with(gltf.nodes().count(), || None);
-
     let mut scenes = vec![];
     let mut named_scenes = HashMap::new();
     for scene in gltf.scenes() {
+        // Each node will be mapped to a slot inside this `entity_lookup`
+        let mut entity_lookup = vec![];
+        entity_lookup.resize_with(gltf.nodes().count(), || None);
+
         let mut world = World::default();
-        world
-            .spawn()
-            .insert_bundle((Transform::identity(), GlobalTransform::identity()))
-            .insert(Name::new(name.to_string()))
-            .with_children(|parent| {
-                for node in scene.nodes() {
-                    let result = load_node(&node, parent, load_context, &buffer_data);
-                    if result.is_err() {
-                        err = Some(result);
-                        return;
-                    }
-                }
-            });
-        if let Some(Err(err)) = err {
-            return Err(err);
-        }
 
-        // Animator component
-        let mut animator = Animator::default();
-        for clip_handle in &clips_handles {
-            animator.add_clip(clip_handle.clone());
+        // Scene root
+        let mut root = world.spawn();
+        root.insert_bundle((Transform::identity(), GlobalTransform::identity()));
+
+        // Named scene
+        if let Some(name) = scene.name() {
+            root.insert(Name::new(name.to_string()));
         }
-        world_builder.with(animator);
 
-        world_builder.with_children(|parent| {
+        root.with_children(|parent| {
             for node in scene.nodes() {
                 load_node(&node, &node, parent, load_context, &mut entity_lookup, 0);
             }
         });
 
+        // Scene animator component
+        if clips_handles.len() > 0 {
+            let mut animator = Animator::default();
+            for clip_handle in &clips_handles {
+                animator.add_clip(clip_handle.clone());
+            }
+            root.insert(animator);
+        }
+
+        // Scene skins
+        for node in scene.nodes() {
+            if let Some(skin) = node.skin() {
+                let mut active = world.entity_mut(entity_lookup[node.index()].unwrap());
+
+                let skin_label = skin_label(&skin);
+                let skin_asset_path = AssetPath::new_ref(load_context.path(), Some(&skin_label));
+                let skin_handle: Handle<SkinAsset> = load_context.get_handle(skin_asset_path);
+                active.insert(skin_handle);
+
+                // TODO: Mesh skinner needs a at least a reference to the skeleton root for it to work
+                // for this reason it need to keep track of all entities created by their index in the gltf node vec
+                let skeleton_root = skin.skeleton().map_or(0, |n| n.index());
+                active.insert(SkinComponent::with_root(
+                    entity_lookup[skeleton_root].expect("missing skeleton root entity"),
+                ));
+
+                active.insert(SkinDebugger::default());
+            }
+        }
+
         let scene_handle = load_context
             .set_labeled_asset(&scene_label(&scene), LoadedAsset::new(Scene::new(world)));
 
@@ -550,7 +561,7 @@ fn load_material(material: &Material, load_context: &mut LoadContext) -> Handle<
 fn load_node(
     root_node: &gltf::Node,
     node: &gltf::Node,
-    world_builder: &mut WorldChildBuilder,
+    parent: &mut WorldChildBuilder,
     load_context: &mut LoadContext,
     entity_lookup: &mut Vec<Option<Entity>>,
     mut depth: usize, // Used to debug (uncomment the prints)
@@ -562,7 +573,7 @@ fn load_node(
     // ? NOTE: Avoid heavy computations when possible, also the blender exporter likes to
     // output decomposed matrixes with is better for us
     let (translation, rotation, scale) = node.transform().decomposed();
-    world_builder.spawn_bundle((
+    let mut active = parent.spawn_bundle((
         Transform {
             translation: translation.into(),
             rotation: rotation.into(),
@@ -571,34 +582,15 @@ fn load_node(
         GlobalTransform::default(),
     ));
 
-    let node_entity = world_builder
-        .current_entity()
-        .expect("entity wasn't created");
-    entity_lookup[node.index()] = Some(node_entity);
+    entity_lookup[node.index()] = Some(active.id());
 
     if let Some(name) = node.name() {
-        world_builder.insert(Name::new(name.to_string()));
-    }
-
-    if let Some(skin) = node.skin() {
-        let skin_label = skin_label(&skin);
-        let skin_asset_path = AssetPath::new_ref(load_context.path(), Some(&skin_label));
-        let skin_handle: Handle<SkinAsset> = load_context.get_handle(skin_asset_path);
-        world_builder.insert(skin_handle);
-
-        // TODO: Mesh skinner needs a at least a reference to the skeleton root for it to work
-        // for this reason it need to keep track of all entities created by their index in the gltf node vec
-        let skeleton_root = skin.skeleton().map_or(root_node.index(), |n| n.index());
-        world_builder.insert(SkinComponent::with_root(
-            entity_lookup[skeleton_root].expect("missing skeleton root entity"),
-        ));
-
-        world_builder.insert(SkinDebugger::default());
+        active.insert(Name::new(name.to_string()));
     }
 
     // create camera node
     if let Some(camera) = node.camera() {
-        world_builder.insert(VisibleEntities {
+        active.insert(VisibleEntities {
             ..Default::default()
         });
 
@@ -616,12 +608,12 @@ fn load_node(
                     ..Default::default()
                 };
 
-                world_builder.insert(Camera {
+                active.insert(Camera {
                     name: Some(base::camera::CAMERA_2D.to_owned()),
                     projection_matrix: orthographic_projection.get_projection_matrix(),
                     ..Default::default()
                 });
-                world_builder.insert(orthographic_projection);
+                active.insert(orthographic_projection);
             }
             gltf::camera::Projection::Perspective(perspective) => {
                 let mut perspective_projection: PerspectiveProjection = PerspectiveProjection {
@@ -635,17 +627,17 @@ fn load_node(
                 if let Some(aspect_ratio) = perspective.aspect_ratio() {
                     perspective_projection.aspect_ratio = aspect_ratio;
                 }
-                world_builder.insert(Camera {
+                active.insert(Camera {
                     name: Some(base::camera::CAMERA_3D.to_owned()),
                     projection_matrix: perspective_projection.get_projection_matrix(),
                     ..Default::default()
                 });
-                world_builder.insert(perspective_projection);
+                active.insert(perspective_projection);
             }
         }
     }
 
-    world_builder.with_children(|parent| {
+    active.with_children(|parent| {
         if let Some(mesh) = node.mesh() {
             // append primitives
             for primitive in mesh.primitives() {
diff --git a/crates/bevy_render/src/mesh/mesh.rs b/crates/bevy_render/src/mesh/mesh.rs
index e0fa7fccadefe..04cc106180359 100644
--- a/crates/bevy_render/src/mesh/mesh.rs
+++ b/crates/bevy_render/src/mesh/mesh.rs
@@ -45,8 +45,6 @@ impl VertexAttributeValues {
     /// mesh, all of the VertexAttributeValues must have the same length.
     pub fn len(&self) -> usize {
         match *self {
-            VertexAttributeValues::Uchar4(ref values) => values.len(),
-            VertexAttributeValues::Ushort4(ref values) => values.len(),
             VertexAttributeValues::Float(ref values) => values.len(),
             VertexAttributeValues::Int(ref values) => values.len(),
             VertexAttributeValues::Uint(ref values) => values.len(),
@@ -74,8 +72,6 @@ impl VertexAttributeValues {
     /// useful for serialization and sending to the GPU.
     pub fn get_bytes(&self) -> &[u8] {
         match self {
-            VertexAttributeValues::Uchar4(values) => values.as_slice().as_bytes(),
-            VertexAttributeValues::Ushort4(values) => values.as_slice().as_bytes(),
             VertexAttributeValues::Float(values) => values.as_slice().as_bytes(),
             VertexAttributeValues::Int(values) => values.as_slice().as_bytes(),
             VertexAttributeValues::Uint(values) => values.as_slice().as_bytes(),
@@ -97,8 +93,6 @@ impl VertexAttributeValues {
 impl From<&VertexAttributeValues> for VertexFormat {
     fn from(values: &VertexAttributeValues) -> Self {
         match values {
-            VertexAttributeValues::Uchar4(_) => VertexFormat::Uchar4,
-            VertexAttributeValues::Ushort4(_) => VertexFormat::Ushort4,
             VertexAttributeValues::Float(_) => VertexFormat::Float,
             VertexAttributeValues::Int(_) => VertexFormat::Int,
             VertexAttributeValues::Uint(_) => VertexFormat::Uint,
diff --git a/examples/animations/material_animation.rs b/examples/animations/material_animation.rs
index aa62e0799579a..b4fd187820f96 100644
--- a/examples/animations/material_animation.rs
+++ b/examples/animations/material_animation.rs
@@ -1,5 +1,5 @@
-use bevy::animation::{tracks::TrackVariableLinear, AddAnimated, Animator, Clip};
-use bevy::prelude::*;
+use bevy::animation::{AddAnimated, Animator, Clip};
+use bevy::{math::curves::CurveVariableLinear, prelude::*};
 
 fn main() {
     App::build()
@@ -10,7 +10,7 @@ fn main() {
 }
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut clips: ResMut<Assets<Clip>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
@@ -19,7 +19,7 @@ fn setup(
     let mut clip = Clip::default();
     clip.add_track_at_path(
         "@Handle<StandardMaterial>.albedo",
-        TrackVariableLinear::from_line(0.0, 1.0, Color::WHITE, Color::ORANGE_RED),
+        CurveVariableLinear::from_line(0.0, 1.0, Color::WHITE, Color::ORANGE_RED),
     );
     let clip_handle = clips.add(clip);
 
@@ -29,7 +29,7 @@ fn setup(
 
     // Animated sphere
     commands
-        .spawn(PbrBundle {
+        .spawn_bundle(PbrBundle {
             mesh: meshes.add(Mesh::from(shape::Icosphere {
                 radius: 1.0,
                 subdivisions: 5,
@@ -38,20 +38,20 @@ fn setup(
             material: materials.add(Color::rgb(0.1, 0.05, 0.0).into()),
             ..Default::default()
         })
-        .with(animator);
+        .insert(animator);
 
     // Camera and Light
-    commands
-        .spawn(LightBundle {
-            transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
-            ..Default::default()
-        })
-        .spawn(PerspectiveCameraBundle {
-            transform: Transform::from_matrix(Mat4::face_toward(
-                Vec3::new(-3.0, 5.0, 8.0),
-                Vec3::new(0.0, 0.0, 0.0),
-                Vec3::new(0.0, 1.0, 0.0),
-            )),
-            ..Default::default()
-        });
+    commands.spawn_bundle(LightBundle {
+        transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
+        ..Default::default()
+    });
+
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_matrix(Mat4::face_toward(
+            Vec3::new(-3.0, 5.0, 8.0),
+            Vec3::new(0.0, 0.0, 0.0),
+            Vec3::new(0.0, 1.0, 0.0),
+        )),
+        ..Default::default()
+    });
 }
diff --git a/examples/animations/mesh_swap_animation.rs b/examples/animations/mesh_swap_animation.rs
index 442a0a5721d9d..1ec5fa4411021 100644
--- a/examples/animations/mesh_swap_animation.rs
+++ b/examples/animations/mesh_swap_animation.rs
@@ -1,5 +1,5 @@
-use bevy::animation::{tracks::TrackVariableLinear, AddAnimated, Animator, Clip};
-use bevy::prelude::*;
+use bevy::animation::{AddAnimated, Animator, Clip};
+use bevy::{math::curves::CurveVariableLinear, prelude::*};
 
 fn main() {
     App::build()
@@ -10,7 +10,7 @@ fn main() {
 }
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut clips: ResMut<Assets<Clip>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
@@ -27,7 +27,7 @@ fn setup(
     let mut clip = Clip::default();
     clip.add_track_at_path(
         "@Handle<Mesh>",
-        TrackVariableLinear::new(
+        CurveVariableLinear::new(
             vec![0.0, 0.5, 1.0],
             vec![cube.clone(), sphere, cube.clone()],
         ),
@@ -39,25 +39,25 @@ fn setup(
     animator.add_layer(clip_handle, 1.0);
 
     commands
-        .spawn(PbrBundle {
+        .spawn_bundle(PbrBundle {
             mesh: cube,
             transform: Transform::from_translation(Vec3::new(0.0, 0.0, 0.0)),
             material: materials.add(Color::ANTIQUE_WHITE.into()),
             ..Default::default()
         })
-        .with(animator);
+        .insert(animator);
 
-    commands
-        .spawn(LightBundle {
-            transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
-            ..Default::default()
-        })
-        .spawn(PerspectiveCameraBundle {
-            transform: Transform::from_matrix(Mat4::face_toward(
-                Vec3::new(-3.0, 5.0, 8.0),
-                Vec3::new(0.0, 0.0, 0.0),
-                Vec3::new(0.0, 1.0, 0.0),
-            )),
-            ..Default::default()
-        });
+    commands.spawn_bundle(LightBundle {
+        transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
+        ..Default::default()
+    });
+
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_matrix(Mat4::face_toward(
+            Vec3::new(-3.0, 5.0, 8.0),
+            Vec3::new(0.0, 0.0, 0.0),
+            Vec3::new(0.0, 1.0, 0.0),
+        )),
+        ..Default::default()
+    });
 }
diff --git a/examples/animations/run_animation.rs b/examples/animations/run_animation.rs
index 41442a1b1d3e5..254210fa3905c 100644
--- a/examples/animations/run_animation.rs
+++ b/examples/animations/run_animation.rs
@@ -10,35 +10,37 @@ fn main() {
 }
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    commands
-        // plane
-        .spawn(PbrBundle {
-            mesh: meshes.add(Mesh::from(shape::Plane { size: 20.0 })),
-            transform: Transform::from_translation(Vec3::new(0.0, -1.0, 0.0)),
-            material: materials.add(Color::rgb(0.1, 0.05, 0.0).into()),
-            ..Default::default()
-        })
-        // light
-        .spawn(LightBundle {
-            transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
-            ..Default::default()
-        })
-        // camera
-        .spawn(PerspectiveCameraBundle {
-            transform: Transform::from_matrix(Mat4::face_toward(
-                Vec3::new(-3.0, 5.0, 8.0),
-                Vec3::new(0.0, 0.0, 0.0),
-                Vec3::new(0.0, 1.0, 0.0),
-            )),
-            ..Default::default()
-        })
-        // character
-        .spawn_scene(asset_server.load("models/character_medium/character_medium.gltf#Scene0"));
+    // plane
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Plane { size: 20.0 })),
+        transform: Transform::from_translation(Vec3::new(0.0, -1.0, 0.0)),
+        material: materials.add(Color::rgb(0.1, 0.05, 0.0).into()),
+        ..Default::default()
+    });
+
+    // light
+    commands.spawn_bundle(LightBundle {
+        transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
+        ..Default::default()
+    });
+
+    // camera
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_matrix(Mat4::face_toward(
+            Vec3::new(-3.0, 5.0, 8.0),
+            Vec3::new(0.0, 0.0, 0.0),
+            Vec3::new(0.0, 1.0, 0.0),
+        )),
+        ..Default::default()
+    });
+
+    // character
+    commands.spawn_scene(asset_server.load("models/character_medium/character_medium.gltf#Scene0"));
 }
 
 fn anim_set(asset_server: Res<AssetServer>, mut animators_query: Query<(&mut Animator,)>) {

From 99883b05cf49e82302d6016e46c75f13062ec05a Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 11 Apr 2021 01:55:47 -0300
Subject: [PATCH 116/153] fixed animations, skinned mesh and gltf load

---
 crates/bevy_animation/src/app.rs              |  7 +-
 .../bevy_animation/src/forward_skinned.vert   |  2 +-
 crates/bevy_gltf/src/loader.rs                | 71 +++++++++----------
 examples/animations/run_animation.rs          |  8 ++-
 4 files changed, 45 insertions(+), 43 deletions(-)

diff --git a/crates/bevy_animation/src/app.rs b/crates/bevy_animation/src/app.rs
index a4096fd235352..86f4225903165 100644
--- a/crates/bevy_animation/src/app.rs
+++ b/crates/bevy_animation/src/app.rs
@@ -10,7 +10,8 @@ use std::{
 };
 
 use crate::{
-    animator::AnimatorRegistry, blending::Blend, reflect, AnimationStage, AnimatorPropertyRegistry,
+    animator::AnimatorRegistry, blending::Blend, reflect, AnimationStage, AnimationSystem,
+    AnimatorPropertyRegistry,
 };
 
 // TODO: Find a way of lifting the `Default` bound on `register_animated_component` and `register_animated_asset` functions
@@ -57,7 +58,7 @@ impl AddAnimated for AppBuilder {
                 AnimationStage::Animate,
                 reflect::animate_component_system::<T>
                     .system()
-                    .after("animator_update"),
+                    .after(AnimationSystem::Animate),
             );
             self
         } else {
@@ -97,7 +98,7 @@ impl AddAnimated for AppBuilder {
                 AnimationStage::Animate,
                 reflect::animate_asset_system::<T>
                     .system()
-                    .after("animator_update"),
+                    .after(AnimationSystem::Animate),
             );
             self
         } else {
diff --git a/crates/bevy_animation/src/forward_skinned.vert b/crates/bevy_animation/src/forward_skinned.vert
index 30200bff624ab..ff4b2bf5646d4 100644
--- a/crates/bevy_animation/src/forward_skinned.vert
+++ b/crates/bevy_animation/src/forward_skinned.vert
@@ -10,7 +10,7 @@ layout(location = 0) out vec3 v_Position;
 layout(location = 1) out vec3 v_Normal;
 layout(location = 2) out vec2 v_Uv;
 
-layout(set = 0, binding = 0) uniform Camera {
+layout(set = 0, binding = 0) uniform CameraViewProj {
     mat4 ViewProj;
 };
 
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index ebe00ac639309..3b9669dbcfa57 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -159,13 +159,12 @@ async fn load_gltf<'a, 'b>(
                     mesh.set_indices(Some(Indices::U32(indices.into_u32().collect())));
                 };
 
-                // TODO: Missing Uchar4
-                // if let Some(color_attribute) = reader
-                //     .read_colors(0)
-                //     .map(|v| VertexAttributeValues::Uchar4(v.into_rgba_u8().collect()))
-                // {
-                //     mesh.set_attribute(Mesh::ATTRIBUTE_COLOR, color_attribute);
-                // }
+                if let Some(color_attribute) = reader
+                    .read_colors(0)
+                    .map(|v| VertexAttributeValues::Uchar4Norm(v.into_rgba_u8().collect()))
+                {
+                    mesh.set_attribute(Mesh::ATTRIBUTE_COLOR, color_attribute);
+                }
 
                 if let Some(weight_attribute) = reader
                     .read_weights(0)
@@ -403,13 +402,13 @@ async fn load_gltf<'a, 'b>(
         clips_handles.push(load_context.get_handle(path));
     }
 
+    // Each node will be mapped to a slot inside this `entity_lookup`
+    let mut entity_lookup = vec![];
+    entity_lookup.resize_with(gltf.nodes().count(), || None);
+
     let mut scenes = vec![];
     let mut named_scenes = HashMap::new();
     for scene in gltf.scenes() {
-        // Each node will be mapped to a slot inside this `entity_lookup`
-        let mut entity_lookup = vec![];
-        entity_lookup.resize_with(gltf.nodes().count(), || None);
-
         let mut world = World::default();
 
         // Scene root
@@ -428,34 +427,12 @@ async fn load_gltf<'a, 'b>(
         });
 
         // Scene animator component
-        if clips_handles.len() > 0 {
-            let mut animator = Animator::default();
-            for clip_handle in &clips_handles {
-                animator.add_clip(clip_handle.clone());
-            }
-            root.insert(animator);
-        }
-
-        // Scene skins
-        for node in scene.nodes() {
-            if let Some(skin) = node.skin() {
-                let mut active = world.entity_mut(entity_lookup[node.index()].unwrap());
-
-                let skin_label = skin_label(&skin);
-                let skin_asset_path = AssetPath::new_ref(load_context.path(), Some(&skin_label));
-                let skin_handle: Handle<SkinAsset> = load_context.get_handle(skin_asset_path);
-                active.insert(skin_handle);
-
-                // TODO: Mesh skinner needs a at least a reference to the skeleton root for it to work
-                // for this reason it need to keep track of all entities created by their index in the gltf node vec
-                let skeleton_root = skin.skeleton().map_or(0, |n| n.index());
-                active.insert(SkinComponent::with_root(
-                    entity_lookup[skeleton_root].expect("missing skeleton root entity"),
-                ));
-
-                active.insert(SkinDebugger::default());
-            }
+        // ? NOTE: Animation clips may be inside another file, so always add an Animator component
+        let mut animator = Animator::default();
+        for clip_handle in &clips_handles {
+            animator.add_clip(clip_handle.clone());
         }
+        root.insert(animator);
 
         let scene_handle = load_context
             .set_labeled_asset(&scene_label(&scene), LoadedAsset::new(Scene::new(world)));
@@ -588,6 +565,24 @@ fn load_node(
         active.insert(Name::new(name.to_string()));
     }
 
+    if let Some(skin) = node.skin() {
+        let skin_label = skin_label(&skin);
+        let skin_asset_path = AssetPath::new_ref(load_context.path(), Some(&skin_label));
+        let skin_handle: Handle<SkinAsset> = load_context.get_handle(skin_asset_path);
+        active.insert(skin_handle);
+
+        // TODO: Mesh skinner needs a at least a reference to the skeleton root for it to work
+        // for this reason it need to keep track of all entities created by their index in the gltf node vec
+        let skeleton_root = skin
+            .skeleton()
+            .map_or_else(|| root_node.index(), |n| n.index());
+        active.insert(SkinComponent::with_root(
+            entity_lookup[skeleton_root].expect("missing skeleton root entity"),
+        ));
+
+        active.insert(SkinDebugger::default());
+    }
+
     // create camera node
     if let Some(camera) = node.camera() {
         active.insert(VisibleEntities {
diff --git a/examples/animations/run_animation.rs b/examples/animations/run_animation.rs
index 254210fa3905c..f6eda6a9338a5 100644
--- a/examples/animations/run_animation.rs
+++ b/examples/animations/run_animation.rs
@@ -1,7 +1,13 @@
-use bevy::{animation::Animator, prelude::*};
+use bevy::{animation::Animator, asset::AssetServerSettings, prelude::*};
 
 fn main() {
     App::build()
+        .insert_resource(AssetServerSettings {
+            asset_folder: format!(
+                "{}/assets",
+                std::env::current_dir().unwrap().to_str().unwrap()
+            ),
+        })
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
         .add_system(anim_set.system().label("anim_set"))

From f52dc95d51ed0468d527a4229725ea1fca5ad976 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 11 Apr 2021 02:03:02 -0300
Subject: [PATCH 117/153] fix tests

---
 crates/bevy_animation/src/animator.rs | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index 3524d71ec265d..f3dadd45b6bdf 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -818,7 +818,7 @@ mod tests {
                 .add_plugin(bevy_transform::TransformPlugin::default())
                 .add_plugin(crate::AnimationPlugin { skinning: false });
 
-            let mut world = World::new();
+            let world = app_builder.world_mut();
             let base = (
                 GlobalTransform::default(),
                 Transform::from_translation(Vec3::new(0.0, 1.0, 0.0)),
@@ -852,10 +852,7 @@ mod tests {
                 clip_b.add_track_at_path("/Node1@Transform.rotation", rot.clone());
                 clip_b.add_track_at_path("/Node1/Node2@Transform.rotation", rot);
 
-                let mut clips = app_builder
-                    .world_mut()
-                    .get_resource_mut::<Assets<Clip>>()
-                    .unwrap();
+                let mut clips = world.get_resource_mut::<Assets<Clip>>().unwrap();
                 let clip_a = clips.add(clip_a);
                 let clip_b = clips.add(clip_b);
 
@@ -903,7 +900,6 @@ mod tests {
                 });
             });
 
-            app_builder.set_world(world);
             app_builder.app.update();
 
             Self {

From cd60401c7961111e6786133a5c566554c30ad8ad Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 11 Apr 2021 02:06:45 -0300
Subject: [PATCH 118/153] fix clippy issues

---
 Cargo.toml                            | 7 ++++---
 crates/bevy_animation/src/animator.rs | 8 ++++----
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 3ab5c397e6d0d..8f8dea7347372 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -460,9 +460,10 @@ path = "examples/animations/run_animation.rs"
 name = "mesh_swap_animation"
 path = "examples/animations/mesh_swap_animation.rs"
 
-[[example]]
-name = "material_animation"
-path = "examples/animations/material_animation.rs"
+# TODO: Enable once Color is sort out
+# [[example]]
+# name = "material_animation"
+# path = "examples/animations/material_animation.rs"
 
 [package.metadata.android]
 apk_label = "Bevy Example"
diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index f3dadd45b6bdf..af41c8e1c4504 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -864,7 +864,7 @@ mod tests {
 
             let root = world
                 .spawn()
-                .insert_bundle(base.clone())
+                .insert_bundle(base)
                 .insert(Name::new("Root"))
                 .insert(animator)
                 .id();
@@ -874,7 +874,7 @@ mod tests {
             world.entity_mut(root).with_children(|world_builder| {
                 entities.push(
                     world_builder
-                        .spawn_bundle(base.clone())
+                        .spawn_bundle(base)
                         .insert(Name::new("Node1"))
                         .id(),
                 );
@@ -883,7 +883,7 @@ mod tests {
                     entities.push(
                         world_builder
                             .spawn()
-                            .insert_bundle(base.clone())
+                            .insert_bundle(base)
                             .insert(Name::new("Node2"))
                             .id(),
                     );
@@ -892,7 +892,7 @@ mod tests {
                         entities.push(
                             world_builder
                                 .spawn()
-                                .insert_bundle(base.clone())
+                                .insert_bundle(base)
                                 .insert(Name::new("Node3"))
                                 .id(),
                         );

From 9a466fe38585f189da7bb689df0741566c548881 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 11 Apr 2021 02:20:29 -0300
Subject: [PATCH 119/153] fix clippy issue

---
 crates/bevy_animation/src/animator.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index af41c8e1c4504..c69b7734fe986 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -1281,7 +1281,7 @@ mod tests {
             KEYFRAMES_PER_CACHE + 3
         );
         assert_eq!(
-            clip.add_track_at_path("zb@T.t", curve.clone()),
+            clip.add_track_at_path("zb@T.t", curve),
             KEYFRAMES_PER_CACHE * 2 + 1
         );
     }

From b697427cd775cbae32762f3717df427bd25f381b Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 11 Apr 2021 02:39:26 -0300
Subject: [PATCH 120/153] clippy please

---
 crates/bevy_gltf/src/loader.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 3b9669dbcfa57..9138c17ada9ce 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -256,10 +256,7 @@ async fn load_gltf<'a, 'b>(
 
         let reader = skin.reader(|buffer| Some(&buffer_data[buffer.index()]));
         if let Some(inverse_bind_matrices) = reader.read_inverse_bind_matrices() {
-            let mut entities_parent_and_name = vec![];
-
-            // Skeleton root node
-            entities_parent_and_name.push((u16::MAX, Name::new("")));
+            let mut entities_parent_and_name = vec![(u16::MAX, Name::new(""))];
 
             for joint in skin.joints() {
                 entities_parent_and_name.push((

From d3757a4567fb7d2d7414d7f5aff0048c73c9aa12 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Tue, 13 Apr 2021 17:48:30 -0300
Subject: [PATCH 121/153] redesign of `CurveVariable`, fix wording

---
 crates/bevy_asset/src/handle.rs               |  46 +++-
 crates/bevy_math/src/curves/fixed.rs          |  61 ++++--
 crates/bevy_math/src/curves/mod.rs            |  12 +-
 crates/bevy_math/src/curves/variable.rs       | 207 ++++++++++++------
 .../bevy_math/src/curves/variable_linear.rs   |  73 ++++--
 .../src/interpolation/interpolate.rs          | 176 +++++++++------
 crates/bevy_math/src/interpolation/lerp.rs    |   6 +-
 crates/bevy_math/src/interpolation/utils.rs   |   6 +-
 8 files changed, 395 insertions(+), 192 deletions(-)

diff --git a/crates/bevy_asset/src/handle.rs b/crates/bevy_asset/src/handle.rs
index 441a3c928358d..879fcbe9069ab 100644
--- a/crates/bevy_asset/src/handle.rs
+++ b/crates/bevy_asset/src/handle.rs
@@ -10,7 +10,7 @@ use crate::{
     Asset, Assets,
 };
 use bevy_ecs::reflect::ReflectComponent;
-use bevy_math::interpolation::{utils::step, Lerp};
+use bevy_math::interpolation::{utils::step_unclamped, Interpolate, Lerp, TangentIgnore};
 use bevy_reflect::{Reflect, ReflectDeserialize};
 use bevy_utils::Uuid;
 use crossbeam_channel::{Receiver, Sender};
@@ -237,7 +237,27 @@ unsafe impl<T: Asset> Sync for Handle<T> {}
 impl<T: Asset + 'static> Lerp for Handle<T> {
     #[inline(always)]
     fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {
-        step(a, b, t)
+        step_unclamped(a, b, t)
+    }
+}
+
+impl<T: Asset + 'static> Interpolate for Handle<T> {
+    type Tangent = TangentIgnore;
+    const FLAT_TANGENT: Self::Tangent = TangentIgnore;
+
+    fn interpolate_unclamped(
+        k0: &Self,
+        _: &Self::Tangent,
+        k1: &Self,
+        _: &Self::Tangent,
+        _: bevy_math::interpolation::Interpolation,
+        t: f32,
+    ) -> Self {
+        step_unclamped(k0, k1, t)
+    }
+
+    fn auto_tangent(_: f32, _: f32, _: f32, _: Self, _: Self, _: Self) -> Self::Tangent {
+        TangentIgnore
     }
 }
 
@@ -351,7 +371,27 @@ impl Clone for HandleUntyped {
 impl Lerp for HandleUntyped {
     #[inline(always)]
     fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {
-        step(a, b, t)
+        step_unclamped(a, b, t)
+    }
+}
+
+impl Interpolate for HandleUntyped {
+    type Tangent = TangentIgnore;
+    const FLAT_TANGENT: Self::Tangent = TangentIgnore;
+
+    fn interpolate_unclamped(
+        k0: &Self,
+        _: &Self::Tangent,
+        k1: &Self,
+        _: &Self::Tangent,
+        _: bevy_math::interpolation::Interpolation,
+        t: f32,
+    ) -> Self {
+        step_unclamped(k0, k1, t)
+    }
+
+    fn auto_tangent(_: f32, _: f32, _: f32, _: Self, _: Self, _: Self) -> Self::Tangent {
+        TangentIgnore
     }
 }
 
diff --git a/crates/bevy_math/src/curves/fixed.rs b/crates/bevy_math/src/curves/fixed.rs
index ac0249a1c765a..ba3d82f47366c 100644
--- a/crates/bevy_math/src/curves/fixed.rs
+++ b/crates/bevy_math/src/curves/fixed.rs
@@ -1,14 +1,15 @@
-use crate::{curves::Curve, interpolation::Lerp};
+use crate::{
+    curves::{Curve, CurveCursor},
+    interpolation::Lerp,
+};
 
 // TODO: impl Serialize, Deserialize
 /// Curve with evenly spaced keyframes, in another words a curve with a fixed frame rate.
 ///
 /// This curve maintains the faster sampling rate over a wide range of frame rates, because
-/// it doesn't rely on keyframe cursor. But as a downside it will have the bigger memory foot print;
+/// it doesn't rely on keyframe cursor. As a downside, it will have a bigger memory foot print.
 #[derive(Default, Debug)]
 pub struct CurveFixed<T> {
-    // ? NOTE: Has I learned from benches casting to f32 is quite expensive
-    // ? so frame rate and offset values must be stored as f32
     frame_rate: f32,
     /// Negative number of frames before the curve starts
     negative_offset: f32,
@@ -42,42 +43,56 @@ impl<T> CurveFixed<T> {
         }
     }
 
+    pub fn keyframes(&self) -> &[T] {
+        &self.keyframes[..]
+    }
+
     pub fn keyframes_mut(&mut self) -> &mut [T] {
         &mut self.keyframes[..]
     }
 
-    // pub fn insert(&mut self, time_sample: f32, value: T) {
-    // }
+    pub fn insert_keyframe(&mut self, index: usize, value: T) {
+        self.keyframes.insert(index, value);
+    }
+
+    pub fn remove_keyframe(&mut self, index: usize) -> T {
+        assert!(self.keyframes.len() > 1, "curve can't be empty");
+        self.keyframes.remove(index)
+    }
+
+    pub fn frame_rate(&self) -> f32 {
+        self.frame_rate
+    }
+
+    pub fn set_frame_rate(&mut self, frame_rate: f32) {
+        self.frame_rate = frame_rate;
+    }
+
+    pub fn set_offset(&mut self, offset: isize) {
+        self.negative_offset = -offset as f32;
+    }
 
-    // pub fn remove(&mut self, index: usize) {
-    //assert!(samples.len() > 1, "curve can't be empty");
-    // }
+    pub fn offset(&self) -> isize {
+        -self.negative_offset as isize
+    }
 
     /// Number of keyframes
     pub fn len(&self) -> usize {
         self.keyframes.len()
     }
 
-    /// True when doesn't have any keyframe
+    /// `true` when this `CurveFixed` doesn't have any keyframe
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
-    pub const fn frame_rate(&self) -> usize {
-        self.frame_rate as usize
+    pub fn iter(&self) -> impl Iterator<Item = &T> {
+        self.keyframes.iter()
     }
 
-    pub fn offset(&self) -> isize {
-        (-self.negative_offset) as isize
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
+        self.keyframes.iter_mut()
     }
-
-    // pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
-    //     self.samples.iter().copied().zip(self.keyframes.iter())
-    // }
-
-    // pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
-    //     self.samples.iter().copied().zip(self.keyframes.iter_mut())
-    // }
 }
 
 impl<T> Curve for CurveFixed<T>
@@ -116,7 +131,7 @@ where
 
     /// Same as `sample` function
     #[inline]
-    fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, Self::Output) {
+    fn sample_with_cursor(&self, cursor: CurveCursor, time: f32) -> (CurveCursor, Self::Output) {
         let _ = cursor;
         (0, self.sample(time))
     }
diff --git a/crates/bevy_math/src/curves/mod.rs b/crates/bevy_math/src/curves/mod.rs
index b490fb0f8adc9..e5023174c1cb2 100644
--- a/crates/bevy_math/src/curves/mod.rs
+++ b/crates/bevy_math/src/curves/mod.rs
@@ -6,19 +6,21 @@ pub use fixed::*;
 pub use variable::*;
 pub use variable_linear::*;
 
+pub type CurveCursor = u16;
+
 pub trait Curve {
     type Output;
 
     fn duration(&self) -> f32;
 
-    /// Easer to use sampling method that don't have time restrictions or needs
-    /// the keyframe cursor, but is more expensive always `O(n)`. Which means
-    /// sampling takes longer to evaluate as much as time get closer to curve duration
-    /// and it get worse with more keyframes.
+    /// Easier to use sampling method that doesn't needs the keyframe cursor,
+    /// but is more expensive in some types of curve, been always `O(n)`.
+    ///
+    /// This means sampling is more expensive to evaluate as the `time` gets bigger;
     fn sample(&self, time: f32) -> Self::Output;
 
     /// Samples the curve starting from some keyframe cursor, this make the common case `O(1)`
     ///
     /// **NOTE** Each keyframe is indexed by a `u16` to reduce memory usage when using the keyframe caching
-    fn sample_with_cursor(&self, cursor: u16, time: f32) -> (u16, Self::Output);
+    fn sample_with_cursor(&self, cursor: u16, time: f32) -> (CurveCursor, Self::Output);
 }
diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index 01a407803d7de..edaa073fc47ed 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -16,18 +16,38 @@ use crate::{
 // http://nfrechette.github.io/2016/12/07/anim_compression_key_reduction/
 // https://github.com/nfrechette/acl
 
+/// Keyframe tangents control mode
+#[derive(Debug, Copy, Clone)]
+pub enum TangentControl {
+    Auto,
+    Free,
+    Broken,
+    InBroken,
+    OutBroken,
+}
+
+impl Default for TangentControl {
+    fn default() -> Self {
+        TangentControl::Auto
+    }
+}
+
 // TODO: impl Serialize, Deserialize
 /// Curve with sparse keyframes frames, in another words a curve with variable frame rate;
 ///
 /// Similar in design to the [`CurveVariableLinear`](super::CurveVariableLinear) but allows
 /// for smoother catmull-rom interpolations using tangents, which can further reduce the number of keyframes at
 /// the cost of performance.
+///
+/// **NOTE** Keyframes count is limited by the [`CurveCursor`] size.
 #[derive(Default, Debug)]
 pub struct CurveVariable<T: Interpolate> {
     time_stamps: Vec<f32>,
     keyframes: Vec<T>,
-    /// Defines the interpolation for each keyframe pair
-    interpolations: Vec<Interpolation<T::Tangent>>,
+    modes: Vec<Interpolation>,
+    tangents_control: Vec<TangentControl>,
+    tangents_in: Vec<T::Tangent>,
+    tangents_out: Vec<T::Tangent>,
 }
 
 impl<T> Clone for CurveVariable<T>
@@ -39,79 +59,134 @@ where
         Self {
             time_stamps: self.time_stamps.clone(),
             keyframes: self.keyframes.clone(),
-            interpolations: self.interpolations.clone(),
+            modes: self.modes.clone(),
+            tangents_control: self.tangents_control.clone(),
+            tangents_in: self.tangents_in.clone(),
+            tangents_out: self.tangents_out.clone(),
         }
     }
 }
 
-// impl<T> CurveVariableInterpolated<T> {
-//     pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
-//         // TODO: Result?
+impl<T> CurveVariable<T>
+where
+    T: Interpolate + Clone,
+{
+    pub fn with_auto_tangents(samples: Vec<f32>, values: Vec<T>) -> Self {
+        // TODO: Result?
 
-//         // Make sure both have the same length
-//         assert!(
-//             samples.len() == values.len(),
-//             "samples and values must have the same length"
-//         );
+        let length = samples.len();
 
-//         assert!(
-//             values.len() <= u16::MAX as usize,
-//             "limit of {} keyframes exceeded",
-//             u16::MAX
-//         );
+        // Make sure both have the same length
+        assert!(
+            length == values.len(),
+            "samples and values must have the same length"
+        );
 
-//         assert!(samples.len() > 0, "empty curve");
+        assert!(
+            values.len() <= u16::MAX as usize,
+            "limit of {} keyframes exceeded",
+            u16::MAX
+        );
 
-//         // Make sure the
-//         assert!(
-//             samples
-//                 .iter()
-//                 .zip(samples.iter().skip(1))
-//                 .all(|(a, b)| a < b),
-//             "time samples must be on ascending order"
-//         );
-//         Self {
-//             time_stamps: samples,
-//             keyframes: values,
-//         }
-//     }
+        assert!(length > 0, "empty curve");
 
-//     pub fn from_line(t0: f32, t1: f32, v0: T, v1: T) -> Self {
-//         Self {
-//             time_stamps: if t1 >= t0 { vec![t0, t1] } else { vec![t1, t0] },
-//             keyframes: vec![v0, v1],
-//         }
-//     }
+        // Make sure the
+        assert!(
+            samples
+                .iter()
+                .zip(samples.iter().skip(1))
+                .all(|(a, b)| a < b),
+            "time samples must be on ascending order"
+        );
 
-//     pub fn from_constant(v: T) -> Self {
-//         Self {
-//             time_stamps: vec![0.0],
-//             keyframes: vec![v],
-//         }
-//     }
+        let mut tangents = Vec::with_capacity(length);
+        if length == 1 {
+            tangents.push(T::FLAT_TANGENT);
+        } else {
+            for i in 0..length {
+                let p = if i > 0 { i - 1 } else { length - 1 };
+                let n = if (i + 1) < length { i + 1 } else { 0 };
+                tangents.push(T::auto_tangent(
+                    samples[p],
+                    samples[i],
+                    samples[n],
+                    values[p].clone(),
+                    values[i].clone(),
+                    values[n].clone(),
+                ));
+            }
+        }
 
-//     // pub fn insert(&mut self, time_sample: f32, value: T) {
-//     // }
+        let mut tangents_control = Vec::with_capacity(length);
+        tangents_control.resize(length, TangentControl::Auto);
 
-//     // pub fn remove(&mut self, index: usize) {
-//     //assert!(samples.len() > 1, "curve can't be empty");
-//     // }
+        let mut modes = Vec::with_capacity(length);
+        modes.resize(length, Interpolation::CatmullRom);
 
-//     pub fn add_offset_time(&mut self, time_offset: f32) {
-//         self.time_stamps.iter_mut().for_each(|t| *t += time_offset);
-//     }
+        Self {
+            time_stamps: samples,
+            keyframes: values,
+            modes,
+            tangents_control,
+            tangents_in: tangents.clone(),
+            tangents_out: tangents,
+        }
+    }
 
-//     pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
-//         self.time_stamps.iter().copied().zip(self.keyframes.iter())
-//     }
+    pub fn from_line(t0: f32, t1: f32, v0: T, v1: T) -> Self {
+        let mut modes = Vec::with_capacity(2);
+        modes.resize(2, Interpolation::Linear);
 
-//     pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
-//         self.time_stamps
-//             .iter()
-//             .copied()
-//             .zip(self.keyframes.iter_mut())
-//     }
-// }
+        let mut tangents_control = Vec::with_capacity(2);
+        tangents_control.resize(2, TangentControl::Auto);
+
+        let mut tangents = Vec::with_capacity(2);
+        tangents.resize(2, T::FLAT_TANGENT);
+
+        if t0 < t1 {
+            Self {
+                time_stamps: vec![t0, t1],
+                keyframes: vec![v0, v1],
+                modes,
+                tangents_control,
+                tangents_in: tangents.clone(),
+                tangents_out: tangents,
+            }
+        } else {
+            Self {
+                time_stamps: vec![t1, t0],
+                keyframes: vec![v1, v0],
+                modes,
+                tangents_control,
+                tangents_in: tangents.clone(),
+                tangents_out: tangents,
+            }
+        }
+    }
+
+    pub fn from_constant(v: T) -> Self {
+        Self {
+            time_stamps: vec![0.0],
+            keyframes: vec![v],
+            modes: vec![Interpolation::CatmullRom],
+            tangents_control: vec![TangentControl::Auto],
+            tangents_in: vec![T::FLAT_TANGENT],
+            tangents_out: vec![T::FLAT_TANGENT],
+        }
+    }
+
+    // TODO: Edit methods
+
+    /// Make sure the first keyframe starts at time `0.0`
+    #[inline]
+    pub fn remove_time_offset(&mut self) {
+        self.apply_time_offset(-self.time_stamps[0]);
+    }
+
+    pub fn apply_time_offset(&mut self, time_offset: f32) {
+        self.time_stamps.iter_mut().for_each(|t| *t += time_offset);
+    }
+}
 
 impl<T> Curve for CurveVariable<T>
 where
@@ -177,10 +252,14 @@ where
             t
         ); // Checks if it's required to normalize t
 
-        let value = T::interpolate(
-            &self.keyframes[i as usize],
-            &self.keyframes[cursor as usize],
-            &self.interpolations[i as usize],
+        let a = i as usize;
+        let b = cursor as usize;
+        let value = T::interpolate_unclamped(
+            &self.keyframes[a],
+            &self.tangents_out[a],
+            &self.keyframes[b],
+            &self.tangents_in[b],
+            self.modes[a as usize],
             t,
         );
 
diff --git a/crates/bevy_math/src/curves/variable_linear.rs b/crates/bevy_math/src/curves/variable_linear.rs
index 29d88c6ba7655..6ab763c63450f 100644
--- a/crates/bevy_math/src/curves/variable_linear.rs
+++ b/crates/bevy_math/src/curves/variable_linear.rs
@@ -1,5 +1,7 @@
-use super::Curve;
-use crate::interpolation::Lerp;
+use crate::{
+    curves::{Curve, CurveCursor},
+    interpolation::Lerp,
+};
 
 // TODO: Curve/Clip need a validation during deserialization because they are
 // structured as SOA (struct of arrays), so the vec's length must match
@@ -7,9 +9,11 @@ use crate::interpolation::Lerp;
 // TODO: impl Serialize, Deserialize
 /// Curve with sparse keyframes frames, in another words a curve with variable frame rate;
 ///
-/// Very useful curve, because can accommodate the output of a linear reduction keyframe algorithm
-/// to lower the memory foot print. But as a down side require the use of keyframe cursor, and
-/// loses performance when the curve frame rate is higher than the curve sampling frame rate
+/// This is a very useful curve, because it can accommodate the output of a linear reduction keyframe algorithm
+/// to lower the memory foot print. As a down side it requires the use of a keyframe cursor, and
+/// loses performance when the curve frame rate is higher than the curve sampling frame rate;
+///
+/// **NOTE** Keyframes count is limited by the [`CurveCursor`] size.
 #[derive(Default, Debug)]
 pub struct CurveVariableLinear<T> {
     time_stamps: Vec<f32>,
@@ -36,9 +40,9 @@ impl<T> CurveVariableLinear<T> {
         );
 
         assert!(
-            values.len() <= u16::MAX as usize,
+            values.len() <= CurveCursor::MAX as usize,
             "limit of {} keyframes exceeded",
-            u16::MAX
+            CurveCursor::MAX
         );
 
         assert!(!samples.is_empty(), "empty curve");
@@ -59,9 +63,16 @@ impl<T> CurveVariableLinear<T> {
     }
 
     pub fn from_line(t0: f32, t1: f32, v0: T, v1: T) -> Self {
-        Self {
-            time_stamps: if t1 >= t0 { vec![t0, t1] } else { vec![t1, t0] },
-            keyframes: vec![v0, v1],
+        if t0 < t1 {
+            Self {
+                time_stamps: vec![t0, t1],
+                keyframes: vec![v0, v1],
+            }
+        } else {
+            Self {
+                time_stamps: vec![t1, t0],
+                keyframes: vec![v1, v0],
+            }
         }
     }
 
@@ -72,14 +83,34 @@ impl<T> CurveVariableLinear<T> {
         }
     }
 
-    // pub fn insert(&mut self, time_sample: f32, value: T) {
-    // }
+    pub fn insert(&mut self, time: f32, value: T) {
+        // Keyframe length is limited by the cursor size yype that is 2 bytes,
+        assert!(
+            self.keyframes.len() < CurveCursor::MAX as usize,
+            "reached keyframe limit"
+        );
+
+        if let Some(index) = self.time_stamps.iter().position(|t| time < *t) {
+            self.time_stamps.insert(index, time);
+            self.keyframes.insert(index, value);
+        } else {
+            self.time_stamps.push(time);
+            self.keyframes.push(value);
+        }
+    }
+
+    pub fn remove(&mut self, index: usize) -> (f32, T) {
+        assert!(self.time_stamps.len() > 1, "curve can't be empty");
+        (self.time_stamps.remove(index), self.keyframes.remove(index))
+    }
 
-    // pub fn remove(&mut self, index: usize) {
-    //assert!(samples.len() > 1, "curve can't be empty");
-    // }
+    /// Make sure the first keyframe starts at time `0.0`
+    #[inline]
+    pub fn remove_time_offset(&mut self) {
+        self.apply_time_offset(-self.time_stamps[0]);
+    }
 
-    pub fn add_offset_time(&mut self, time_offset: f32) {
+    pub fn apply_time_offset(&mut self, time_offset: f32) {
         self.time_stamps.iter_mut().for_each(|t| *t += time_offset);
     }
 
@@ -113,12 +144,16 @@ where
             self.time_stamps.len() - 1
         };
 
-        self.sample_with_cursor(index as u16, time).1
+        self.sample_with_cursor(index as CurveCursor, time).1
     }
 
-    fn sample_with_cursor(&self, mut cursor: u16, time: f32) -> (u16, Self::Output) {
+    fn sample_with_cursor(
+        &self,
+        mut cursor: CurveCursor,
+        time: f32,
+    ) -> (CurveCursor, Self::Output) {
         // Adjust for the current keyframe index
-        let last_cursor = (self.time_stamps.len() - 1) as u16;
+        let last_cursor = (self.time_stamps.len() - 1) as CurveCursor;
 
         cursor = cursor.max(0).min(last_cursor);
         if self.time_stamps[cursor as usize] < time {
diff --git a/crates/bevy_math/src/interpolation/interpolate.rs b/crates/bevy_math/src/interpolation/interpolate.rs
index 44b34643e3a69..0aa82ac0eccce 100644
--- a/crates/bevy_math/src/interpolation/interpolate.rs
+++ b/crates/bevy_math/src/interpolation/interpolate.rs
@@ -1,105 +1,119 @@
-use crate::{interpolation::utils, Quat, Vec2, Vec3, Vec4};
+use super::{utils, Lerp};
+use crate::{Quat, Vec2, Vec3, Vec4};
 
 // http://archive.gamedev.net/archive/reference/articles/article1497.html (bit old)
 
+#[derive(Debug, Copy, Clone)]
 pub struct TangentIgnore;
 
-#[derive(Debug)]
-pub enum Interpolation<T> {
+#[derive(Debug, Copy, Clone)]
+pub enum Interpolation {
     Step,
     Linear,
-    /// Right tangent for the current keyframe and left tangent of the next keyframe
-    Smooth {
-        right: T,
-        left: T,
-    },
+    CatmullRom,
 }
 
-impl<T: Clone> Clone for Interpolation<T> {
-    fn clone(&self) -> Self {
-        match self {
-            Interpolation::Step => Interpolation::Step,
-            Interpolation::Linear => Interpolation::Linear,
-            Interpolation::Smooth { right, left } => Interpolation::Smooth {
-                right: right.clone(),
-                left: left.clone(),
-            },
-        }
+pub trait Interpolate: Lerp + Clone {
+    type Tangent: Copy;
+
+    const FLAT_TANGENT: Self::Tangent;
+
+    #[inline]
+    fn interpolate(
+        k0: &Self,
+        t0: &Self::Tangent,
+        k1: &Self,
+        t1: &Self::Tangent,
+        interp: Interpolation,
+        t: f32,
+    ) -> Self {
+        Self::interpolate_unclamped(k0, t0, k1, t1, interp, t.clamp(0.0, 1.0))
     }
-}
 
-pub trait Interpolate {
-    type Tangent;
+    fn interpolate_unclamped(
+        k0: &Self,
+        t0: &Self::Tangent,
+        k1: &Self,
+        t1: &Self::Tangent,
+        interp: Interpolation,
+        t: f32,
+    ) -> Self;
 
-    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self;
+    fn auto_tangent(t0: f32, t1: f32, t2: f32, k0: Self, k1: Self, k2: Self) -> Self::Tangent;
 }
 
 impl Interpolate for bool {
     type Tangent = TangentIgnore;
+    const FLAT_TANGENT: Self::Tangent = TangentIgnore;
 
     #[inline]
-    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
-        let _ = interp;
+    fn interpolate_unclamped(
+        k0: &Self,
+        _: &Self::Tangent,
+        k1: &Self,
+        _: &Self::Tangent,
+        _: Interpolation,
+        t: f32,
+    ) -> Self {
         if t > 0.99 {
             *k0
         } else {
             *k1
         }
     }
-}
-
-impl Interpolate for f32 {
-    type Tangent = Self;
 
-    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
-        match interp {
-            Interpolation::Step => utils::step(k0, k1, t),
-            Interpolation::Linear => utils::lerp(t * k0, *k1, t),
-            Interpolation::Smooth { right, left } => utils::catmull_rom(*k0, *right, *k1, *left, t),
-        }
-    }
-}
-
-impl Interpolate for Vec2 {
-    type Tangent = Self;
-
-    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
-        match interp {
-            Interpolation::Step => utils::step(k0, k1, t),
-            Interpolation::Linear => utils::lerp(*k0, *k1, t),
-            Interpolation::Smooth { right, left } => utils::catmull_rom(*k0, *right, *k1, *left, t),
-        }
+    fn auto_tangent(_: f32, _: f32, _: f32, _: Self, _: Self, _: Self) -> Self::Tangent {
+        TangentIgnore
     }
 }
 
-impl Interpolate for Vec3 {
-    type Tangent = Self;
+macro_rules! interpolate {
+    ($ty:ty, $flat:expr) => {
+        impl Interpolate for $ty {
+            type Tangent = Self;
+            const FLAT_TANGENT: Self::Tangent = $flat;
+
+            fn interpolate_unclamped(
+                k0: &Self,
+                t0: &Self::Tangent,
+                k1: &Self,
+                t1: &Self::Tangent,
+                interp: Interpolation,
+                t: f32,
+            ) -> Self {
+                match interp {
+                    Interpolation::Step => utils::step_unclamped(k0, k1, t),
+                    Interpolation::Linear => utils::lerp_unclamped(*k0, *k1, t),
+                    Interpolation::CatmullRom => {
+                        utils::catmull_rom_unclamped(*k0, *t0, *k1, *t1, t)
+                    }
+                }
+            }
 
-    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
-        match interp {
-            Interpolation::Step => utils::step(k0, k1, t),
-            Interpolation::Linear => utils::lerp(*k0, *k1, t),
-            Interpolation::Smooth { right, left } => utils::catmull_rom(*k0, *right, *k1, *left, t),
+            fn auto_tangent(
+                t0: f32,
+                t1: f32,
+                t2: f32,
+                k0: Self,
+                k1: Self,
+                k2: Self,
+            ) -> Self::Tangent {
+                utils::auto_tangent(t0, t1, t2, k0, k1, k2)
+            }
         }
-    }
+    };
 }
 
-impl Interpolate for Vec4 {
-    type Tangent = Self;
-
-    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
-        match interp {
-            Interpolation::Step => utils::step(k0, k1, t),
-            Interpolation::Linear => utils::lerp(*k0, *k1, t),
-            Interpolation::Smooth { right, left } => utils::catmull_rom(*k0, *right, *k1, *left, t),
-        }
-    }
-}
+interpolate!(f32, 0.0);
+interpolate!(Vec2, Vec2::ZERO);
+interpolate!(Vec3, Vec3::ZERO);
+interpolate!(Vec4, Vec4::ZERO);
 
+// TODO: Color can't be interpolated because color operations are undefined, see pr #1870
 // impl Interpolate for Color {
 //     type Tangent = Self;
 
-//     fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
+//     fn interpolate(k0: &Self, k1: &Self, interp: Interpolation, t: f32) -> Self {
 //         match interp {
 //             Interpolation::Step => utils::step(k0, k1, t),
 //             Interpolation::Linear => utils::lerp(*k0, *k1, t),
@@ -113,16 +127,28 @@ impl Interpolate for Vec4 {
 //             .into(),
 //         }
 //     }
+
+//     fn auto_tangent<T>(t0: f32, t1: f32, t2: f32, k0: Self, k1: Self, k2: Self) -> Self::Tangent {
+//         utils::auto_tangent(t0, t1, t2, k0, k1, k2)
+//     }
 // }
 
 impl Interpolate for Quat {
     type Tangent = Self;
+    const FLAT_TANGENT: Self::Tangent = unsafe { std::mem::transmute([0.0f32; 4]) };
 
     /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
     /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
-    fn interpolate(k0: &Self, k1: &Self, interp: &Interpolation<Self::Tangent>, t: f32) -> Self {
+    fn interpolate_unclamped(
+        k0: &Self,
+        t0: &Self::Tangent,
+        k1: &Self,
+        t1: &Self::Tangent,
+        interp: Interpolation,
+        t: f32,
+    ) -> Self {
         match interp {
-            Interpolation::Step => utils::step(k0, k1, t),
+            Interpolation::Step => utils::step_unclamped(k0, k1, t),
             Interpolation::Linear => {
                 // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
                 let mut k1 = *k1;
@@ -130,22 +156,22 @@ impl Interpolate for Quat {
                     k1 = -k1;
                 }
 
-                let q = utils::lerp::<Vec4>((*k0).into(), k1.into(), t);
+                let q = utils::lerp_unclamped::<Vec4>((*k0).into(), k1.into(), t);
                 let d = utils::inv_sqrt(q.dot(q));
                 (q * d).into()
             }
-            Interpolation::Smooth { right, left } => {
+            Interpolation::CatmullRom => {
                 // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
                 let mut k1 = *k1;
                 if k0.dot(k1) < 0.0 {
                     k1 = -k1;
                 }
 
-                let q = utils::catmull_rom::<Vec4>(
+                let q = utils::catmull_rom_unclamped::<Vec4>(
                     (*k0).into(),
-                    (*right).into(),
+                    (*t0).into(),
                     k1.into(),
-                    (*left).into(),
+                    (*t1).into(),
                     t,
                 );
                 let d = utils::inv_sqrt(q.dot(q));
@@ -153,4 +179,8 @@ impl Interpolate for Quat {
             }
         }
     }
+
+    fn auto_tangent(t0: f32, t1: f32, t2: f32, k0: Self, k1: Self, k2: Self) -> Self::Tangent {
+        utils::auto_tangent(t0, t1, t2, k0, k1, k2)
+    }
 }
diff --git a/crates/bevy_math/src/interpolation/lerp.rs b/crates/bevy_math/src/interpolation/lerp.rs
index 27ff8d6ffee51..b235c88ccde8c 100644
--- a/crates/bevy_math/src/interpolation/lerp.rs
+++ b/crates/bevy_math/src/interpolation/lerp.rs
@@ -7,7 +7,7 @@ pub trait Lerp: Sized {
 
     /// Lerp, `t` is clamped in [0; 1] range
     fn lerp(a: &Self, b: &Self, t: f32) -> Self {
-        let t = t.min(1.0).max(0.0);
+        let t = t.clamp(0.0, 1.0);
         Self::lerp_unclamped(a, b, t)
     }
 }
@@ -51,15 +51,17 @@ impl Lerp for Vec4 {
     }
 }
 
+// TODO: Color can't be interpolated because color operations are undefined, see pr #1870
 // impl Lerp for Color {
 //     #[inline]
 //     fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {
+//         // ? NOTE: Make sure alpha is interpolated (pr #1870 Mul and Add doesn't include alpha)
 //         (*a) * (1.0 - t) + (*b) * t
 //     }
 // }
 
 impl Lerp for Quat {
-    /// Performs an nlerp, because it's much cheaper and easer to combine with other animations,
+    /// Performs an nlerp, because it's cheaper and easier to combine with other animations,
     /// reference: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/
     #[inline]
     fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {
diff --git a/crates/bevy_math/src/interpolation/utils.rs b/crates/bevy_math/src/interpolation/utils.rs
index 078768ac03cfa..21d9c5b2f270b 100644
--- a/crates/bevy_math/src/interpolation/utils.rs
+++ b/crates/bevy_math/src/interpolation/utils.rs
@@ -17,7 +17,7 @@ pub fn inv_sqrt(x: f32) -> f32 {
 }
 
 #[inline]
-pub fn step<T: Clone>(k0: &T, k1: &T, u: f32) -> T {
+pub fn step_unclamped<T: Clone>(k0: &T, k1: &T, u: f32) -> T {
     if u > 0.999 {
         k0.clone()
     } else {
@@ -26,7 +26,7 @@ pub fn step<T: Clone>(k0: &T, k1: &T, u: f32) -> T {
 }
 
 #[inline]
-pub fn lerp<T>(k0: T, k1: T, u: f32) -> T
+pub fn lerp_unclamped<T>(k0: T, k1: T, u: f32) -> T
 where
     T: Add<Output = T> + Mul<f32, Output = T>,
 {
@@ -37,7 +37,7 @@ where
 ///
 /// Source: http://archive.gamedev.net/archive/reference/articles/article1497.html
 #[inline]
-pub fn catmull_rom<T>(k0: T, t0: T, k1: T, t1: T, u: f32) -> T
+pub fn catmull_rom_unclamped<T>(k0: T, t0: T, k1: T, t1: T, u: f32) -> T
 where
     T: Add<Output = T> + Sub<Output = T> + Mul<f32, Output = T>,
 {

From 2a02a129ceb04ff7db0b83d0bde0bfb35f38f615 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Tue, 13 Apr 2021 22:35:33 -0300
Subject: [PATCH 122/153] update auto tangents

---
 crates/bevy_asset/src/handle.rs               |  4 +--
 crates/bevy_math/src/curves/variable.rs       | 35 +++++++++++++++----
 .../src/interpolation/interpolate.rs          | 18 +++++-----
 3 files changed, 40 insertions(+), 17 deletions(-)

diff --git a/crates/bevy_asset/src/handle.rs b/crates/bevy_asset/src/handle.rs
index 879fcbe9069ab..f4550c8e669a9 100644
--- a/crates/bevy_asset/src/handle.rs
+++ b/crates/bevy_asset/src/handle.rs
@@ -256,7 +256,7 @@ impl<T: Asset + 'static> Interpolate for Handle<T> {
         step_unclamped(k0, k1, t)
     }
 
-    fn auto_tangent(_: f32, _: f32, _: f32, _: Self, _: Self, _: Self) -> Self::Tangent {
+    fn auto_tangent(_: f32, _: f32, _: f32, _: &Self, _: &Self, _: &Self) -> Self::Tangent {
         TangentIgnore
     }
 }
@@ -390,7 +390,7 @@ impl Interpolate for HandleUntyped {
         step_unclamped(k0, k1, t)
     }
 
-    fn auto_tangent(_: f32, _: f32, _: f32, _: Self, _: Self, _: Self) -> Self::Tangent {
+    fn auto_tangent(_: f32, _: f32, _: f32, _: &Self, _: &Self, _: &Self) -> Self::Tangent {
         TangentIgnore
     }
 }
diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index edaa073fc47ed..e0649a339e150 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -69,7 +69,7 @@ where
 
 impl<T> CurveVariable<T>
 where
-    T: Interpolate + Clone,
+    T: Interpolate,
 {
     pub fn with_auto_tangents(samples: Vec<f32>, values: Vec<T>) -> Self {
         // TODO: Result?
@@ -107,12 +107,7 @@ where
                 let p = if i > 0 { i - 1 } else { length - 1 };
                 let n = if (i + 1) < length { i + 1 } else { 0 };
                 tangents.push(T::auto_tangent(
-                    samples[p],
-                    samples[i],
-                    samples[n],
-                    values[p].clone(),
-                    values[i].clone(),
-                    values[n].clone(),
+                    samples[p], samples[i], samples[n], &values[p], &values[i], &values[n],
                 ));
             }
         }
@@ -177,6 +172,32 @@ where
 
     // TODO: Edit methods
 
+    /// Updates keyframes marked with `TangentControl::Auto`
+    pub fn update_tangents(&mut self) {
+        let length = self.keyframes.len();
+        if length == 1 {
+            self.tangents_in[0] = T::FLAT_TANGENT;
+            self.tangents_out[0] = T::FLAT_TANGENT;
+        } else {
+            for i in 0..length {
+                let p = if i > 0 { i - 1 } else { length - 1 };
+                let n = if (i + 1) < length { i + 1 } else { 0 };
+
+                let tangent = T::auto_tangent(
+                    self.time_stamps[p],
+                    self.time_stamps[i],
+                    self.time_stamps[n],
+                    &self.keyframes[p].clone(),
+                    &self.keyframes[i].clone(),
+                    &self.keyframes[n].clone(),
+                );
+
+                self.tangents_in[i] = tangent;
+                self.tangents_out[i] = tangent;
+            }
+        }
+    }
+
     /// Make sure the first keyframe starts at time `0.0`
     #[inline]
     pub fn remove_time_offset(&mut self) {
diff --git a/crates/bevy_math/src/interpolation/interpolate.rs b/crates/bevy_math/src/interpolation/interpolate.rs
index 0aa82ac0eccce..2264533d1190b 100644
--- a/crates/bevy_math/src/interpolation/interpolate.rs
+++ b/crates/bevy_math/src/interpolation/interpolate.rs
@@ -39,7 +39,7 @@ pub trait Interpolate: Lerp + Clone {
         t: f32,
     ) -> Self;
 
-    fn auto_tangent(t0: f32, t1: f32, t2: f32, k0: Self, k1: Self, k2: Self) -> Self::Tangent;
+    fn auto_tangent(t0: f32, t1: f32, t2: f32, k0: &Self, k1: &Self, k2: &Self) -> Self::Tangent;
 }
 
 impl Interpolate for bool {
@@ -62,7 +62,7 @@ impl Interpolate for bool {
         }
     }
 
-    fn auto_tangent(_: f32, _: f32, _: f32, _: Self, _: Self, _: Self) -> Self::Tangent {
+    fn auto_tangent(_: f32, _: f32, _: f32, _: &Self, _: &Self, _: &Self) -> Self::Tangent {
         TangentIgnore
     }
 }
@@ -90,15 +90,16 @@ macro_rules! interpolate {
                 }
             }
 
+            #[inline]
             fn auto_tangent(
                 t0: f32,
                 t1: f32,
                 t2: f32,
-                k0: Self,
-                k1: Self,
-                k2: Self,
+                k0: &Self,
+                k1: &Self,
+                k2: &Self,
             ) -> Self::Tangent {
-                utils::auto_tangent(t0, t1, t2, k0, k1, k2)
+                utils::auto_tangent(t0, t1, t2, *k0, *k1, *k2)
             }
         }
     };
@@ -180,7 +181,8 @@ impl Interpolate for Quat {
         }
     }
 
-    fn auto_tangent(t0: f32, t1: f32, t2: f32, k0: Self, k1: Self, k2: Self) -> Self::Tangent {
-        utils::auto_tangent(t0, t1, t2, k0, k1, k2)
+    #[inline]
+    fn auto_tangent(t0: f32, t1: f32, t2: f32, k0: &Self, k1: &Self, k2: &Self) -> Self::Tangent {
+        utils::auto_tangent(t0, t1, t2, *k0, *k1, *k2)
     }
 }

From 81a2c08c4f8bfb25f4ae0e5db19dc4c1996db0f0 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Wed, 14 Apr 2021 23:50:10 -0300
Subject: [PATCH 123/153] curve variable example

---
 Cargo.toml                                    |   5 +
 crates/bevy_math/src/curves/variable.rs       |  15 +-
 .../bevy_math/src/curves/variable_linear.rs   |   2 +
 examples/animations/smooth_curves.rs          | 156 ++++++++++++++++++
 4 files changed, 172 insertions(+), 6 deletions(-)
 create mode 100644 examples/animations/smooth_curves.rs

diff --git a/Cargo.toml b/Cargo.toml
index 0ea4b712499e7..a52c56bccef4d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -450,6 +450,11 @@ crate-type = ["cdylib"]
 name = "android"
 path = "examples/android/android.rs"
 
+# Animation
+[[example]]
+name = "smooth_curves"
+path = "examples/animations/smooth_curves.rs"
+
 [package.metadata.android]
 apk_label = "Bevy Example"
 assets = "assets"
diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index e0649a339e150..68abd18eb5a7f 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -21,6 +21,7 @@ use crate::{
 pub enum TangentControl {
     Auto,
     Free,
+    Flat,
     Broken,
     InBroken,
     OutBroken,
@@ -37,7 +38,9 @@ impl Default for TangentControl {
 ///
 /// Similar in design to the [`CurveVariableLinear`](super::CurveVariableLinear) but allows
 /// for smoother catmull-rom interpolations using tangents, which can further reduce the number of keyframes at
-/// the cost of performance.
+/// the cost of performance;
+///
+/// It can't handle discontinuities, as in two keyframes with the same timestamp.
 ///
 /// **NOTE** Keyframes count is limited by the [`CurveCursor`] size.
 #[derive(Default, Debug)]
@@ -180,16 +183,16 @@ where
             self.tangents_out[0] = T::FLAT_TANGENT;
         } else {
             for i in 0..length {
-                let p = if i > 0 { i - 1 } else { length - 1 };
-                let n = if (i + 1) < length { i + 1 } else { 0 };
+                let p = if i > 0 { i - 1 } else { 0 };
+                let n = if (i + 1) < length { i + 1 } else { length - 1 };
 
                 let tangent = T::auto_tangent(
                     self.time_stamps[p],
                     self.time_stamps[i],
                     self.time_stamps[n],
-                    &self.keyframes[p].clone(),
-                    &self.keyframes[i].clone(),
-                    &self.keyframes[n].clone(),
+                    &self.keyframes[p],
+                    &self.keyframes[i],
+                    &self.keyframes[n],
                 );
 
                 self.tangents_in[i] = tangent;
diff --git a/crates/bevy_math/src/curves/variable_linear.rs b/crates/bevy_math/src/curves/variable_linear.rs
index 6ab763c63450f..971d64a24ea0e 100644
--- a/crates/bevy_math/src/curves/variable_linear.rs
+++ b/crates/bevy_math/src/curves/variable_linear.rs
@@ -13,6 +13,8 @@ use crate::{
 /// to lower the memory foot print. As a down side it requires the use of a keyframe cursor, and
 /// loses performance when the curve frame rate is higher than the curve sampling frame rate;
 ///
+/// It can't handle discontinuities, as in two keyframes with the same timestamp.
+///
 /// **NOTE** Keyframes count is limited by the [`CurveCursor`] size.
 #[derive(Default, Debug)]
 pub struct CurveVariableLinear<T> {
diff --git a/examples/animations/smooth_curves.rs b/examples/animations/smooth_curves.rs
new file mode 100644
index 0000000000000..04bbc14cce74e
--- /dev/null
+++ b/examples/animations/smooth_curves.rs
@@ -0,0 +1,156 @@
+use bevy::{
+    math::curves::{Curve, CurveVariable},
+    prelude::*,
+    render::pipeline::PrimitiveTopology,
+};
+
+struct CurveCursor;
+
+struct CurveTarget;
+
+#[derive(Default)]
+struct CurveMesh {
+    timer: Timer,
+    curve: CurveVariable<f32>,
+    mesh: Handle<Mesh>,
+}
+
+fn main() {
+    App::build()
+        .insert_resource(CurveMesh::default())
+        .add_plugins(DefaultPlugins)
+        .add_startup_system(setup.system())
+        .add_system(animate.system())
+        .run();
+}
+
+fn values<T: Copy>(length: usize, default: T) -> Vec<T> {
+    let mut v = vec![];
+    v.resize(length, default);
+    v
+}
+
+fn setup(
+    mut commands: Commands,
+    mut curve_mesh: ResMut<CurveMesh>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    let samples = vec![0.0, 1.0, 1.3, 1.6, 1.7, 1.8, 1.9, 2.0];
+    let keyframes = vec![3.0, 0.0, 1.0, 0.0, 0.5, 0.0, 0.25, 0.0];
+
+    // Create curve
+    curve_mesh.curve = CurveVariable::with_auto_tangents(samples.clone(), keyframes.clone());
+    // Create timer
+    curve_mesh.timer = Timer::from_seconds(2.5, true);
+
+    // Create curve mesh
+    const DIVS: usize = 1024;
+    let mut mesh = Mesh::new(PrimitiveTopology::LineStrip);
+    mesh.set_attribute(
+        Mesh::ATTRIBUTE_POSITION,
+        (0..DIVS)
+            .into_iter()
+            .map(|i| {
+                let time = (i as f32 / (DIVS - 1) as f32) * curve_mesh.curve.duration();
+                [time, curve_mesh.curve.sample(time), 0.0]
+            })
+            .collect::<Vec<_>>(),
+    );
+    mesh.set_attribute(Mesh::ATTRIBUTE_NORMAL, values(DIVS, [0.0f32, 0.0, 1.0]));
+    mesh.set_attribute(Mesh::ATTRIBUTE_TANGENT, values(DIVS, [0.0f32, 1.0, 0.0]));
+    mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, values(DIVS, [0.0f32; 2]));
+    let mesh = meshes.add(mesh);
+    curve_mesh.mesh = mesh.clone();
+
+    let material = materials.add(Color::RED.into());
+    let keyframe_mesh = meshes.add(Mesh::from(shape::Cube { size: 0.05 }));
+
+    // Animated sphere
+    commands
+        .spawn_bundle(PbrBundle {
+            mesh,
+            transform: Transform::from_translation(Vec3::new(-3.5, 0.0, 0.0)),
+            material: material.clone(),
+            ..Default::default()
+        })
+        .with_children(|parent| {
+            // Create keyframes
+            for (t, k) in samples.iter().zip(keyframes.iter()) {
+                parent.spawn_bundle(PbrBundle {
+                    mesh: keyframe_mesh.clone(),
+                    transform: Transform::from_translation(Vec3::new(*t, *k, 0.0)),
+                    material: material.clone(),
+                    ..Default::default()
+                });
+            }
+
+            // Create time cursor
+            let mut mesh = Mesh::new(PrimitiveTopology::LineStrip);
+            mesh.set_attribute(
+                Mesh::ATTRIBUTE_POSITION,
+                vec![[0.0f32, 4.0, 0.0], [0.0, -2.0, 0.0]],
+            );
+            mesh.set_attribute(Mesh::ATTRIBUTE_NORMAL, values(2, [0.0f32, 0.0, 1.0]));
+            mesh.set_attribute(Mesh::ATTRIBUTE_TANGENT, values(2, [0.0f32, 1.0, 0.0]));
+            mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, values(2, [0.0f32; 2]));
+            let mesh = meshes.add(mesh);
+
+            parent
+                .spawn_bundle(PbrBundle {
+                    mesh,
+                    material: materials.add(Color::BLUE.into()),
+                    ..Default::default()
+                })
+                .insert(CurveCursor);
+        });
+
+    commands
+        .spawn_bundle(PbrBundle {
+            mesh: meshes.add(Mesh::from(shape::Icosphere {
+                radius: 0.5,
+                subdivisions: 3,
+            })),
+            transform: Transform::from_translation(Vec3::new(2.0, 0.0, 0.0)),
+            material: materials.add(Color::BEIGE.into()),
+            ..Default::default()
+        })
+        .insert(CurveTarget);
+
+    // Camera and Light
+    commands.spawn_bundle(LightBundle {
+        transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
+        ..Default::default()
+    });
+
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_matrix(Mat4::face_toward(
+            Vec3::new(-3.0, 5.0, 8.0),
+            Vec3::new(0.0, 0.0, 0.0),
+            Vec3::new(0.0, 1.0, 0.0),
+        )),
+        ..Default::default()
+    });
+}
+
+fn animate(
+    mut curve_mesh: ResMut<CurveMesh>,
+    time: Res<Time>,
+    mut query_set: QuerySet<(
+        Query<(&mut Transform, &CurveTarget)>,
+        Query<(&mut Transform, &CurveCursor)>,
+    )>,
+) {
+    let t = curve_mesh.timer.elapsed_secs();
+
+    for (mut transform, _) in query_set.q0_mut().iter_mut() {
+        let y = curve_mesh.curve.sample(t);
+        transform.translation.y = y;
+    }
+
+    for (mut transform, _) in query_set.q1_mut().iter_mut() {
+        transform.translation.x = t;
+    }
+
+    curve_mesh.timer.tick(time.delta());
+}

From 9e8b537382491ecf84ed43e616404a9d31f50d2d Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Thu, 15 Apr 2021 14:37:28 -0300
Subject: [PATCH 124/153] fix smooth interpolation

---
 crates/bevy_asset/src/handle.rs               |  2 +
 crates/bevy_math/src/curves/variable.rs       | 48 ++++++++++--
 .../src/interpolation/interpolate.rs          | 16 ++--
 crates/bevy_math/src/interpolation/utils.rs   | 15 ++--
 examples/animations/smooth_curves.rs          | 75 ++++++++++++-------
 5 files changed, 106 insertions(+), 50 deletions(-)

diff --git a/crates/bevy_asset/src/handle.rs b/crates/bevy_asset/src/handle.rs
index f4550c8e669a9..604f0497bbbef 100644
--- a/crates/bevy_asset/src/handle.rs
+++ b/crates/bevy_asset/src/handle.rs
@@ -252,6 +252,7 @@ impl<T: Asset + 'static> Interpolate for Handle<T> {
         _: &Self::Tangent,
         _: bevy_math::interpolation::Interpolation,
         t: f32,
+        _: f32,
     ) -> Self {
         step_unclamped(k0, k1, t)
     }
@@ -386,6 +387,7 @@ impl Interpolate for HandleUntyped {
         _: &Self::Tangent,
         _: bevy_math::interpolation::Interpolation,
         t: f32,
+        _: f32,
     ) -> Self {
         step_unclamped(k0, k1, t)
     }
diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index 68abd18eb5a7f..36d1030e3a408 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -1,5 +1,5 @@
 use crate::{
-    curves::Curve,
+    curves::{Curve, CurveCursor},
     interpolation::{Interpolate, Interpolation},
 };
 
@@ -17,7 +17,7 @@ use crate::{
 // https://github.com/nfrechette/acl
 
 /// Keyframe tangents control mode
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum TangentControl {
     Auto,
     Free,
@@ -175,6 +175,11 @@ where
 
     // TODO: Edit methods
 
+    pub fn get_in_out_tangent(&self, index: CurveCursor) -> (T::Tangent, T::Tangent) {
+        let index = index as usize;
+        (self.tangents_in[index], self.tangents_out[index])
+    }
+
     /// Updates keyframes marked with `TangentControl::Auto`
     pub fn update_tangents(&mut self) {
         let length = self.keyframes.len();
@@ -186,6 +191,10 @@ where
                 let p = if i > 0 { i - 1 } else { 0 };
                 let n = if (i + 1) < length { i + 1 } else { length - 1 };
 
+                if self.tangents_control[i] != TangentControl::Auto {
+                    continue;
+                }
+
                 let tangent = T::auto_tangent(
                     self.time_stamps[p],
                     self.time_stamps[i],
@@ -201,15 +210,36 @@ where
         }
     }
 
-    /// Make sure the first keyframe starts at time `0.0`
-    #[inline]
-    pub fn remove_time_offset(&mut self) {
-        self.apply_time_offset(-self.time_stamps[0]);
+    /// Number of keyframes
+    pub fn len(&self) -> usize {
+        self.keyframes.len()
+    }
+
+    /// `true` when this `CurveFixed` doesn't have any keyframe
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
     }
 
-    pub fn apply_time_offset(&mut self, time_offset: f32) {
+    pub fn set_offset(&mut self, mut time_offset: f32) {
+        time_offset -= self.offset(); // Removes current offset
         self.time_stamps.iter_mut().for_each(|t| *t += time_offset);
     }
+
+    #[inline]
+    pub fn offset(&self) -> f32 {
+        self.time_stamps[0]
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
+        self.time_stamps.iter().copied().zip(self.keyframes.iter())
+    }
+
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
+        self.time_stamps
+            .iter()
+            .copied()
+            .zip(self.keyframes.iter_mut())
+    }
 }
 
 impl<T> Curve for CurveVariable<T>
@@ -269,7 +299,8 @@ where
         // Lerp the value
         let i = cursor - 1;
         let previous_time = self.time_stamps[i as usize];
-        let t = (time - previous_time) / (self.time_stamps[cursor as usize] - previous_time);
+        let dt = self.time_stamps[cursor as usize] - previous_time;
+        let t = (time - previous_time) / dt;
         debug_assert!(
             (0.0..=1.0).contains(&t),
             "t = {} but should be normalized",
@@ -285,6 +316,7 @@ where
             &self.tangents_in[b],
             self.modes[a as usize],
             t,
+            dt,
         );
 
         (cursor, value)
diff --git a/crates/bevy_math/src/interpolation/interpolate.rs b/crates/bevy_math/src/interpolation/interpolate.rs
index 2264533d1190b..e8217e8fd1023 100644
--- a/crates/bevy_math/src/interpolation/interpolate.rs
+++ b/crates/bevy_math/src/interpolation/interpolate.rs
@@ -26,8 +26,9 @@ pub trait Interpolate: Lerp + Clone {
         t1: &Self::Tangent,
         interp: Interpolation,
         t: f32,
+        dt: f32,
     ) -> Self {
-        Self::interpolate_unclamped(k0, t0, k1, t1, interp, t.clamp(0.0, 1.0))
+        Self::interpolate_unclamped(k0, t0, k1, t1, interp, t.clamp(0.0, 1.0), dt)
     }
 
     fn interpolate_unclamped(
@@ -37,6 +38,7 @@ pub trait Interpolate: Lerp + Clone {
         t1: &Self::Tangent,
         interp: Interpolation,
         t: f32,
+        dt: f32,
     ) -> Self;
 
     fn auto_tangent(t0: f32, t1: f32, t2: f32, k0: &Self, k1: &Self, k2: &Self) -> Self::Tangent;
@@ -54,12 +56,9 @@ impl Interpolate for bool {
         _: &Self::Tangent,
         _: Interpolation,
         t: f32,
+        _: f32,
     ) -> Self {
-        if t > 0.99 {
-            *k0
-        } else {
-            *k1
-        }
+        utils::step_unclamped(k0, k1, t)
     }
 
     fn auto_tangent(_: f32, _: f32, _: f32, _: &Self, _: &Self, _: &Self) -> Self::Tangent {
@@ -80,12 +79,13 @@ macro_rules! interpolate {
                 t1: &Self::Tangent,
                 interp: Interpolation,
                 t: f32,
+                dt: f32,
             ) -> Self {
                 match interp {
                     Interpolation::Step => utils::step_unclamped(k0, k1, t),
                     Interpolation::Linear => utils::lerp_unclamped(*k0, *k1, t),
                     Interpolation::CatmullRom => {
-                        utils::catmull_rom_unclamped(*k0, *t0, *k1, *t1, t)
+                        utils::catmull_rom_unclamped(*k0, *t0, *k1, *t1, t, dt)
                     }
                 }
             }
@@ -147,6 +147,7 @@ impl Interpolate for Quat {
         t1: &Self::Tangent,
         interp: Interpolation,
         t: f32,
+        dt: f32,
     ) -> Self {
         match interp {
             Interpolation::Step => utils::step_unclamped(k0, k1, t),
@@ -174,6 +175,7 @@ impl Interpolate for Quat {
                     k1.into(),
                     (*t1).into(),
                     t,
+                    dt,
                 );
                 let d = utils::inv_sqrt(q.dot(q));
                 (q * d).into()
diff --git a/crates/bevy_math/src/interpolation/utils.rs b/crates/bevy_math/src/interpolation/utils.rs
index 21d9c5b2f270b..5907785373fd9 100644
--- a/crates/bevy_math/src/interpolation/utils.rs
+++ b/crates/bevy_math/src/interpolation/utils.rs
@@ -37,16 +37,19 @@ where
 ///
 /// Source: http://archive.gamedev.net/archive/reference/articles/article1497.html
 #[inline]
-pub fn catmull_rom_unclamped<T>(k0: T, t0: T, k1: T, t1: T, u: f32) -> T
+pub fn catmull_rom_unclamped<T>(k0: T, t0: T, k1: T, t1: T, u: f32, dx: f32) -> T
 where
     T: Add<Output = T> + Sub<Output = T> + Mul<f32, Output = T>,
 {
-    let u2 = u * u;
-    let u3 = u2 * u;
-    let _3u2 = 3.0 * u2;
-    let _2u3 = 2.0 * u3;
+    let v_u2 = u * u;
+    let v_u3 = v_u2 * u;
+    let v_3u2 = 3.0 * v_u2;
+    let v_2u3 = 2.0 * v_u3;
 
-    k0 * (_2u3 - _3u2 + 1.0) + k1 * (_3u2 - _2u3) + t0 * (u3 - 2.0 * u2 + u) + t1 * (u3 - u2)
+    k0 * (v_2u3 - v_3u2 + 1.0)
+        + k1 * (v_3u2 - v_2u3)
+        + t0 * dx * (v_u3 - 2.0 * v_u2 + u)
+        + t1 * dx * (v_u3 - v_u2)
 }
 
 /// Finds the tangent gradients for the Catmull-Rom spline
diff --git a/examples/animations/smooth_curves.rs b/examples/animations/smooth_curves.rs
index 04bbc14cce74e..c67327af9da32 100644
--- a/examples/animations/smooth_curves.rs
+++ b/examples/animations/smooth_curves.rs
@@ -1,12 +1,12 @@
 use bevy::{
-    math::curves::{Curve, CurveVariable},
+    math::curves::{Curve, CurveCursor, CurveVariable},
     prelude::*,
     render::pipeline::PrimitiveTopology,
 };
 
-struct CurveCursor;
+struct CurveCursorTag;
 
-struct CurveTarget;
+struct CurveTargetTag;
 
 #[derive(Default)]
 struct CurveMesh {
@@ -30,17 +30,26 @@ fn values<T: Copy>(length: usize, default: T) -> Vec<T> {
     v
 }
 
+fn line(a: [f32; 3], b: [f32; 3]) -> Mesh {
+    let mut mesh = Mesh::new(PrimitiveTopology::LineStrip);
+    mesh.set_attribute(Mesh::ATTRIBUTE_POSITION, vec![a, b]);
+    mesh.set_attribute(Mesh::ATTRIBUTE_NORMAL, values(2, [0.0f32, 0.0, 1.0]));
+    mesh.set_attribute(Mesh::ATTRIBUTE_TANGENT, values(2, [0.0f32, 1.0, 0.0]));
+    mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, values(2, [0.0f32; 2]));
+    mesh
+}
+
 fn setup(
     mut commands: Commands,
     mut curve_mesh: ResMut<CurveMesh>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    let samples = vec![0.0, 1.0, 1.3, 1.6, 1.7, 1.8, 1.9, 2.0];
-    let keyframes = vec![3.0, 0.0, 1.0, 0.0, 0.5, 0.0, 0.25, 0.0];
-
     // Create curve
-    curve_mesh.curve = CurveVariable::with_auto_tangents(samples.clone(), keyframes.clone());
+    curve_mesh.curve = CurveVariable::with_auto_tangents(
+        vec![0.0, 1.0, 1.3, 1.6, 1.7, 1.8, 1.9, 2.0],
+        vec![3.0, 0.0, 1.0, 0.0, 0.5, 0.0, 0.25, 0.0],
+    );
     // Create timer
     curve_mesh.timer = Timer::from_seconds(2.5, true);
 
@@ -76,33 +85,41 @@ fn setup(
         })
         .with_children(|parent| {
             // Create keyframes
-            for (t, k) in samples.iter().zip(keyframes.iter()) {
-                parent.spawn_bundle(PbrBundle {
-                    mesh: keyframe_mesh.clone(),
-                    transform: Transform::from_translation(Vec3::new(*t, *k, 0.0)),
-                    material: material.clone(),
-                    ..Default::default()
-                });
+            let tangent_material = materials.add(Color::BLACK.into());
+            for (index, (t, k)) in curve_mesh.curve.iter().enumerate() {
+                parent
+                    .spawn_bundle(PbrBundle {
+                        mesh: keyframe_mesh.clone(),
+                        transform: Transform::from_translation(Vec3::new(t, *k, 0.0)),
+                        material: material.clone(),
+                        ..Default::default()
+                    })
+                    .with_children(|parent| {
+                        // tangents
+                        let (a, b) = curve_mesh.curve.get_in_out_tangent(index as CurveCursor);
+                        let (ay, ax) = a.atan().sin_cos();
+                        let (by, bx) = b.atan().sin_cos();
+                        parent.spawn_bundle(PbrBundle {
+                            mesh: meshes.add(line([0.0, 0.0, 0.0], [ax * -0.2, ay * -0.2, 0.0])),
+                            material: tangent_material.clone(),
+                            ..Default::default()
+                        });
+                        parent.spawn_bundle(PbrBundle {
+                            mesh: meshes.add(line([0.0, 0.0, 0.0], [bx * 0.2, by * 0.2, 0.0])),
+                            material: tangent_material.clone(),
+                            ..Default::default()
+                        });
+                    });
             }
 
             // Create time cursor
-            let mut mesh = Mesh::new(PrimitiveTopology::LineStrip);
-            mesh.set_attribute(
-                Mesh::ATTRIBUTE_POSITION,
-                vec![[0.0f32, 4.0, 0.0], [0.0, -2.0, 0.0]],
-            );
-            mesh.set_attribute(Mesh::ATTRIBUTE_NORMAL, values(2, [0.0f32, 0.0, 1.0]));
-            mesh.set_attribute(Mesh::ATTRIBUTE_TANGENT, values(2, [0.0f32, 1.0, 0.0]));
-            mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, values(2, [0.0f32; 2]));
-            let mesh = meshes.add(mesh);
-
             parent
                 .spawn_bundle(PbrBundle {
-                    mesh,
+                    mesh: meshes.add(line([0.0, 4.0, 0.0], [0.0, -2.0, 0.0])),
                     material: materials.add(Color::BLUE.into()),
                     ..Default::default()
                 })
-                .insert(CurveCursor);
+                .insert(CurveCursorTag);
         });
 
     commands
@@ -115,7 +132,7 @@ fn setup(
             material: materials.add(Color::BEIGE.into()),
             ..Default::default()
         })
-        .insert(CurveTarget);
+        .insert(CurveTargetTag);
 
     // Camera and Light
     commands.spawn_bundle(LightBundle {
@@ -137,8 +154,8 @@ fn animate(
     mut curve_mesh: ResMut<CurveMesh>,
     time: Res<Time>,
     mut query_set: QuerySet<(
-        Query<(&mut Transform, &CurveTarget)>,
-        Query<(&mut Transform, &CurveCursor)>,
+        Query<(&mut Transform, &CurveTargetTag)>,
+        Query<(&mut Transform, &CurveCursorTag)>,
     )>,
 ) {
     let t = curve_mesh.timer.elapsed_secs();

From 2d1864cf52849bcd6ec6f0dcc9033ef76dbc012d Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Fri, 16 Apr 2021 18:43:46 -0300
Subject: [PATCH 125/153] curve editing functions

---
 crates/bevy_math/src/curves/fixed.rs    |  19 +-
 crates/bevy_math/src/curves/variable.rs | 293 ++++++++++++++++++++----
 2 files changed, 252 insertions(+), 60 deletions(-)

diff --git a/crates/bevy_math/src/curves/fixed.rs b/crates/bevy_math/src/curves/fixed.rs
index ba3d82f47366c..c8619656c4db3 100644
--- a/crates/bevy_math/src/curves/fixed.rs
+++ b/crates/bevy_math/src/curves/fixed.rs
@@ -13,7 +13,7 @@ pub struct CurveFixed<T> {
     frame_rate: f32,
     /// Negative number of frames before the curve starts
     negative_offset: f32,
-    keyframes: Vec<T>,
+    pub keyframes: Vec<T>,
 }
 
 impl<T: Clone> Clone for CurveFixed<T> {
@@ -43,23 +43,6 @@ impl<T> CurveFixed<T> {
         }
     }
 
-    pub fn keyframes(&self) -> &[T] {
-        &self.keyframes[..]
-    }
-
-    pub fn keyframes_mut(&mut self) -> &mut [T] {
-        &mut self.keyframes[..]
-    }
-
-    pub fn insert_keyframe(&mut self, index: usize, value: T) {
-        self.keyframes.insert(index, value);
-    }
-
-    pub fn remove_keyframe(&mut self, index: usize) -> T {
-        assert!(self.keyframes.len() > 1, "curve can't be empty");
-        self.keyframes.remove(index)
-    }
-
     pub fn frame_rate(&self) -> f32 {
         self.frame_rate
     }
diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index 36d1030e3a408..c2b53ed46e982 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -3,19 +3,6 @@ use crate::{
     interpolation::{Interpolate, Interpolation},
 };
 
-// TODO: Smooth interpolation are untested
-
-// TODO: Curve/Clip need a validation during deserialization because they are
-// structured as SOA (struct of arrays), so the vec's length must match
-
-// https://github.com/niklasfrykholm/blog
-// https://bitsquid.blogspot.com/search?q=animation
-// http://bitsquid.blogspot.com/2009/11/bitsquid-low-level-animation-system.html
-// http://archive.gamedev.net/archive/reference/articles/article1497.html (bit old)
-
-// http://nfrechette.github.io/2016/12/07/anim_compression_key_reduction/
-// https://github.com/nfrechette/acl
-
 /// Keyframe tangents control mode
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum TangentControl {
@@ -23,8 +10,6 @@ pub enum TangentControl {
     Free,
     Flat,
     Broken,
-    InBroken,
-    OutBroken,
 }
 
 impl Default for TangentControl {
@@ -34,6 +19,7 @@ impl Default for TangentControl {
 }
 
 // TODO: impl Serialize, Deserialize
+// TODO: How better handling of SOA? the length for instance is repeated and extra checks are need on deserialization
 /// Curve with sparse keyframes frames, in another words a curve with variable frame rate;
 ///
 /// Similar in design to the [`CurveVariableLinear`](super::CurveVariableLinear) but allows
@@ -42,6 +28,9 @@ impl Default for TangentControl {
 ///
 /// It can't handle discontinuities, as in two keyframes with the same timestamp.
 ///
+/// Interpolation is based on this [article](http://archive.gamedev.net/archive/reference/articles/article1497.html),
+/// it's very similar to the implementation used by Unity, except that tangents doesn't have weighted mode;
+///
 /// **NOTE** Keyframes count is limited by the [`CurveCursor`] size.
 #[derive(Default, Debug)]
 pub struct CurveVariable<T: Interpolate> {
@@ -173,41 +162,176 @@ where
         }
     }
 
-    // TODO: Edit methods
+    /// Insert a new keyframe
+    ///
+    /// ```rust
+    /// # fn main() {
+    /// let mut curve = CurveVariable::from_constant(0.0f32);
+    /// curve.insert()
+    ///     .set_time(1.0)
+    ///     .set_value(2.0)
+    ///     .set_tangent_control(TangentControl::Flat)
+    ///     .done();
+    ///
+    /// assert_eq!(curve.len(), 2);
+    /// # }
+    /// ```
+    pub fn insert(&mut self) -> CurveVariableKeyframeBuilder<T> {
+        CurveVariableKeyframeBuilder {
+            time: self
+                .time_stamps
+                .last()
+                .copied()
+                .map_or(0.0, |t| t + 0.03333),
+            value: self.keyframes.last().unwrap().clone(),
+            mode: self.modes.last().unwrap().clone(),
+            tangent_control: TangentControl::Auto,
+            tangent_in: T::FLAT_TANGENT,
+            tangent_out: T::FLAT_TANGENT,
+            curve: self,
+        }
+    }
 
-    pub fn get_in_out_tangent(&self, index: CurveCursor) -> (T::Tangent, T::Tangent) {
-        let index = index as usize;
-        (self.tangents_in[index], self.tangents_out[index])
+    pub fn remove(&mut self, index: CurveCursor) {
+        let i = index as usize;
+
+        self.time_stamps.remove(i);
+        self.keyframes.remove(i);
+        self.modes.remove(i);
+        self.tangents_control.remove(i);
+        self.tangents_in.remove(i);
+        self.tangents_out.remove(i);
+
+        if i < self.keyframes.len() {
+            self.adjust_tangents(i);
+        }
+        if i > 0 {
+            self.adjust_tangents(i - 1);
+        }
     }
 
-    /// Updates keyframes marked with `TangentControl::Auto`
-    pub fn update_tangents(&mut self) {
-        let length = self.keyframes.len();
-        if length == 1 {
-            self.tangents_in[0] = T::FLAT_TANGENT;
-            self.tangents_out[0] = T::FLAT_TANGENT;
+    pub fn set_value(&mut self, index: CurveCursor, value: T) {
+        let i = index as usize;
+        self.keyframes[i] = value;
+        self.adjust_tangents_with_neighbors(i);
+    }
+
+    pub fn set_time(&mut self, index: CurveCursor, time: f32) {
+        let i = index as usize;
+        let j = self
+            .time_stamps
+            .iter()
+            .position(|t| *t < time)
+            .unwrap_or_else(|| self.time_stamps.len() - 1);
+
+        if i != j {
+            let k = j + 1;
+            self.time_stamps[i..k].rotate_left(0);
+            self.keyframes[i..k].rotate_left(0);
+            self.modes[i..k].rotate_left(0);
+            self.tangents_control[i..k].rotate_left(0);
+            self.tangents_in[i..k].rotate_left(0);
+            self.tangents_out[i..k].rotate_left(0);
+
+            self.adjust_tangents_with_neighbors(j);
         } else {
-            for i in 0..length {
-                let p = if i > 0 { i - 1 } else { 0 };
-                let n = if (i + 1) < length { i + 1 } else { length - 1 };
+            self.time_stamps[i] = time;
+        }
 
-                if self.tangents_control[i] != TangentControl::Auto {
-                    continue;
-                }
+        self.adjust_tangents_with_neighbors(i);
+    }
 
-                let tangent = T::auto_tangent(
-                    self.time_stamps[p],
-                    self.time_stamps[i],
-                    self.time_stamps[n],
-                    &self.keyframes[p],
-                    &self.keyframes[i],
-                    &self.keyframes[n],
-                );
-
-                self.tangents_in[i] = tangent;
-                self.tangents_out[i] = tangent;
+    #[inline]
+    pub fn set_interpolation(&mut self, index: CurveCursor, interpolation: Interpolation) {
+        self.modes[index as usize] = interpolation;
+    }
+
+    #[inline]
+    pub fn set_in_tangent(&mut self, index: CurveCursor, tangent: T::Tangent) {
+        let i = index as usize;
+        self.tangents_control[i] = TangentControl::Broken;
+        self.tangents_in[i] = tangent;
+    }
+
+    #[inline]
+    pub fn set_out_tangent(&mut self, index: CurveCursor, tangent: T::Tangent) {
+        let i = index as usize;
+        self.tangents_control[i] = TangentControl::Broken;
+        self.tangents_out[i] = tangent;
+    }
+
+    #[inline]
+    pub fn set_in_out_tangent(&mut self, index: CurveCursor, tangent: T::Tangent) {
+        let i = index as usize;
+        self.tangents_control[i] = TangentControl::Free;
+        self.tangents_in[i] = tangent;
+        self.tangents_out[i] = tangent;
+    }
+
+    pub fn set_tangent_control(&mut self, index: CurveCursor, tangent_control: TangentControl) {
+        let i = index as usize;
+        self.tangents_control[i] = tangent_control;
+        self.adjust_tangents(i);
+    }
+
+    /// Adjust tangents for self and neighbors keyframes
+    pub(crate) fn adjust_tangents_with_neighbors(&mut self, i: usize) {
+        if i > 0 {
+            self.adjust_tangents(i - 1);
+        }
+
+        self.adjust_tangents(i);
+
+        if i < self.keyframes.len() - 1 {
+            self.adjust_tangents(i + 1);
+        }
+    }
+
+    /// Adjust tangents for a single keyframe according with their [`TangentControl`]
+    fn adjust_tangents(&mut self, i: usize) {
+        let length = self.keyframes.len();
+        let mut tangent = T::FLAT_TANGENT;
+
+        match self.tangents_control[i] {
+            TangentControl::Auto => {
+                if length > 2 {
+                    let p = if i > 0 { i - 1 } else { 0 };
+                    let n = if (i + 1) < length { i + 1 } else { length - 1 };
+
+                    tangent = T::auto_tangent(
+                        self.time_stamps[p],
+                        self.time_stamps[i],
+                        self.time_stamps[n],
+                        &self.keyframes[p],
+                        &self.keyframes[i],
+                        &self.keyframes[n],
+                    );
+                }
+            }
+            TangentControl::Flat => {}
+            _ => {
+                // Do nothing
+                return;
             }
         }
+
+        self.tangents_in[i] = tangent;
+        self.tangents_out[i] = tangent;
+    }
+
+    /// Rebuilds tangents for the entire curve based on each keyframe [`TangentControl`] mode
+    pub fn rebuild_curve_tangents(&mut self) {
+        for i in 0..self.len() {
+            self.adjust_tangents(i);
+        }
+    }
+
+    // TODO: More getters
+
+    #[inline]
+    pub fn get_in_out_tangent(&self, index: CurveCursor) -> (T::Tangent, T::Tangent) {
+        let i = index as usize;
+        (self.tangents_in[i], self.tangents_out[i])
     }
 
     /// Number of keyframes
@@ -323,6 +447,91 @@ where
     }
 }
 
+pub struct CurveVariableKeyframeBuilder<'a, T: Interpolate> {
+    curve: &'a mut CurveVariable<T>,
+    time: f32,
+    value: T,
+    mode: Interpolation,
+    tangent_control: TangentControl,
+    tangent_in: T::Tangent,
+    tangent_out: T::Tangent,
+}
+
+impl<'a, T: Interpolate> CurveVariableKeyframeBuilder<'a, T> {
+    #[inline]
+    pub fn set_time(mut self, time: f32) -> Self {
+        self.time = time;
+        self
+    }
+
+    #[inline]
+    pub fn set_value(mut self, value: T) -> Self {
+        self.value = value;
+        self
+    }
+
+    #[inline]
+    pub fn set_mode(mut self, mode: Interpolation) -> Self {
+        self.mode = mode;
+        self
+    }
+
+    #[inline]
+    pub fn set_tangent_control(mut self, tangent_control: TangentControl) -> Self {
+        if tangent_control == TangentControl::Flat {
+            self.tangent_in = T::FLAT_TANGENT;
+            self.tangent_out = T::FLAT_TANGENT;
+        }
+
+        self.tangent_control = tangent_control;
+        self
+    }
+
+    #[inline]
+    pub fn set_in_tangent(mut self, tangent: T::Tangent) -> Self {
+        self.tangent_control = TangentControl::Broken;
+        self.tangent_in = tangent;
+        self
+    }
+
+    #[inline]
+    pub fn set_out_tangent(mut self, tangent: T::Tangent) -> Self {
+        self.tangent_control = TangentControl::Broken;
+        self.tangent_out = tangent;
+        self
+    }
+
+    #[inline]
+    pub fn set_in_out_tangent(&mut self, tangent: T::Tangent) {
+        self.tangent_control = TangentControl::Free;
+        self.tangent_in = tangent;
+        self.tangent_out = tangent;
+    }
+
+    pub fn done(self) {
+        if let Some(i) = self.curve.time_stamps.iter().position(|t| *t < self.time) {
+            self.curve.time_stamps.insert(i, self.time);
+            self.curve.keyframes.insert(i, self.value);
+            self.curve.modes.insert(i, self.mode);
+            self.curve.tangents_control.insert(i, self.tangent_control);
+            self.curve.tangents_in.insert(i, self.tangent_in);
+            self.curve.tangents_out.insert(i, self.tangent_out);
+
+            self.curve.adjust_tangents_with_neighbors(i);
+        } else {
+            self.curve.time_stamps.push(self.time);
+            self.curve.keyframes.push(self.value);
+            self.curve.modes.push(self.mode);
+            self.curve.tangents_control.push(self.tangent_control);
+            self.curve.tangents_in.push(self.tangent_in);
+            self.curve.tangents_out.push(self.tangent_out);
+
+            self.curve
+                .adjust_tangents_with_neighbors(self.curve.keyframes.len() - 1);
+        }
+    }
+}
+
 // #[cfg(test)]
 // mod tests {
 //     use super::*;

From bf417aa0de68f396c760c7c5de6324927a47b4be Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sat, 17 Apr 2021 01:47:59 -0300
Subject: [PATCH 126/153] curve variable getters

---
 crates/bevy_math/src/curves/variable.rs | 30 ++++++++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index c2b53ed46e982..d3d242f3640e8 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -18,6 +18,14 @@ impl Default for TangentControl {
     }
 }
 
+// TODO: Test performance by packing keyframe runtime info (value, mode, in_tangent, out_tangent)
+// pub struct CurveVariableKeyframe<T: Interpolate> {
+//     pub value: T,
+//     pub interpolation: Interpolation,
+//     pub in_tangent: T::Tangent,
+//     pub out_tangent: T::Tangent,
+// }
+
 // TODO: impl Serialize, Deserialize
 // TODO: How better handling of SOA? the length for instance is repeated and extra checks are need on deserialization
 /// Curve with sparse keyframes frames, in another words a curve with variable frame rate;
@@ -63,6 +71,8 @@ impl<T> CurveVariable<T>
 where
     T: Interpolate,
 {
+    // TODO: with_flat_tangents
+
     pub fn with_auto_tangents(samples: Vec<f32>, values: Vec<T>) -> Self {
         // TODO: Result?
 
@@ -326,7 +336,25 @@ where
         }
     }
 
-    // TODO: More getters
+    #[inline]
+    pub fn get_value(&self, index: CurveCursor) -> &T {
+        &self.keyframes[index as usize]
+    }
+
+    #[inline]
+    pub fn get_time(&self, index: CurveCursor) -> f32 {
+        self.time_stamps[index as usize]
+    }
+
+    #[inline]
+    pub fn get_interpolation(&self, index: CurveCursor) -> Interpolation {
+        self.modes[index as usize]
+    }
+
+    #[inline]
+    pub fn get_tangent_control(&self, index: CurveCursor) -> TangentControl {
+        self.tangents_control[index as usize]
+    }
 
     #[inline]
     pub fn get_in_out_tangent(&self, index: CurveCursor) -> (T::Tangent, T::Tangent) {

From 55937004ff42833d3dd1b17f0626f636cde0bab7 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sat, 17 Apr 2021 02:31:04 -0300
Subject: [PATCH 127/153] error handling

---
 crates/bevy_math/Cargo.toml                   |   1 +
 crates/bevy_math/src/curves/mod.rs            |  12 ++
 crates/bevy_math/src/curves/variable.rs       | 143 +++++++++---------
 .../bevy_math/src/curves/variable_linear.rs   |  50 +++---
 examples/animations/smooth_curves.rs          |  12 +-
 5 files changed, 116 insertions(+), 102 deletions(-)

diff --git a/crates/bevy_math/Cargo.toml b/crates/bevy_math/Cargo.toml
index fe252394424f0..aa2531ad06172 100644
--- a/crates/bevy_math/Cargo.toml
+++ b/crates/bevy_math/Cargo.toml
@@ -15,3 +15,4 @@ keywords = ["bevy"]
 [dependencies]
 glam = { version = "0.13.0", features = ["serde"] }
 bevy_reflect = { path = "../bevy_reflect", version = "0.5.0", features = ["bevy"] }
+thiserror = "1.0"
diff --git a/crates/bevy_math/src/curves/mod.rs b/crates/bevy_math/src/curves/mod.rs
index e5023174c1cb2..15df411ce6def 100644
--- a/crates/bevy_math/src/curves/mod.rs
+++ b/crates/bevy_math/src/curves/mod.rs
@@ -1,3 +1,5 @@
+use thiserror::Error;
+
 mod fixed;
 mod variable;
 mod variable_linear;
@@ -24,3 +26,13 @@ pub trait Curve {
     /// **NOTE** Each keyframe is indexed by a `u16` to reduce memory usage when using the keyframe caching
     fn sample_with_cursor(&self, cursor: u16, time: f32) -> (CurveCursor, Self::Output);
 }
+
+#[derive(Error, Debug)]
+pub enum CurveCreationError {
+    #[error("number of keyframes time stamps and values doesn't match")]
+    MissMachLength,
+    #[error("limit of {0} keyframes exceeded")]
+    KeyframeLimitReached(usize),
+    #[error("keyframes aren't sorted by time")]
+    NotSorted,
+}
diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index d3d242f3640e8..7d04f9f4d26c1 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -1,5 +1,5 @@
 use crate::{
-    curves::{Curve, CurveCursor},
+    curves::{Curve, CurveCreationError, CurveCursor},
     interpolation::{Interpolate, Interpolation},
 };
 
@@ -71,63 +71,94 @@ impl<T> CurveVariable<T>
 where
     T: Interpolate,
 {
-    // TODO: with_flat_tangents
-
-    pub fn with_auto_tangents(samples: Vec<f32>, values: Vec<T>) -> Self {
-        // TODO: Result?
+    #[inline]
+    pub fn with_flat_tangents(
+        samples: Vec<f32>,
+        values: Vec<T>,
+    ) -> Result<Self, CurveCreationError> {
+        Self::with_tangents_and_mode(
+            samples,
+            values,
+            TangentControl::Flat,
+            Interpolation::CatmullRom,
+        )
+    }
 
+    #[inline]
+    pub fn with_auto_tangents(
+        samples: Vec<f32>,
+        values: Vec<T>,
+    ) -> Result<Self, CurveCreationError> {
+        Self::with_tangents_and_mode(
+            samples,
+            values,
+            TangentControl::Auto,
+            Interpolation::CatmullRom,
+        )
+    }
+
+    pub fn with_tangents_and_mode(
+        samples: Vec<f32>,
+        values: Vec<T>,
+        tangent_control: TangentControl,
+        mode: Interpolation,
+    ) -> Result<Self, CurveCreationError> {
         let length = samples.len();
 
         // Make sure both have the same length
-        assert!(
-            length == values.len(),
-            "samples and values must have the same length"
-        );
-
-        assert!(
-            values.len() <= u16::MAX as usize,
-            "limit of {} keyframes exceeded",
-            u16::MAX
-        );
+        if length != values.len() {
+            Err(CurveCreationError::MissMachLength)?;
+        }
 
-        assert!(length > 0, "empty curve");
+        if values.len() > CurveCursor::MAX as usize {
+            Err(CurveCreationError::KeyframeLimitReached(
+                CurveCursor::MAX as usize,
+            ))?;
+        }
 
         // Make sure the
-        assert!(
-            samples
-                .iter()
-                .zip(samples.iter().skip(1))
-                .all(|(a, b)| a < b),
-            "time samples must be on ascending order"
-        );
+        if !samples
+            .iter()
+            .zip(samples.iter().skip(1))
+            .all(|(a, b)| a < b)
+        {
+            Err(CurveCreationError::NotSorted)?;
+        }
 
         let mut tangents = Vec::with_capacity(length);
-        if length == 1 {
-            tangents.push(T::FLAT_TANGENT);
-        } else {
-            for i in 0..length {
-                let p = if i > 0 { i - 1 } else { length - 1 };
-                let n = if (i + 1) < length { i + 1 } else { 0 };
-                tangents.push(T::auto_tangent(
-                    samples[p], samples[i], samples[n], &values[p], &values[i], &values[n],
-                ));
+        if tangent_control == TangentControl::Auto
+            || tangent_control == TangentControl::Free
+            || tangent_control == TangentControl::Broken
+        {
+            if length == 1 {
+                tangents.push(T::FLAT_TANGENT);
+            } else {
+                for i in 0..length {
+                    let p = if i > 0 { i - 1 } else { length - 1 };
+                    let n = if (i + 1) < length { i + 1 } else { 0 };
+                    tangents.push(T::auto_tangent(
+                        samples[p], samples[i], samples[n], &values[p], &values[i], &values[n],
+                    ));
+                }
             }
+        } else {
+            tangents.resize(length, T::FLAT_TANGENT);
         }
 
         let mut tangents_control = Vec::with_capacity(length);
-        tangents_control.resize(length, TangentControl::Auto);
+        tangents_control.resize(length, tangent_control);
 
         let mut modes = Vec::with_capacity(length);
-        modes.resize(length, Interpolation::CatmullRom);
+        modes.resize(length, mode);
 
-        Self {
+        Ok(Self {
             time_stamps: samples,
             keyframes: values,
             modes,
             tangents_control,
             tangents_in: tangents.clone(),
             tangents_out: tangents,
-        }
+        })
     }
 
     pub fn from_line(t0: f32, t1: f32, v0: T, v1: T) -> Self {
@@ -175,6 +206,8 @@ where
     /// Insert a new keyframe
     ///
     /// ```rust
+    /// use bevy_math::curves::{CurveVariable, TangentControl};
+    ///
     /// # fn main() {
     /// let mut curve = CurveVariable::from_constant(0.0f32);
     /// curve.insert()
@@ -562,41 +595,5 @@ impl<'a, T: Interpolate> CurveVariableKeyframeBuilder<'a, T> {
 
 // #[cfg(test)]
 // mod tests {
-//     use super::*;
-
-//     #[test]
-//     fn curve_evaluation() {
-//         let curve = CurveVariableInterpolated::new(
-//             vec![0.0, 0.25, 0.5, 0.75, 1.0],
-//             vec![0.0, 0.5, 1.0, 1.5, 2.0],
-//         );
-//         assert_eq!(curve.sample(0.5), 1.0);
-
-//         let mut i0 = 0;
-//         let mut e0 = 0.0;
-//         for v in &[0.1, 0.3, 0.7, 0.4, 0.2, 0.0, 0.4, 0.85, 1.0] {
-//             let v = *v;
-//             let (i1, e1) = curve.sample_indexed(i0, v);
-//             assert_eq!(e1, 2.0 * v);
-//             if e1 > e0 {
-//                 assert!(i1 >= i0);
-//             } else {
-//                 assert!(i1 <= i0);
-//             }
-//             e0 = e1;
-//             i0 = i1;
-//         }
-//     }
-
-//     #[test]
-//     #[should_panic]
-//     fn curve_bad_length() {
-//         let _ = CurveVariableInterpolated::new(vec![0.0, 0.5, 1.0], vec![0.0, 1.0]);
-//     }
-
-//     #[test]
-//     #[should_panic]
-//     fn curve_time_samples_not_sorted() {
-//         let _ = CurveVariableInterpolated::new(vec![0.0, 1.5, 1.0], vec![0.0, 1.0, 2.0]);
-//     }
+// TODO: Tests for creating, evaluating and editing the `CurveVariable`
 // }
diff --git a/crates/bevy_math/src/curves/variable_linear.rs b/crates/bevy_math/src/curves/variable_linear.rs
index 971d64a24ea0e..0148791a353bb 100644
--- a/crates/bevy_math/src/curves/variable_linear.rs
+++ b/crates/bevy_math/src/curves/variable_linear.rs
@@ -1,5 +1,5 @@
 use crate::{
-    curves::{Curve, CurveCursor},
+    curves::{Curve, CurveCreationError, CurveCursor},
     interpolation::Lerp,
 };
 
@@ -32,36 +32,33 @@ impl<T: Clone> Clone for CurveVariableLinear<T> {
 }
 
 impl<T> CurveVariableLinear<T> {
-    pub fn new(samples: Vec<f32>, values: Vec<T>) -> Self {
-        // TODO: Result?
+    pub fn new(samples: Vec<f32>, values: Vec<T>) -> Result<Self, CurveCreationError> {
+        let length = samples.len();
 
         // Make sure both have the same length
-        assert!(
-            samples.len() == values.len(),
-            "samples and values must have the same length"
-        );
-
-        assert!(
-            values.len() <= CurveCursor::MAX as usize,
-            "limit of {} keyframes exceeded",
-            CurveCursor::MAX
-        );
+        if length != values.len() {
+            Err(CurveCreationError::MissMachLength)?;
+        }
 
-        assert!(!samples.is_empty(), "empty curve");
+        if values.len() > CurveCursor::MAX as usize {
+            Err(CurveCreationError::KeyframeLimitReached(
+                CurveCursor::MAX as usize,
+            ))?;
+        }
 
         // Make sure the
-        assert!(
-            samples
-                .iter()
-                .zip(samples.iter().skip(1))
-                .all(|(a, b)| a < b),
-            "time samples must be on ascending order"
-        );
+        if !samples
+            .iter()
+            .zip(samples.iter().skip(1))
+            .all(|(a, b)| a < b)
+        {
+            Err(CurveCreationError::NotSorted)?;
+        }
 
-        Self {
+        Ok(Self {
             time_stamps: samples,
             keyframes: values,
-        }
+        })
     }
 
     pub fn from_line(t0: f32, t1: f32, v0: T, v1: T) -> Self {
@@ -214,7 +211,8 @@ mod tests {
         let curve = CurveVariableLinear::new(
             vec![0.0, 0.25, 0.5, 0.75, 1.0],
             vec![0.0, 0.5, 1.0, 1.5, 2.0],
-        );
+        )
+        .unwrap();
         assert!((curve.sample(0.5) - 1.0).abs() < f32::EPSILON);
 
         let mut i0 = 0;
@@ -236,12 +234,12 @@ mod tests {
     #[test]
     #[should_panic]
     fn curve_bad_length() {
-        let _ = CurveVariableLinear::new(vec![0.0, 0.5, 1.0], vec![0.0, 1.0]);
+        let _ = CurveVariableLinear::new(vec![0.0, 0.5, 1.0], vec![0.0, 1.0]).unwrap();
     }
 
     #[test]
     #[should_panic]
     fn curve_time_samples_not_sorted() {
-        let _ = CurveVariableLinear::new(vec![0.0, 1.5, 1.0], vec![0.0, 1.0, 2.0]);
+        let _ = CurveVariableLinear::new(vec![0.0, 1.5, 1.0], vec![0.0, 1.0, 2.0]).unwrap();
     }
 }
diff --git a/examples/animations/smooth_curves.rs b/examples/animations/smooth_curves.rs
index c67327af9da32..1118062cf26de 100644
--- a/examples/animations/smooth_curves.rs
+++ b/examples/animations/smooth_curves.rs
@@ -1,5 +1,8 @@
 use bevy::{
-    math::curves::{Curve, CurveCursor, CurveVariable},
+    math::{
+        curves::{Curve, CurveCursor, CurveVariable, TangentControl},
+        interpolation::Interpolation,
+    },
     prelude::*,
     render::pipeline::PrimitiveTopology,
 };
@@ -46,10 +49,13 @@ fn setup(
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
     // Create curve
-    curve_mesh.curve = CurveVariable::with_auto_tangents(
+    curve_mesh.curve = CurveVariable::with_tangents_and_mode(
         vec![0.0, 1.0, 1.3, 1.6, 1.7, 1.8, 1.9, 2.0],
         vec![3.0, 0.0, 1.0, 0.0, 0.5, 0.0, 0.25, 0.0],
-    );
+        TangentControl::Auto,
+        Interpolation::CatmullRom,
+    )
+    .unwrap();
     // Create timer
     curve_mesh.timer = Timer::from_seconds(2.5, true);
 

From 6857f544a3f8440e8053d2580e85e7e9f9bfe6d8 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sat, 17 Apr 2021 02:40:58 -0300
Subject: [PATCH 128/153] fix clippy error

---
 crates/bevy_math/src/curves/variable.rs        | 10 +++++-----
 crates/bevy_math/src/curves/variable_linear.rs |  8 ++++----
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index 7d04f9f4d26c1..67b12f790210c 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -107,13 +107,13 @@ where
 
         // Make sure both have the same length
         if length != values.len() {
-            Err(CurveCreationError::MissMachLength)?;
+            return Err(CurveCreationError::MissMachLength);
         }
 
         if values.len() > CurveCursor::MAX as usize {
-            Err(CurveCreationError::KeyframeLimitReached(
+            return Err(CurveCreationError::KeyframeLimitReached(
                 CurveCursor::MAX as usize,
-            ))?;
+            ));
         }
 
         // Make sure the
@@ -122,7 +122,7 @@ where
             .zip(samples.iter().skip(1))
             .all(|(a, b)| a < b)
         {
-            Err(CurveCreationError::NotSorted)?;
+            return Err(CurveCreationError::NotSorted);
         }
 
         let mut tangents = Vec::with_capacity(length);
@@ -227,7 +227,7 @@ where
                 .copied()
                 .map_or(0.0, |t| t + 0.03333),
             value: self.keyframes.last().unwrap().clone(),
-            mode: self.modes.last().unwrap().clone(),
+            mode: *self.modes.last().unwrap(),
             tangent_control: TangentControl::Auto,
             tangent_in: T::FLAT_TANGENT,
             tangent_out: T::FLAT_TANGENT,
diff --git a/crates/bevy_math/src/curves/variable_linear.rs b/crates/bevy_math/src/curves/variable_linear.rs
index 0148791a353bb..f2414fe6743aa 100644
--- a/crates/bevy_math/src/curves/variable_linear.rs
+++ b/crates/bevy_math/src/curves/variable_linear.rs
@@ -37,13 +37,13 @@ impl<T> CurveVariableLinear<T> {
 
         // Make sure both have the same length
         if length != values.len() {
-            Err(CurveCreationError::MissMachLength)?;
+            return Err(CurveCreationError::MissMachLength);
         }
 
         if values.len() > CurveCursor::MAX as usize {
-            Err(CurveCreationError::KeyframeLimitReached(
+            return Err(CurveCreationError::KeyframeLimitReached(
                 CurveCursor::MAX as usize,
-            ))?;
+            ));
         }
 
         // Make sure the
@@ -52,7 +52,7 @@ impl<T> CurveVariableLinear<T> {
             .zip(samples.iter().skip(1))
             .all(|(a, b)| a < b)
         {
-            Err(CurveCreationError::NotSorted)?;
+            return Err(CurveCreationError::NotSorted);
         }
 
         Ok(Self {

From b36cd7d5be5af2140d404d1397d75c7718b069c3 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sat, 17 Apr 2021 10:23:56 -0300
Subject: [PATCH 129/153] fix tests

---
 examples/animations/smooth_curves.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/animations/smooth_curves.rs b/examples/animations/smooth_curves.rs
index 1118062cf26de..407d13a25ea5b 100644
--- a/examples/animations/smooth_curves.rs
+++ b/examples/animations/smooth_curves.rs
@@ -141,7 +141,7 @@ fn setup(
         .insert(CurveTargetTag);
 
     // Camera and Light
-    commands.spawn_bundle(LightBundle {
+    commands.spawn_bundle(PointLightBundle {
         transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
         ..Default::default()
     });

From 281a9127fba80ff78b00963d4b244007dc24aa70 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sat, 17 Apr 2021 10:29:22 -0300
Subject: [PATCH 130/153] force ci to rerun

---
 crates/bevy_math/src/curves/variable.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index 67b12f790210c..0d89b205151f9 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -18,6 +18,7 @@ impl Default for TangentControl {
     }
 }
 
+// remove-me
 // TODO: Test performance by packing keyframe runtime info (value, mode, in_tangent, out_tangent)
 // pub struct CurveVariableKeyframe<T: Interpolate> {
 //     pub value: T,

From 00a6f5761c96494fb8df375f6795b670b2ddb683 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sat, 17 Apr 2021 11:10:56 -0300
Subject: [PATCH 131/153] curve variable bench

---
 benches/Cargo.toml                            |  6 ++
 benches/benches/bevy_math/curves.rs           | 58 +++++++++++++++++++
 crates/bevy_math/src/curves/mod.rs            |  2 +-
 crates/bevy_math/src/curves/variable.rs       |  7 ++-
 .../src/interpolation/interpolate.rs          |  3 +-
 crates/bevy_math/src/interpolation/lerp.rs    | 10 +++-
 6 files changed, 81 insertions(+), 5 deletions(-)
 create mode 100644 benches/benches/bevy_math/curves.rs

diff --git a/benches/Cargo.toml b/benches/Cargo.toml
index ca22ca2f3b835..84e7b611af55b 100644
--- a/benches/Cargo.toml
+++ b/benches/Cargo.toml
@@ -9,6 +9,7 @@ edition = "2018"
 
 [dev-dependencies]
 criterion = "0.3"
+rand = "0.8.3"
 bevy = { path = "../" }
 
 [[bench]]
@@ -20,3 +21,8 @@ harness = false
 name = "iter"
 path = "benches/bevy_tasks/iter.rs"
 harness = false
+
+[[bench]]
+name = "curves"
+path = "benches/bevy_math/curves.rs"
+harness = false
diff --git a/benches/benches/bevy_math/curves.rs b/benches/benches/bevy_math/curves.rs
new file mode 100644
index 0000000000000..5172fdee3921d
--- /dev/null
+++ b/benches/benches/bevy_math/curves.rs
@@ -0,0 +1,58 @@
+use bevy::math::{
+    curves::{Curve, CurveCursor, CurveVariable},
+    Vec4,
+};
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use rand::prelude::*;
+
+criterion_group!(benches, curve_variable);
+criterion_main!(benches);
+
+const SAMPLES_COUNT: usize = 100;
+
+fn curve_sampling<T>(samples: &[f32], curve: &impl Curve<Output = T>) {
+    let mut c: CurveCursor = 0;
+    for t in samples {
+        let (nc, v) = curve.sample_with_cursor(c, *t);
+        black_box(v);
+        c = nc;
+    }
+}
+
+fn curve_variable(criterion: &mut Criterion) {
+    let mut group = criterion.benchmark_group("curve_variable");
+    group.warm_up_time(std::time::Duration::from_millis(500));
+    group.measurement_time(std::time::Duration::from_secs(3));
+
+    let curve = CurveVariable::with_auto_tangents(
+        vec![0.0, 1.0, 1.3, 1.6, 1.7, 1.8, 1.9, 2.0],
+        vec![3.0, 0.0, 1.0, 0.0, 0.5, 0.0, 0.25, 0.0]
+            .iter()
+            .map(|x| Vec4::splat(*x))
+            .collect::<Vec<_>>(),
+    )
+    .unwrap();
+
+    let duration = curve.duration();
+    let mut rand = rand::thread_rng();
+
+    let rand_samples = (0..SAMPLES_COUNT)
+        .into_iter()
+        .map(|_| duration * rand.gen::<f32>())
+        .collect::<Vec<_>>();
+
+    let samples = (0..SAMPLES_COUNT)
+        .into_iter()
+        .map(|i| duration * (i as f32) / (SAMPLES_COUNT - 1) as f32)
+        .collect::<Vec<_>>();
+
+    group.bench_function("random_sampling", |bencher| {
+        bencher.iter(|| black_box(curve_sampling(&rand_samples[..], &curve)));
+    });
+
+    group.bench_function("sampling", |bencher| {
+        bencher.iter(|| black_box(curve_sampling(&samples[..], &curve)));
+    });
+
+    group.finish()
+}
diff --git a/crates/bevy_math/src/curves/mod.rs b/crates/bevy_math/src/curves/mod.rs
index 15df411ce6def..751eefe00a1a7 100644
--- a/crates/bevy_math/src/curves/mod.rs
+++ b/crates/bevy_math/src/curves/mod.rs
@@ -24,7 +24,7 @@ pub trait Curve {
     /// Samples the curve starting from some keyframe cursor, this make the common case `O(1)`
     ///
     /// **NOTE** Each keyframe is indexed by a `u16` to reduce memory usage when using the keyframe caching
-    fn sample_with_cursor(&self, cursor: u16, time: f32) -> (CurveCursor, Self::Output);
+    fn sample_with_cursor(&self, cursor: CurveCursor, time: f32) -> (CurveCursor, Self::Output);
 }
 
 #[derive(Error, Debug)]
diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index 0d89b205151f9..6e3bc9687835c 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -18,7 +18,6 @@ impl Default for TangentControl {
     }
 }
 
-// remove-me
 // TODO: Test performance by packing keyframe runtime info (value, mode, in_tangent, out_tangent)
 // pub struct CurveVariableKeyframe<T: Interpolate> {
 //     pub value: T,
@@ -449,7 +448,11 @@ where
         self.sample_with_cursor(index as u16, time).1
     }
 
-    fn sample_with_cursor(&self, mut cursor: u16, time: f32) -> (u16, Self::Output) {
+    fn sample_with_cursor(
+        &self,
+        mut cursor: CurveCursor,
+        time: f32,
+    ) -> (CurveCursor, Self::Output) {
         // Adjust for the current keyframe cursor
         let last_cursor = (self.time_stamps.len() - 1) as u16;
 
diff --git a/crates/bevy_math/src/interpolation/interpolate.rs b/crates/bevy_math/src/interpolation/interpolate.rs
index e8217e8fd1023..cea75b62f497c 100644
--- a/crates/bevy_math/src/interpolation/interpolate.rs
+++ b/crates/bevy_math/src/interpolation/interpolate.rs
@@ -1,5 +1,5 @@
 use super::{utils, Lerp};
-use crate::{Quat, Vec2, Vec3, Vec4};
+use crate::{Quat, Vec2, Vec3, Vec3A, Vec4};
 
 // http://archive.gamedev.net/archive/reference/articles/article1497.html (bit old)
 
@@ -108,6 +108,7 @@ macro_rules! interpolate {
 interpolate!(f32, 0.0);
 interpolate!(Vec2, Vec2::ZERO);
 interpolate!(Vec3, Vec3::ZERO);
+interpolate!(Vec3A, Vec3A::ZERO);
 interpolate!(Vec4, Vec4::ZERO);
 
 // TODO: Color can't be interpolated because color operations are undefined, see pr #1870
diff --git a/crates/bevy_math/src/interpolation/lerp.rs b/crates/bevy_math/src/interpolation/lerp.rs
index b235c88ccde8c..a05cd853eb6eb 100644
--- a/crates/bevy_math/src/interpolation/lerp.rs
+++ b/crates/bevy_math/src/interpolation/lerp.rs
@@ -1,4 +1,4 @@
-use crate::{interpolation::utils::*, Quat, Vec2, Vec3, Vec4};
+use crate::{interpolation::utils::*, Quat, Vec2, Vec3, Vec3A, Vec4};
 
 /// Defines how a particular type will be interpolated
 pub trait Lerp: Sized {
@@ -37,6 +37,7 @@ impl Lerp for Vec2 {
     }
 }
 
+/// **NOTE** Prefer [`Vec3A`] or [`Vec4`] whenever possible, using [`Vec3`] is 2 times slower
 impl Lerp for Vec3 {
     #[inline]
     fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {
@@ -44,6 +45,13 @@ impl Lerp for Vec3 {
     }
 }
 
+impl Lerp for Vec3A {
+    #[inline]
+    fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {
+        (*a) * (1.0 - t) + (*b) * t
+    }
+}
+
 impl Lerp for Vec4 {
     #[inline]
     fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {

From d7306a1edac4eb152909873ac141c1bf60f8e27b Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sat, 17 Apr 2021 12:05:19 -0300
Subject: [PATCH 132/153] soa is better for random sampling

---
 crates/bevy_math/src/curves/variable.rs | 17 ++---------------
 1 file changed, 2 insertions(+), 15 deletions(-)

diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index 6e3bc9687835c..36f6ea7fe7658 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -18,16 +18,10 @@ impl Default for TangentControl {
     }
 }
 
-// TODO: Test performance by packing keyframe runtime info (value, mode, in_tangent, out_tangent)
-// pub struct CurveVariableKeyframe<T: Interpolate> {
-//     pub value: T,
-//     pub interpolation: Interpolation,
-//     pub in_tangent: T::Tangent,
-//     pub out_tangent: T::Tangent,
-// }
-
 // TODO: impl Serialize, Deserialize
 // TODO: How better handling of SOA? the length for instance is repeated and extra checks are need on deserialization
+// ? NOTE: Using a AOS of value, mode and tangents in and out, decreases performance on random sampling by ~15%,
+// ? sequential sampling remains unchanged
 /// Curve with sparse keyframes frames, in another words a curve with variable frame rate;
 ///
 /// Similar in design to the [`CurveVariableLinear`](super::CurveVariableLinear) but allows
@@ -418,13 +412,6 @@ where
     pub fn iter(&self) -> impl Iterator<Item = (f32, &T)> {
         self.time_stamps.iter().copied().zip(self.keyframes.iter())
     }
-
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = (f32, &mut T)> {
-        self.time_stamps
-            .iter()
-            .copied()
-            .zip(self.keyframes.iter_mut())
-    }
 }
 
 impl<T> Curve for CurveVariable<T>

From f7a0bb409b422c1cad5158c737dc1debaa7bbf32 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sat, 17 Apr 2021 12:06:53 -0300
Subject: [PATCH 133/153] remove unused variables

---
 examples/animations/smooth_curves.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/examples/animations/smooth_curves.rs b/examples/animations/smooth_curves.rs
index 407d13a25ea5b..060b5698a7bf9 100644
--- a/examples/animations/smooth_curves.rs
+++ b/examples/animations/smooth_curves.rs
@@ -15,7 +15,6 @@ struct CurveTargetTag;
 struct CurveMesh {
     timer: Timer,
     curve: CurveVariable<f32>,
-    mesh: Handle<Mesh>,
 }
 
 fn main() {
@@ -76,7 +75,6 @@ fn setup(
     mesh.set_attribute(Mesh::ATTRIBUTE_TANGENT, values(DIVS, [0.0f32, 1.0, 0.0]));
     mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, values(DIVS, [0.0f32; 2]));
     let mesh = meshes.add(mesh);
-    curve_mesh.mesh = mesh.clone();
 
     let material = materials.add(Color::RED.into());
     let keyframe_mesh = meshes.add(Mesh::from(shape::Cube { size: 0.05 }));

From d564c5313cbd2d9c4fcb49107c72fe452778db45 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 18 Apr 2021 17:45:29 -0300
Subject: [PATCH 134/153] fix set_time and auto tangent

---
 crates/bevy_math/src/curves/variable.rs     | 137 +++++++++++++++++---
 crates/bevy_math/src/interpolation/utils.rs |   2 +-
 2 files changed, 118 insertions(+), 21 deletions(-)

diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index 36f6ea7fe7658..2bd5bb243c1af 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -128,8 +128,8 @@ where
                 tangents.push(T::FLAT_TANGENT);
             } else {
                 for i in 0..length {
-                    let p = if i > 0 { i - 1 } else { length - 1 };
-                    let n = if (i + 1) < length { i + 1 } else { 0 };
+                    let p = if i > 0 { i - 1 } else { 0 };
+                    let n = if (i + 1) < length { i + 1 } else { length - 1 };
                     tangents.push(T::auto_tangent(
                         samples[p], samples[i], samples[n], &values[p], &values[i], &values[n],
                     ));
@@ -253,29 +253,69 @@ where
         self.adjust_tangents_with_neighbors(i);
     }
 
-    pub fn set_time(&mut self, index: CurveCursor, time: f32) {
+    pub fn set_time(&mut self, index: CurveCursor, time: f32) -> Option<CurveCursor> {
         let i = index as usize;
-        let j = self
-            .time_stamps
-            .iter()
-            .position(|t| *t < time)
-            .unwrap_or_else(|| self.time_stamps.len() - 1);
+        
+        let mut j = i;
+        let last = self.time_stamps.len() - 1;
+        if self.time_stamps[j] < time {
+            // Forward search
+            loop {
+                if j == last { break; }
+
+                let temp = j + 1;
+                if self.time_stamps[temp] > time {
+                    break;
+                }
+
+                j = temp;
+            }
+        } else {
+            // Backward search
+            loop {
+                if j == 0 { break; }
+
+                let temp = j - 1;
+                if self.time_stamps[temp] < time {
+                    break;
+                }
 
-        if i != j {
+                j = temp;
+            }
+        }
+
+        if i < j {
+            // Move forward
             let k = j + 1;
-            self.time_stamps[i..k].rotate_left(0);
-            self.keyframes[i..k].rotate_left(0);
-            self.modes[i..k].rotate_left(0);
-            self.tangents_control[i..k].rotate_left(0);
-            self.tangents_in[i..k].rotate_left(0);
-            self.tangents_out[i..k].rotate_left(0);
+            self.time_stamps[i..k].rotate_left(1);
+            self.keyframes[i..k].rotate_left(1);
+            self.modes[i..k].rotate_left(1);
+            self.tangents_control[i..k].rotate_left(1);
+            self.tangents_in[i..k].rotate_left(1);
+            self.tangents_out[i..k].rotate_left(1);
+
+            self.adjust_tangents_with_neighbors(j);
+            self.adjust_tangents_with_neighbors(i);
+        } else if i > j {
+            // Move backward
+            let k = i + 1;
+            self.time_stamps[j..k].rotate_right(1);
+            self.keyframes[j..k].rotate_right(1);
+            self.modes[j..k].rotate_right(1);
+            self.tangents_control[j..k].rotate_right(1);
+            self.tangents_in[j..k].rotate_right(1);
+            self.tangents_out[j..k].rotate_right(1);
 
             self.adjust_tangents_with_neighbors(j);
+            self.adjust_tangents_with_neighbors(i);
         } else {
+            // Just update the keyframe time
             self.time_stamps[i] = time;
+            self.adjust_tangents_with_neighbors(i);
+            return None;
         }
 
-        self.adjust_tangents_with_neighbors(i);
+        return Some(j as CurveCursor);
     }
 
     #[inline]
@@ -584,7 +624,64 @@ impl<'a, T: Interpolate> CurveVariableKeyframeBuilder<'a, T> {
     }
 }
 
-// #[cfg(test)]
-// mod tests {
-// TODO: Tests for creating, evaluating and editing the `CurveVariable`
-// }
+#[cfg(test)]
+mod tests {
+    use super::*;
+    // TODO: Tests for creating, evaluating and editing the `CurveVariable`
+
+    #[test]
+    fn set_keyframe_value() {
+        let mut curve =
+            CurveVariable::with_auto_tangents(vec![0.0, 1.0, 2.0], vec![0.0, 1.0, 0.0]).unwrap();
+        curve.set_value(0, 1.0);
+        curve.set_value(1, 0.0);
+        curve.set_value(2, 1.0);
+
+        let ground_truth: Vec<f32> = vec![
+            1.0,
+            0.80658436,
+            0.5144033,
+            0.22222212,
+            0.028806567,
+            0.028806612,
+            0.22222227,
+            0.5144033,
+            0.80658436,
+            1.0,
+        ];
+        let samples = (0..10)
+            .into_iter()
+            .map(|i| curve.sample(2.0 * i as f32 / 9.0))
+            .collect::<Vec<_>>();
+
+        assert_eq!(ground_truth.len(), samples.len());
+        assert!(ground_truth
+            .iter()
+            .zip(samples.iter())
+            .all(|(a, b)| (a - b).abs() < std::f32::EPSILON));
+    }
+
+    #[test]
+    fn set_keyframe_time() {
+        let mut curve =
+            CurveVariable::with_auto_tangents(vec![0.0, 1.0, 2.0, 3.0], vec![1.0, 0.0, 0.0, 0.0])
+                .unwrap();
+
+        // Don't change keyframe
+        assert_eq!(curve.set_time(0, 0.0), None);
+        assert_eq!(curve.set_time(1, 1.0), None);
+        assert_eq!(curve.set_time(2, 2.0), None);
+        assert_eq!(curve.set_time(3, 3.0), None);
+        assert_eq!(curve.set_time(0, 0.5), None);
+
+        // Change keyframe
+        assert_eq!(curve.set_time(0, 1.5), Some(1));
+        assert!((*curve.get_value(1) - 1.0).abs() < std::f32::EPSILON);
+
+        assert_eq!(curve.set_time(1, 2.5), Some(2));
+        assert!((*curve.get_value(2) - 1.0).abs() < std::f32::EPSILON);
+
+        assert_eq!(curve.set_time(2, 0.0), Some(0));
+        assert!((*curve.get_value(0) - 1.0).abs() < std::f32::EPSILON);
+    }
+}
diff --git a/crates/bevy_math/src/interpolation/utils.rs b/crates/bevy_math/src/interpolation/utils.rs
index 5907785373fd9..90adc19989d5e 100644
--- a/crates/bevy_math/src/interpolation/utils.rs
+++ b/crates/bevy_math/src/interpolation/utils.rs
@@ -61,5 +61,5 @@ where
     T: Copy + Add<Output = T> + Sub<Output = T> + Mul<f32, Output = T> + Div<f32, Output = T>,
 {
     // k'(t) = ½[k(t) - k(t-1)]/δx1 + ½[k(t+1) - k(t)]/δx2
-    ((k1 - k0) / (t1 - t0) + (k2 - k1) / (t2 - t1)) * 0.5
+    ((k1 - k0) / (t1 - t0).max(1e-9) + (k2 - k1) / (t2 - t1).max(1e-9)) * 0.5
 }

From 69587dcb69020cea14ee420eccaa9de655236d22 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 18 Apr 2021 17:50:32 -0300
Subject: [PATCH 135/153] fmt + clippy

---
 crates/bevy_math/src/curves/variable.rs | 76 ++++++++++++++-----------
 1 file changed, 43 insertions(+), 33 deletions(-)

diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index 2bd5bb243c1af..7221087f5dde4 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -1,3 +1,5 @@
+use std::cmp::Ordering;
+
 use crate::{
     curves::{Curve, CurveCreationError, CurveCursor},
     interpolation::{Interpolate, Interpolation},
@@ -255,13 +257,15 @@ where
 
     pub fn set_time(&mut self, index: CurveCursor, time: f32) -> Option<CurveCursor> {
         let i = index as usize;
-        
+
         let mut j = i;
         let last = self.time_stamps.len() - 1;
         if self.time_stamps[j] < time {
             // Forward search
             loop {
-                if j == last { break; }
+                if j == last {
+                    break;
+                }
 
                 let temp = j + 1;
                 if self.time_stamps[temp] > time {
@@ -273,7 +277,9 @@ where
         } else {
             // Backward search
             loop {
-                if j == 0 { break; }
+                if j == 0 {
+                    break;
+                }
 
                 let temp = j - 1;
                 if self.time_stamps[temp] < time {
@@ -284,38 +290,42 @@ where
             }
         }
 
-        if i < j {
-            // Move forward
-            let k = j + 1;
-            self.time_stamps[i..k].rotate_left(1);
-            self.keyframes[i..k].rotate_left(1);
-            self.modes[i..k].rotate_left(1);
-            self.tangents_control[i..k].rotate_left(1);
-            self.tangents_in[i..k].rotate_left(1);
-            self.tangents_out[i..k].rotate_left(1);
-
-            self.adjust_tangents_with_neighbors(j);
-            self.adjust_tangents_with_neighbors(i);
-        } else if i > j {
-            // Move backward
-            let k = i + 1;
-            self.time_stamps[j..k].rotate_right(1);
-            self.keyframes[j..k].rotate_right(1);
-            self.modes[j..k].rotate_right(1);
-            self.tangents_control[j..k].rotate_right(1);
-            self.tangents_in[j..k].rotate_right(1);
-            self.tangents_out[j..k].rotate_right(1);
-
-            self.adjust_tangents_with_neighbors(j);
-            self.adjust_tangents_with_neighbors(i);
-        } else {
-            // Just update the keyframe time
-            self.time_stamps[i] = time;
-            self.adjust_tangents_with_neighbors(i);
-            return None;
+        match i.cmp(&j) {
+            Ordering::Greater => {
+                // Move backward
+                let k = i + 1;
+                self.time_stamps[j..k].rotate_right(1);
+                self.keyframes[j..k].rotate_right(1);
+                self.modes[j..k].rotate_right(1);
+                self.tangents_control[j..k].rotate_right(1);
+                self.tangents_in[j..k].rotate_right(1);
+                self.tangents_out[j..k].rotate_right(1);
+
+                self.adjust_tangents_with_neighbors(j);
+                self.adjust_tangents_with_neighbors(i);
+            }
+            Ordering::Less => {
+                // Move forward
+                let k = j + 1;
+                self.time_stamps[i..k].rotate_left(1);
+                self.keyframes[i..k].rotate_left(1);
+                self.modes[i..k].rotate_left(1);
+                self.tangents_control[i..k].rotate_left(1);
+                self.tangents_in[i..k].rotate_left(1);
+                self.tangents_out[i..k].rotate_left(1);
+
+                self.adjust_tangents_with_neighbors(j);
+                self.adjust_tangents_with_neighbors(i);
+            }
+            Ordering::Equal => {
+                // Just update the keyframe time
+                self.time_stamps[i] = time;
+                self.adjust_tangents_with_neighbors(i);
+                return None;
+            }
         }
 
-        return Some(j as CurveCursor);
+        Some(j as CurveCursor)
     }
 
     #[inline]

From 8953ef7ec3ccb64e087a5349e080a6f85020cc9a Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sat, 1 May 2021 21:58:15 -0300
Subject: [PATCH 136/153] renamed curve algo

---
 crates/bevy_math/src/curves/variable.rs           |  6 +++---
 crates/bevy_math/src/interpolation/interpolate.rs | 11 +++++------
 crates/bevy_math/src/interpolation/utils.rs       |  8 +++++---
 3 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index 7221087f5dde4..7498ddf753df7 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -76,7 +76,7 @@ where
             samples,
             values,
             TangentControl::Flat,
-            Interpolation::CatmullRom,
+            Interpolation::Hermite,
         )
     }
 
@@ -89,7 +89,7 @@ where
             samples,
             values,
             TangentControl::Auto,
-            Interpolation::CatmullRom,
+            Interpolation::Hermite,
         )
     }
 
@@ -192,7 +192,7 @@ where
         Self {
             time_stamps: vec![0.0],
             keyframes: vec![v],
-            modes: vec![Interpolation::CatmullRom],
+            modes: vec![Interpolation::Hermite],
             tangents_control: vec![TangentControl::Auto],
             tangents_in: vec![T::FLAT_TANGENT],
             tangents_out: vec![T::FLAT_TANGENT],
diff --git a/crates/bevy_math/src/interpolation/interpolate.rs b/crates/bevy_math/src/interpolation/interpolate.rs
index cea75b62f497c..bdc0c259e1424 100644
--- a/crates/bevy_math/src/interpolation/interpolate.rs
+++ b/crates/bevy_math/src/interpolation/interpolate.rs
@@ -10,10 +10,11 @@ pub struct TangentIgnore;
 pub enum Interpolation {
     Step,
     Linear,
-    CatmullRom,
+    Hermite,
 }
 
 pub trait Interpolate: Lerp + Clone {
+    /// Tangent used for the hermite interpolation
     type Tangent: Copy;
 
     const FLAT_TANGENT: Self::Tangent;
@@ -84,9 +85,7 @@ macro_rules! interpolate {
                 match interp {
                     Interpolation::Step => utils::step_unclamped(k0, k1, t),
                     Interpolation::Linear => utils::lerp_unclamped(*k0, *k1, t),
-                    Interpolation::CatmullRom => {
-                        utils::catmull_rom_unclamped(*k0, *t0, *k1, *t1, t, dt)
-                    }
+                    Interpolation::Hermite => utils::hermite_unclamped(*k0, *t0, *k1, *t1, t, dt),
                 }
             }
 
@@ -163,14 +162,14 @@ impl Interpolate for Quat {
                 let d = utils::inv_sqrt(q.dot(q));
                 (q * d).into()
             }
-            Interpolation::CatmullRom => {
+            Interpolation::Hermite => {
                 // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
                 let mut k1 = *k1;
                 if k0.dot(k1) < 0.0 {
                     k1 = -k1;
                 }
 
-                let q = utils::catmull_rom_unclamped::<Vec4>(
+                let q = utils::hermite_unclamped::<Vec4>(
                     (*k0).into(),
                     (*t0).into(),
                     k1.into(),
diff --git a/crates/bevy_math/src/interpolation/utils.rs b/crates/bevy_math/src/interpolation/utils.rs
index 90adc19989d5e..65378335d82b7 100644
--- a/crates/bevy_math/src/interpolation/utils.rs
+++ b/crates/bevy_math/src/interpolation/utils.rs
@@ -33,11 +33,11 @@ where
     k0 * (1.0 - u) + k1 * u
 }
 
-/// Catmull-Rom spline interpolation
+/// Cubic hermite spline
 ///
 /// Source: http://archive.gamedev.net/archive/reference/articles/article1497.html
 #[inline]
-pub fn catmull_rom_unclamped<T>(k0: T, t0: T, k1: T, t1: T, u: f32, dx: f32) -> T
+pub fn hermite_unclamped<T>(k0: T, t0: T, k1: T, t1: T, u: f32, dx: f32) -> T
 where
     T: Add<Output = T> + Sub<Output = T> + Mul<f32, Output = T>,
 {
@@ -52,7 +52,7 @@ where
         + t1 * dx * (v_u3 - v_u2)
 }
 
-/// Finds the tangent gradients for the Catmull-Rom spline
+/// Finds the tangent gradients for the hermite spline
 ///
 /// Source: http://archive.gamedev.net/archive/reference/articles/article1497.html
 #[inline]
@@ -63,3 +63,5 @@ where
     // k'(t) = ½[k(t) - k(t-1)]/δx1 + ½[k(t+1) - k(t)]/δx2
     ((k1 - k0) / (t1 - t0).max(1e-9) + (k2 - k1) / (t2 - t1).max(1e-9)) * 0.5
 }
+
+// https://www.cubic.org/docs/hermite.htm

From d7651281b229d8da6e6a0837f04c9b8f1e75dd4d Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Thu, 6 May 2021 20:29:08 -0300
Subject: [PATCH 137/153] Update examples/README.md

Co-authored-by: Trevor Lovell <trevorlovelldesign@gmail.com>
---
 examples/README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/examples/README.md b/examples/README.md
index fc8c830626364..a298a837c243c 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -99,9 +99,9 @@ Example | File | Description
 
 Example | File | Description
 --- | --- | ---
-`run_animation` | [`animations/run_animation.rs`](./animations/run_animation.rs) | Demonstrates how to play and blending between a idle and run animations
-[//]: # (`mesh_swap_animation` | [`animations/mesh_swap_animation.rs`](./animations/mesh_swap_animation.rs) | Demonstrates hot to create your own animation clip that swaps meshes (or any other asset handle))
-[//]: # (`material_animation` | [`animations/material_animation.rs`](./animations/material_animation.rs) | Illustrate how to animate material properties (or any other asset property))
+`run_animation` | [`animations/run_animation.rs`](./animations/run_animation.rs) | Demonstrates how to play, and blend between, an idle animation and a run animation
+[//]: # (`mesh_swap_animation` | [`animations/mesh_swap_animation.rs`](./animations/mesh_swap_animation.rs) | Demonstrates how to create your own animation clip that swaps meshes (or any other asset handle))
+[//]: # (`material_animation` | [`animations/material_animation.rs`](./animations/material_animation.rs) | Illustrates how to animate material properties (or any other asset property))
 
 ## Application
 

From ab7f8acac5db71bae90fa3dd8491211a8f7276a6 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sat, 8 May 2021 15:45:10 -0300
Subject: [PATCH 138/153] fix step function and cmp interpolation enum

---
 crates/bevy_math/src/interpolation/interpolate.rs | 2 +-
 crates/bevy_math/src/interpolation/utils.rs       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_math/src/interpolation/interpolate.rs b/crates/bevy_math/src/interpolation/interpolate.rs
index bdc0c259e1424..238af78ab9d1f 100644
--- a/crates/bevy_math/src/interpolation/interpolate.rs
+++ b/crates/bevy_math/src/interpolation/interpolate.rs
@@ -6,7 +6,7 @@ use crate::{Quat, Vec2, Vec3, Vec3A, Vec4};
 #[derive(Debug, Copy, Clone)]
 pub struct TangentIgnore;
 
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum Interpolation {
     Step,
     Linear,
diff --git a/crates/bevy_math/src/interpolation/utils.rs b/crates/bevy_math/src/interpolation/utils.rs
index 65378335d82b7..d6b5aba093e4d 100644
--- a/crates/bevy_math/src/interpolation/utils.rs
+++ b/crates/bevy_math/src/interpolation/utils.rs
@@ -18,7 +18,7 @@ pub fn inv_sqrt(x: f32) -> f32 {
 
 #[inline]
 pub fn step_unclamped<T: Clone>(k0: &T, k1: &T, u: f32) -> T {
-    if u > 0.999 {
+    if u < (1.0 - 1e-9) {
         k0.clone()
     } else {
         k1.clone()

From d5ad840189a74890d2a68085ebefea9e5d867a30 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 9 May 2021 01:34:06 -0300
Subject: [PATCH 139/153] fix set free tangents and comments

---
 crates/bevy_math/src/curves/variable.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index 7498ddf753df7..ca988c923262e 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -8,9 +8,13 @@ use crate::{
 /// Keyframe tangents control mode
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum TangentControl {
+    /// Tangents are automatically calculated, based on the catmull-rom algorithm
     Auto,
+    /// In tangent will be the same as the out tangent
     Free,
+    /// Tangents will set to be [`Interpolate::FLAT_TANGENT`]
     Flat,
+    /// In and out tangents can be set to a different values
     Broken,
 }
 
@@ -395,6 +399,11 @@ where
                     );
                 }
             }
+            TangentControl::Free => {
+                // Copy left tangent into the right tangent
+                self.tangents_out[i] = self.tangents_in[i];
+                return;
+            }
             TangentControl::Flat => {}
             _ => {
                 // Do nothing

From 63aca455250c4979507f27d4e1c846acd0c45c7d Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 9 May 2021 01:45:54 -0300
Subject: [PATCH 140/153] add thiserror crate

---
 crates/bevy_math/Cargo.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_math/Cargo.toml b/crates/bevy_math/Cargo.toml
index 76d8a6dc46d94..8e5302c426a0b 100644
--- a/crates/bevy_math/Cargo.toml
+++ b/crates/bevy_math/Cargo.toml
@@ -15,3 +15,4 @@ keywords = ["bevy"]
 [dependencies]
 glam = { version = "0.14.0", features = ["serde"] }
 bevy_reflect = { path = "../bevy_reflect", version = "0.5.0", features = ["bevy"] }
+thiserror = "1.0"

From fbec101f26887ccc31750614d42e899fd7fca258 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 9 May 2021 01:53:04 -0300
Subject: [PATCH 141/153] fix samples

---
 examples/animations/smooth_curves.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/animations/smooth_curves.rs b/examples/animations/smooth_curves.rs
index 060b5698a7bf9..1fdd5096b1f71 100644
--- a/examples/animations/smooth_curves.rs
+++ b/examples/animations/smooth_curves.rs
@@ -52,7 +52,7 @@ fn setup(
         vec![0.0, 1.0, 1.3, 1.6, 1.7, 1.8, 1.9, 2.0],
         vec![3.0, 0.0, 1.0, 0.0, 0.5, 0.0, 0.25, 0.0],
         TangentControl::Auto,
-        Interpolation::CatmullRom,
+        Interpolation::Hermite,
     )
     .unwrap();
     // Create timer

From dc4d43b6d0f8ce2aebcf22ba8332b5645e243ec5 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 9 May 2021 14:49:01 -0300
Subject: [PATCH 142/153] fix error typo

Co-authored-by: Martin Svanberg <martin@martinsvanberg.com>
---
 crates/bevy_math/src/curves/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_math/src/curves/mod.rs b/crates/bevy_math/src/curves/mod.rs
index 751eefe00a1a7..6ba5de39f5469 100644
--- a/crates/bevy_math/src/curves/mod.rs
+++ b/crates/bevy_math/src/curves/mod.rs
@@ -30,7 +30,7 @@ pub trait Curve {
 #[derive(Error, Debug)]
 pub enum CurveCreationError {
     #[error("number of keyframes time stamps and values doesn't match")]
-    MissMachLength,
+    MismatchedLength,
     #[error("limit of {0} keyframes exceeded")]
     KeyframeLimitReached(usize),
     #[error("keyframes aren't sorted by time")]

From 960aff471299a187218ecf94f51ac608ac70cd5d Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 9 May 2021 14:51:38 -0300
Subject: [PATCH 143/153] idiomatic Option<T> lerp impl

Co-authored-by: Jakob Hellermann <jakob.hellermann@protonmail.com>
---
 crates/bevy_math/src/interpolation/lerp.rs | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_math/src/interpolation/lerp.rs b/crates/bevy_math/src/interpolation/lerp.rs
index a05cd853eb6eb..7ef661db093d1 100644
--- a/crates/bevy_math/src/interpolation/lerp.rs
+++ b/crates/bevy_math/src/interpolation/lerp.rs
@@ -91,13 +91,9 @@ impl Lerp for Quat {
 
 impl<T: Lerp + Clone> Lerp for Option<T> {
     fn lerp_unclamped(a: &Self, b: &Self, t: f32) -> Self {
-        match (a.is_some(), b.is_some()) {
-            (true, true) => Some(T::lerp_unclamped(
-                a.as_ref().unwrap(),
-                b.as_ref().unwrap(),
-                t,
-            )),
-            (false, true) | (true, false) | (false, false) => {
+        match (a, b) {
+            (Some(a), Some(b)) => Some(T::lerp_unclamped(a, b, t)),
+            _ => {
                 if t > 0.99 {
                     b.clone()
                 } else {

From 07c11d8998547550ca5220c0185fda1c602f65b4 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 9 May 2021 14:58:43 -0300
Subject: [PATCH 144/153] fix build errors

---
 crates/bevy_math/src/curves/variable.rs        | 2 +-
 crates/bevy_math/src/curves/variable_linear.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index ca988c923262e..71587720fd857 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -107,7 +107,7 @@ where
 
         // Make sure both have the same length
         if length != values.len() {
-            return Err(CurveCreationError::MissMachLength);
+            return Err(CurveCreationError::MismatchedLength);
         }
 
         if values.len() > CurveCursor::MAX as usize {
diff --git a/crates/bevy_math/src/curves/variable_linear.rs b/crates/bevy_math/src/curves/variable_linear.rs
index f2414fe6743aa..15b4e73c7370e 100644
--- a/crates/bevy_math/src/curves/variable_linear.rs
+++ b/crates/bevy_math/src/curves/variable_linear.rs
@@ -37,7 +37,7 @@ impl<T> CurveVariableLinear<T> {
 
         // Make sure both have the same length
         if length != values.len() {
-            return Err(CurveCreationError::MissMachLength);
+            return Err(CurveCreationError::MismatchedLength);
         }
 
         if values.len() > CurveCursor::MAX as usize {

From df986e357a855aab085e700a6247e6e6a8eb99cc Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 9 May 2021 15:14:47 -0300
Subject: [PATCH 145/153] must use keyframe insert builder

---
 crates/bevy_math/src/curves/variable.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index 71587720fd857..4bdb38215197b 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -558,6 +558,7 @@ where
     }
 }
 
+#[must_use = "use the `done` function to insert the keyframe"]
 pub struct CurveVariableKeyframeBuilder<'a, T: Interpolate> {
     curve: &'a mut CurveVariable<T>,
     time: f32,

From 6693aaf1de987a8f7f193f245e086316095f3854 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Sun, 9 May 2021 15:49:00 -0300
Subject: [PATCH 146/153] fix keyframe insertion

---
 crates/bevy_math/src/curves/mod.rs            |  2 +-
 crates/bevy_math/src/curves/variable.rs       | 53 ++++++++++---------
 .../bevy_math/src/curves/variable_linear.rs   | 12 ++---
 3 files changed, 33 insertions(+), 34 deletions(-)

diff --git a/crates/bevy_math/src/curves/mod.rs b/crates/bevy_math/src/curves/mod.rs
index 6ba5de39f5469..d38a65a0ac35a 100644
--- a/crates/bevy_math/src/curves/mod.rs
+++ b/crates/bevy_math/src/curves/mod.rs
@@ -28,7 +28,7 @@ pub trait Curve {
 }
 
 #[derive(Error, Debug)]
-pub enum CurveCreationError {
+pub enum CurveError {
     #[error("number of keyframes time stamps and values doesn't match")]
     MismatchedLength,
     #[error("limit of {0} keyframes exceeded")]
diff --git a/crates/bevy_math/src/curves/variable.rs b/crates/bevy_math/src/curves/variable.rs
index 4bdb38215197b..7ca1380bbb60d 100644
--- a/crates/bevy_math/src/curves/variable.rs
+++ b/crates/bevy_math/src/curves/variable.rs
@@ -1,7 +1,7 @@
 use std::cmp::Ordering;
 
 use crate::{
-    curves::{Curve, CurveCreationError, CurveCursor},
+    curves::{Curve, CurveCursor, CurveError},
     interpolation::{Interpolate, Interpolation},
 };
 
@@ -72,10 +72,7 @@ where
     T: Interpolate,
 {
     #[inline]
-    pub fn with_flat_tangents(
-        samples: Vec<f32>,
-        values: Vec<T>,
-    ) -> Result<Self, CurveCreationError> {
+    pub fn with_flat_tangents(samples: Vec<f32>, values: Vec<T>) -> Result<Self, CurveError> {
         Self::with_tangents_and_mode(
             samples,
             values,
@@ -85,10 +82,7 @@ where
     }
 
     #[inline]
-    pub fn with_auto_tangents(
-        samples: Vec<f32>,
-        values: Vec<T>,
-    ) -> Result<Self, CurveCreationError> {
+    pub fn with_auto_tangents(samples: Vec<f32>, values: Vec<T>) -> Result<Self, CurveError> {
         Self::with_tangents_and_mode(
             samples,
             values,
@@ -102,18 +96,16 @@ where
         values: Vec<T>,
         tangent_control: TangentControl,
         mode: Interpolation,
-    ) -> Result<Self, CurveCreationError> {
+    ) -> Result<Self, CurveError> {
         let length = samples.len();
 
         // Make sure both have the same length
         if length != values.len() {
-            return Err(CurveCreationError::MismatchedLength);
+            return Err(CurveError::MismatchedLength);
         }
 
         if values.len() > CurveCursor::MAX as usize {
-            return Err(CurveCreationError::KeyframeLimitReached(
-                CurveCursor::MAX as usize,
-            ));
+            return Err(CurveError::KeyframeLimitReached(CurveCursor::MAX as usize));
         }
 
         // Make sure the
@@ -122,7 +114,7 @@ where
             .zip(samples.iter().skip(1))
             .all(|(a, b)| a < b)
         {
-            return Err(CurveCreationError::NotSorted);
+            return Err(CurveError::NotSorted);
         }
 
         let mut tangents = Vec::with_capacity(length);
@@ -620,16 +612,23 @@ impl<'a, T: Interpolate> CurveVariableKeyframeBuilder<'a, T> {
         self.tangent_out = tangent;
     }
 
-    pub fn done(self) {
-        if let Some(i) = self.curve.time_stamps.iter().position(|t| *t < self.time) {
-            self.curve.time_stamps.insert(i, self.time);
-            self.curve.keyframes.insert(i, self.value);
-            self.curve.modes.insert(i, self.mode);
-            self.curve.tangents_control.insert(i, self.tangent_control);
-            self.curve.tangents_in.insert(i, self.tangent_in);
-            self.curve.tangents_out.insert(i, self.tangent_out);
+    pub fn done(self) -> Result<CurveCursor, CurveError> {
+        let index;
 
-            self.curve.adjust_tangents_with_neighbors(i);
+        if self.curve.len() >= (CurveCursor::MAX - 1) as usize {
+            return Err(CurveError::KeyframeLimitReached(CurveCursor::MAX as usize));
+        }
+
+        if let Some(i) = self.curve.time_stamps.iter().position(|t| *t > self.time) {
+            index = i;
+            self.curve.time_stamps.insert(index, self.time);
+            self.curve.keyframes.insert(index, self.value);
+            self.curve.modes.insert(index, self.mode);
+            self.curve
+                .tangents_control
+                .insert(index, self.tangent_control);
+            self.curve.tangents_in.insert(index, self.tangent_in);
+            self.curve.tangents_out.insert(index, self.tangent_out);
         } else {
             self.curve.time_stamps.push(self.time);
             self.curve.keyframes.push(self.value);
@@ -638,9 +637,11 @@ impl<'a, T: Interpolate> CurveVariableKeyframeBuilder<'a, T> {
             self.curve.tangents_in.push(self.tangent_in);
             self.curve.tangents_out.push(self.tangent_out);
 
-            self.curve
-                .adjust_tangents_with_neighbors(self.curve.keyframes.len() - 1);
+            index = self.curve.keyframes.len() - 1;
         }
+
+        self.curve.adjust_tangents_with_neighbors(index);
+        Ok(index as CurveCursor)
     }
 }
 
diff --git a/crates/bevy_math/src/curves/variable_linear.rs b/crates/bevy_math/src/curves/variable_linear.rs
index 15b4e73c7370e..68f280cd49989 100644
--- a/crates/bevy_math/src/curves/variable_linear.rs
+++ b/crates/bevy_math/src/curves/variable_linear.rs
@@ -1,5 +1,5 @@
 use crate::{
-    curves::{Curve, CurveCreationError, CurveCursor},
+    curves::{Curve, CurveCursor, CurveError},
     interpolation::Lerp,
 };
 
@@ -32,18 +32,16 @@ impl<T: Clone> Clone for CurveVariableLinear<T> {
 }
 
 impl<T> CurveVariableLinear<T> {
-    pub fn new(samples: Vec<f32>, values: Vec<T>) -> Result<Self, CurveCreationError> {
+    pub fn new(samples: Vec<f32>, values: Vec<T>) -> Result<Self, CurveError> {
         let length = samples.len();
 
         // Make sure both have the same length
         if length != values.len() {
-            return Err(CurveCreationError::MismatchedLength);
+            return Err(CurveError::MismatchedLength);
         }
 
         if values.len() > CurveCursor::MAX as usize {
-            return Err(CurveCreationError::KeyframeLimitReached(
-                CurveCursor::MAX as usize,
-            ));
+            return Err(CurveError::KeyframeLimitReached(CurveCursor::MAX as usize));
         }
 
         // Make sure the
@@ -52,7 +50,7 @@ impl<T> CurveVariableLinear<T> {
             .zip(samples.iter().skip(1))
             .all(|(a, b)| a < b)
         {
-            return Err(CurveCreationError::NotSorted);
+            return Err(CurveError::NotSorted);
         }
 
         Ok(Self {

From cb9e1f62f428ed670d93b6b6f55f3c3ac7f806bc Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Mon, 10 May 2021 00:25:33 -0300
Subject: [PATCH 147/153] fix merge

---
 crates/bevy_animation/src/skinned_mesh.rs  |  6 +-
 crates/bevy_render/src/mesh/mesh.rs        | 85 +---------------------
 examples/animations/mesh_swap_animation.rs |  4 +-
 examples/animations/run_animation.rs       |  2 +-
 4 files changed, 9 insertions(+), 88 deletions(-)

diff --git a/crates/bevy_animation/src/skinned_mesh.rs b/crates/bevy_animation/src/skinned_mesh.rs
index 93d2fd47ff138..2bdeebf7884f9 100644
--- a/crates/bevy_animation/src/skinned_mesh.rs
+++ b/crates/bevy_animation/src/skinned_mesh.rs
@@ -362,13 +362,13 @@ pub(crate) fn skinning_debugger_update(
 
             mesh.set_attribute(
                 Mesh::ATTRIBUTE_POSITION,
-                VertexAttributeValues::Float3(vertices),
+                VertexAttributeValues::Float32x3(vertices),
             );
             mesh.set_attribute(
                 Mesh::ATTRIBUTE_NORMAL,
-                VertexAttributeValues::Float3(normals),
+                VertexAttributeValues::Float32x3(normals),
             );
-            mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, VertexAttributeValues::Float2(uvs));
+            mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, VertexAttributeValues::Float32x2(uvs));
             mesh.set_indices(Some(Indices::U32(indices)));
         }
     }
diff --git a/crates/bevy_render/src/mesh/mesh.rs b/crates/bevy_render/src/mesh/mesh.rs
index 5c9e55a89c285..976f4951a1c7e 100644
--- a/crates/bevy_render/src/mesh/mesh.rs
+++ b/crates/bevy_render/src/mesh/mesh.rs
@@ -14,14 +14,9 @@ use bevy_ecs::{
     world::Mut,
 };
 use bevy_math::*;
-<<<<<<< HEAD
-use bevy_reflect::{Reflect, TypeUuid};
-use std::borrow::Cow;
-=======
-use bevy_reflect::TypeUuid;
+use bevy_reflect::{TypeUuid, Reflect};
 use bevy_utils::EnumVariantMeta;
 use std::{borrow::Cow, collections::BTreeMap};
->>>>>>> curves-and-lerp
 
 use crate::pipeline::{InputStepMode, VertexAttribute, VertexBufferLayout};
 use bevy_utils::{HashMap, HashSet};
@@ -32,22 +27,6 @@ pub const VERTEX_ATTRIBUTE_BUFFER_ID: u64 = 10;
 /// An array where each entry describes a property of a single vertex.
 #[derive(Clone, Debug, EnumVariantMeta)]
 pub enum VertexAttributeValues {
-<<<<<<< HEAD
-    Float(Vec<f32>),
-    Int(Vec<i32>),
-    Uint(Vec<u32>),
-    Float2(Vec<[f32; 2]>),
-    Int2(Vec<[i32; 2]>),
-    Uint2(Vec<[u32; 2]>),
-    Float3(Vec<[f32; 3]>),
-    Int3(Vec<[i32; 3]>),
-    Uint3(Vec<[u32; 3]>),
-    Float4(Vec<[f32; 4]>),
-    Int4(Vec<[i32; 4]>),
-    Uint4(Vec<[u32; 4]>),
-    Uchar4Norm(Vec<[u8; 4]>),
-    Ushort4(Vec<[u16; 4]>),
-=======
     Float32(Vec<f32>),
     Sint32(Vec<i32>),
     Uint32(Vec<u32>),
@@ -76,7 +55,6 @@ pub enum VertexAttributeValues {
     Snorm8x4(Vec<[i8; 4]>),
     Uint8x4(Vec<[u8; 4]>),
     Unorm8x4(Vec<[u8; 4]>),
->>>>>>> curves-and-lerp
 }
 
 impl VertexAttributeValues {
@@ -84,22 +62,6 @@ impl VertexAttributeValues {
     /// mesh, all of the VertexAttributeValues must have the same length.
     pub fn len(&self) -> usize {
         match *self {
-<<<<<<< HEAD
-            VertexAttributeValues::Float(ref values) => values.len(),
-            VertexAttributeValues::Int(ref values) => values.len(),
-            VertexAttributeValues::Uint(ref values) => values.len(),
-            VertexAttributeValues::Float2(ref values) => values.len(),
-            VertexAttributeValues::Int2(ref values) => values.len(),
-            VertexAttributeValues::Uint2(ref values) => values.len(),
-            VertexAttributeValues::Float3(ref values) => values.len(),
-            VertexAttributeValues::Int3(ref values) => values.len(),
-            VertexAttributeValues::Uint3(ref values) => values.len(),
-            VertexAttributeValues::Float4(ref values) => values.len(),
-            VertexAttributeValues::Int4(ref values) => values.len(),
-            VertexAttributeValues::Uint4(ref values) => values.len(),
-            VertexAttributeValues::Uchar4Norm(ref values) => values.len(),
-            VertexAttributeValues::Ushort4(ref values) => values.len(),
-=======
             VertexAttributeValues::Float32(ref values) => values.len(),
             VertexAttributeValues::Sint32(ref values) => values.len(),
             VertexAttributeValues::Uint32(ref values) => values.len(),
@@ -128,7 +90,6 @@ impl VertexAttributeValues {
             VertexAttributeValues::Snorm8x4(ref values) => values.len(),
             VertexAttributeValues::Uint8x4(ref values) => values.len(),
             VertexAttributeValues::Unorm8x4(ref values) => values.len(),
->>>>>>> curves-and-lerp
         }
     }
 
@@ -149,22 +110,6 @@ impl VertexAttributeValues {
     /// useful for serialization and sending to the GPU.
     pub fn get_bytes(&self) -> &[u8] {
         match self {
-<<<<<<< HEAD
-            VertexAttributeValues::Float(values) => values.as_slice().as_bytes(),
-            VertexAttributeValues::Int(values) => values.as_slice().as_bytes(),
-            VertexAttributeValues::Uint(values) => values.as_slice().as_bytes(),
-            VertexAttributeValues::Float2(values) => values.as_slice().as_bytes(),
-            VertexAttributeValues::Int2(values) => values.as_slice().as_bytes(),
-            VertexAttributeValues::Uint2(values) => values.as_slice().as_bytes(),
-            VertexAttributeValues::Float3(values) => values.as_slice().as_bytes(),
-            VertexAttributeValues::Int3(values) => values.as_slice().as_bytes(),
-            VertexAttributeValues::Uint3(values) => values.as_slice().as_bytes(),
-            VertexAttributeValues::Float4(values) => values.as_slice().as_bytes(),
-            VertexAttributeValues::Int4(values) => values.as_slice().as_bytes(),
-            VertexAttributeValues::Uint4(values) => values.as_slice().as_bytes(),
-            VertexAttributeValues::Uchar4Norm(values) => values.as_slice().as_bytes(),
-            VertexAttributeValues::Ushort4(values) => values.as_slice().as_bytes(),
-=======
             VertexAttributeValues::Float32(values) => values.as_slice().as_bytes(),
             VertexAttributeValues::Sint32(values) => values.as_slice().as_bytes(),
             VertexAttributeValues::Uint32(values) => values.as_slice().as_bytes(),
@@ -193,7 +138,6 @@ impl VertexAttributeValues {
             VertexAttributeValues::Snorm8x4(values) => values.as_slice().as_bytes(),
             VertexAttributeValues::Uint8x4(values) => values.as_slice().as_bytes(),
             VertexAttributeValues::Unorm8x4(values) => values.as_slice().as_bytes(),
->>>>>>> curves-and-lerp
         }
     }
 }
@@ -201,22 +145,6 @@ impl VertexAttributeValues {
 impl From<&VertexAttributeValues> for VertexFormat {
     fn from(values: &VertexAttributeValues) -> Self {
         match values {
-<<<<<<< HEAD
-            VertexAttributeValues::Float(_) => VertexFormat::Float,
-            VertexAttributeValues::Int(_) => VertexFormat::Int,
-            VertexAttributeValues::Uint(_) => VertexFormat::Uint,
-            VertexAttributeValues::Float2(_) => VertexFormat::Float2,
-            VertexAttributeValues::Int2(_) => VertexFormat::Int2,
-            VertexAttributeValues::Uint2(_) => VertexFormat::Uint2,
-            VertexAttributeValues::Float3(_) => VertexFormat::Float3,
-            VertexAttributeValues::Int3(_) => VertexFormat::Int3,
-            VertexAttributeValues::Uint3(_) => VertexFormat::Uint3,
-            VertexAttributeValues::Float4(_) => VertexFormat::Float4,
-            VertexAttributeValues::Int4(_) => VertexFormat::Int4,
-            VertexAttributeValues::Uint4(_) => VertexFormat::Uint4,
-            VertexAttributeValues::Uchar4Norm(_) => VertexFormat::Uchar4Norm,
-            VertexAttributeValues::Ushort4(_) => VertexFormat::Ushort4,
-=======
             VertexAttributeValues::Float32(_) => VertexFormat::Float32,
             VertexAttributeValues::Sint32(_) => VertexFormat::Sint32,
             VertexAttributeValues::Uint32(_) => VertexFormat::Uint32,
@@ -245,7 +173,6 @@ impl From<&VertexAttributeValues> for VertexFormat {
             VertexAttributeValues::Snorm8x4(_) => VertexFormat::Snorm8x4,
             VertexAttributeValues::Uint8x4(_) => VertexFormat::Uint8x4,
             VertexAttributeValues::Unorm8x4(_) => VertexFormat::Unorm8x4,
->>>>>>> curves-and-lerp
         }
     }
 }
@@ -297,19 +224,13 @@ impl From<&Indices> for IndexFormat {
 pub struct Mesh {
     #[reflect(ignore)]
     primitive_topology: PrimitiveTopology,
-<<<<<<< HEAD
-    /// `bevy_utils::HashMap` with all defined vertex attributes (Positions, Normals, ...) for this
-    /// mesh. Attribute name maps to attribute values.
-    #[reflect(ignore)]
-    attributes: HashMap<Cow<'static, str>, VertexAttributeValues>,
-    #[reflect(ignore)]
-=======
     /// `std::collections::BTreeMap` with all defined vertex attributes (Positions, Normals, ...)
     /// for this mesh. Attribute name maps to attribute values.
     /// Uses a BTreeMap because, unlike HashMap, it has a defined iteration order,
     /// which allows easy stable VertexBuffers (i.e. same buffer order)
+    #[reflect(ignore)]
     attributes: BTreeMap<Cow<'static, str>, VertexAttributeValues>,
->>>>>>> curves-and-lerp
+    #[reflect(ignore)]
     indices: Option<Indices>,
 }
 
diff --git a/examples/animations/mesh_swap_animation.rs b/examples/animations/mesh_swap_animation.rs
index 1ec5fa4411021..28de7aca61455 100644
--- a/examples/animations/mesh_swap_animation.rs
+++ b/examples/animations/mesh_swap_animation.rs
@@ -30,7 +30,7 @@ fn setup(
         CurveVariableLinear::new(
             vec![0.0, 0.5, 1.0],
             vec![cube.clone(), sphere, cube.clone()],
-        ),
+        ).unwrap(),
     );
     let clip_handle = clips.add(clip);
 
@@ -47,7 +47,7 @@ fn setup(
         })
         .insert(animator);
 
-    commands.spawn_bundle(LightBundle {
+    commands.spawn_bundle(PointLightBundle {
         transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
         ..Default::default()
     });
diff --git a/examples/animations/run_animation.rs b/examples/animations/run_animation.rs
index f6eda6a9338a5..002306b327317 100644
--- a/examples/animations/run_animation.rs
+++ b/examples/animations/run_animation.rs
@@ -30,7 +30,7 @@ fn setup(
     });
 
     // light
-    commands.spawn_bundle(LightBundle {
+    commands.spawn_bundle(PointLightBundle {
         transform: Transform::from_translation(Vec3::new(4.0, 8.0, 4.0)),
         ..Default::default()
     });

From c4ee420fcb2d923ef758632918c79edafa78b8ec Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Mon, 10 May 2021 00:30:46 -0300
Subject: [PATCH 148/153] fix format

---
 crates/bevy_gltf/src/loader.rs              | 24 ++++++++++++++-------
 crates/bevy_internal/src/default_plugins.rs |  4 ++--
 crates/bevy_render/src/mesh/mesh.rs         |  2 +-
 examples/animations/mesh_swap_animation.rs  |  3 ++-
 4 files changed, 21 insertions(+), 12 deletions(-)

diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 1e98aced7f9df..a970a647447c5 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -156,7 +156,9 @@ async fn load_gltf<'a, 'b>(
                 } else {
                     let len = mesh.count_vertices();
                     let uvs = vec![[0.0, 0.0]; len];
-                    bevy_log::debug!("missing `TEXCOORD_0` vertex attribute, loading zeroed out UVs");
+                    bevy_log::debug!(
+                        "missing `TEXCOORD_0` vertex attribute, loading zeroed out UVs"
+                    );
                     mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, uvs);
                 }
 
@@ -191,7 +193,7 @@ async fn load_gltf<'a, 'b>(
                 {
                     mesh.set_attribute(Mesh::ATTRIBUTE_JOINT_INDEX, joint_attribute);
                 }
-                
+
                 if mesh.attribute(Mesh::ATTRIBUTE_NORMAL).is_none() {
                     let vertex_count_before = mesh.count_vertices();
                     mesh.duplicate_vertices();
@@ -363,23 +365,29 @@ async fn load_gltf<'a, 'b>(
                 ReadOutputs::Translations(values) => {
                     let values = values.map(Vec3::from).collect::<Vec<_>>();
                     property_path += "@Transform.translation";
-                    clip_curves_translation_and_scale
-                        .push((property_path, CurveVariableLinear::new(time_stamps, values).unwrap()));
+                    clip_curves_translation_and_scale.push((
+                        property_path,
+                        CurveVariableLinear::new(time_stamps, values).unwrap(),
+                    ));
 
                     // TODO: This is a runtime importer so here's no place for further optimizations
                 }
                 ReadOutputs::Rotations(values) => {
                     let values = values.into_f32().map(Quat::from).collect::<Vec<_>>();
                     property_path += "@Transform.rotation";
-                    clip_curves_rotation
-                        .push((property_path, CurveVariableLinear::new(time_stamps, values).unwrap()));
+                    clip_curves_rotation.push((
+                        property_path,
+                        CurveVariableLinear::new(time_stamps, values).unwrap(),
+                    ));
                 }
                 ReadOutputs::Scales(values) => {
                     let values = values.map(Vec3::from).collect::<Vec<_>>();
 
                     property_path += "@Transform.scale";
-                    clip_curves_translation_and_scale
-                        .push((property_path, CurveVariableLinear::new(time_stamps, values).unwrap()));
+                    clip_curves_translation_and_scale.push((
+                        property_path,
+                        CurveVariableLinear::new(time_stamps, values).unwrap(),
+                    ));
                 }
                 ReadOutputs::MorphTargetWeights(_) => {
                     unimplemented!("morph targets aren't current supported")
diff --git a/crates/bevy_internal/src/default_plugins.rs b/crates/bevy_internal/src/default_plugins.rs
index 35cdca8915f51..cbf67e96723cb 100644
--- a/crates/bevy_internal/src/default_plugins.rs
+++ b/crates/bevy_internal/src/default_plugins.rs
@@ -1,5 +1,7 @@
 use bevy_app::{PluginGroup, PluginGroupBuilder};
 
+#[cfg(feature = "bevy_animation")]
+use bevy_animation::AnimationPlugin;
 use bevy_app::ScheduleRunnerPlugin;
 use bevy_asset::AssetPlugin;
 #[cfg(feature = "bevy_audio")]
@@ -8,8 +10,6 @@ use bevy_core::CorePlugin;
 use bevy_diagnostic::DiagnosticsPlugin;
 #[cfg(feature = "bevy_gilrs")]
 use bevy_gilrs::GilrsPlugin;
-#[cfg(feature = "bevy_animation")]
-use bevy_animation::AnimationPlugin;
 #[cfg(all(feature = "bevy_gltf", feature = "bevy_animation"))]
 use bevy_gltf::GltfPlugin;
 use bevy_input::InputPlugin;
diff --git a/crates/bevy_render/src/mesh/mesh.rs b/crates/bevy_render/src/mesh/mesh.rs
index 976f4951a1c7e..55257c5023a6d 100644
--- a/crates/bevy_render/src/mesh/mesh.rs
+++ b/crates/bevy_render/src/mesh/mesh.rs
@@ -14,7 +14,7 @@ use bevy_ecs::{
     world::Mut,
 };
 use bevy_math::*;
-use bevy_reflect::{TypeUuid, Reflect};
+use bevy_reflect::{Reflect, TypeUuid};
 use bevy_utils::EnumVariantMeta;
 use std::{borrow::Cow, collections::BTreeMap};
 
diff --git a/examples/animations/mesh_swap_animation.rs b/examples/animations/mesh_swap_animation.rs
index 28de7aca61455..f6101a525969c 100644
--- a/examples/animations/mesh_swap_animation.rs
+++ b/examples/animations/mesh_swap_animation.rs
@@ -30,7 +30,8 @@ fn setup(
         CurveVariableLinear::new(
             vec![0.0, 0.5, 1.0],
             vec![cube.clone(), sphere, cube.clone()],
-        ).unwrap(),
+        )
+        .unwrap(),
     );
     let clip_handle = clips.add(clip);
 

From 5646db6a8589110547c26e00c9c7bcf94df2e6ff Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Tue, 11 May 2021 01:46:14 -0300
Subject: [PATCH 149/153] fix clippy errors

---
 crates/bevy_animation/src/animator.rs     |  2 +-
 crates/bevy_animation/src/skinned_mesh.rs | 16 +++++++---------
 2 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_animation/src/animator.rs b/crates/bevy_animation/src/animator.rs
index c69b7734fe986..773b6b405921f 100644
--- a/crates/bevy_animation/src/animator.rs
+++ b/crates/bevy_animation/src/animator.rs
@@ -491,8 +491,8 @@ impl Animator {
         let clip = self.add_clip(clip);
         let layer_index = self.layers.len();
         self.layers.push(Layer {
-            clip,
             weight,
+            clip,
             ..Default::default()
         });
         layer_index
diff --git a/crates/bevy_animation/src/skinned_mesh.rs b/crates/bevy_animation/src/skinned_mesh.rs
index 2bdeebf7884f9..24c3520ecca05 100644
--- a/crates/bevy_animation/src/skinned_mesh.rs
+++ b/crates/bevy_animation/src/skinned_mesh.rs
@@ -284,15 +284,13 @@ pub(crate) fn skinning_debugger_update(
             if !debugger.started {
                 let bone_mesh = meshes.add(Mesh::from(shape::Cube { size: 0.05 }));
                 // TODO: Keep track of all these entities, their position will only be updated if the parent GlobalTransform changes ...
-                for bone in skinner.joint_entities.iter() {
-                    if let Some(entity) = bone {
-                        commands
-                            .spawn_bundle(PbrBundle {
-                                mesh: bone_mesh.clone(),
-                                ..Default::default()
-                            })
-                            .insert(Parent(*entity));
-                    }
+                for entity in skinner.joint_entities.iter().flatten() {
+                    commands
+                        .spawn_bundle(PbrBundle {
+                            mesh: bone_mesh.clone(),
+                            ..Default::default()
+                        })
+                        .insert(Parent(*entity));
                 }
 
                 debugger.started = true;

From 475c514036b089cfa925e30f074d07c25708c2ca Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Tue, 18 May 2021 19:20:48 -0300
Subject: [PATCH 150/153] fixed handle Relfect impl

---
 crates/bevy_asset/src/handle.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_asset/src/handle.rs b/crates/bevy_asset/src/handle.rs
index 8acbce82e18da..197cfddfb5c5f 100644
--- a/crates/bevy_asset/src/handle.rs
+++ b/crates/bevy_asset/src/handle.rs
@@ -60,7 +60,7 @@ impl HandleId {
 /// Handles contain a unique id that corresponds to a specific asset in the [Assets](crate::Assets)
 /// collection.
 #[derive(Reflect)]
-#[reflect(Component)]
+#[reflect_value(Component)]
 pub struct Handle<T>
 where
     T: Asset,

From 91ed51daeba8bae18ddd9dc13697ced44b0d14c0 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Thu, 20 May 2021 02:42:03 -0300
Subject: [PATCH 151/153] bump glam version, fix Quat conversions

---
 crates/bevy_gltf/src/loader.rs                    | 4 ++--
 crates/bevy_math/Cargo.toml                       | 2 +-
 crates/bevy_math/src/interpolation/interpolate.rs | 4 ++--
 crates/bevy_math/src/interpolation/lerp.rs        | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index ac1e79523dd4a..a09c6bd26d404 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -373,7 +373,7 @@ async fn load_gltf<'a, 'b>(
                     // TODO: This is a runtime importer so here's no place for further optimizations
                 }
                 ReadOutputs::Rotations(values) => {
-                    let values = values.into_f32().map(Quat::from).collect::<Vec<_>>();
+                    let values = values.into_f32().map(Quat::from_array).collect::<Vec<_>>();
                     property_path += "@Transform.rotation";
                     clip_curves_rotation.push((
                         property_path,
@@ -630,7 +630,7 @@ fn load_node(
     let mut active = parent.spawn_bundle((
         Transform {
             translation: translation.into(),
-            rotation: rotation.into(),
+            rotation: Quat::from_array(rotation),
             scale: scale.into(),
         },
         GlobalTransform::default(),
diff --git a/crates/bevy_math/Cargo.toml b/crates/bevy_math/Cargo.toml
index 4175c5adb5a44..3ae369a906c36 100644
--- a/crates/bevy_math/Cargo.toml
+++ b/crates/bevy_math/Cargo.toml
@@ -13,6 +13,6 @@ license = "MIT"
 keywords = ["bevy"]
 
 [dependencies]
-glam = { version = "0.15.1", features = ["serde", "bytemuck"] }
+glam = { version = "0.15.2", features = ["serde", "bytemuck"] }
 bevy_reflect = { path = "../bevy_reflect", version = "0.5.0", features = ["bevy"] }
 thiserror = "1.0"
\ No newline at end of file
diff --git a/crates/bevy_math/src/interpolation/interpolate.rs b/crates/bevy_math/src/interpolation/interpolate.rs
index 238af78ab9d1f..1670b04d6ef9b 100644
--- a/crates/bevy_math/src/interpolation/interpolate.rs
+++ b/crates/bevy_math/src/interpolation/interpolate.rs
@@ -160,7 +160,7 @@ impl Interpolate for Quat {
 
                 let q = utils::lerp_unclamped::<Vec4>((*k0).into(), k1.into(), t);
                 let d = utils::inv_sqrt(q.dot(q));
-                (q * d).into()
+                Quat::from_vec4(q * d)
             }
             Interpolation::Hermite => {
                 // Make sure is always the short path, look at this: https://github.com/mgeier/quaternion-nursery
@@ -178,7 +178,7 @@ impl Interpolate for Quat {
                     dt,
                 );
                 let d = utils::inv_sqrt(q.dot(q));
-                (q * d).into()
+                Quat::from_vec4(q * d)
             }
         }
     }
diff --git a/crates/bevy_math/src/interpolation/lerp.rs b/crates/bevy_math/src/interpolation/lerp.rs
index 7ef661db093d1..3c2c5c737cf67 100644
--- a/crates/bevy_math/src/interpolation/lerp.rs
+++ b/crates/bevy_math/src/interpolation/lerp.rs
@@ -85,7 +85,7 @@ impl Lerp for Quat {
 
         let rot = Vec4::lerp_unclamped(&a, &b, t);
         let inv_mag = inv_sqrt(rot.dot(rot));
-        (rot * inv_mag).into()
+        Quat::from_vec4(rot * inv_mag)
     }
 }
 

From 0484f9dd66005546109463f71db33ba0aeb73013 Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Tue, 1 Jun 2021 01:47:03 -0300
Subject: [PATCH 152/153] fix license

---
 crates/bevy_animation/Cargo.toml | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index 118683e7fd802..2d6383012c42c 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -1,8 +1,13 @@
 [package]
 name = "bevy_animation"
 version = "0.5.0"
-authors = ["Felipe Jorge <felipe.jorge.pereira@gmail.com>"]
 edition = "2018"
+authors = ["Felipe Jorge <felipe.jorge.pereira@gmail.com>"]
+description = "Bevy Engine Property Animation System"
+homepage = "https://bevyengine.org"
+repository = "https://github.com/bevyengine/bevy"
+license = "MIT"
+keywords = ["bevy", "animation"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

From 0a67f62759a99fada81db14ce8f800eab09f491c Mon Sep 17 00:00:00 2001
From: Felipe Jorge <felipe.jorge.pereira@gmail.com>
Date: Tue, 1 Jun 2021 01:47:15 -0300
Subject: [PATCH 153/153] load clip name

---
 crates/bevy_gltf/src/loader.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index a09c6bd26d404..ea8898893c230 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -325,6 +325,10 @@ async fn load_gltf<'a, 'b>(
         }
 
         let mut clip = Clip::default();
+        clip.name = animation
+            .name()
+            .unwrap_or_else(|| anim_label.as_str())
+            .to_string();
 
         let mut start_time = f32::MAX;