#543 Fix instanced transformation order (#545)

* save animation transformation in Mesh instead of current transformation

* Fix order of transformations for InstancedMesh

Author: asny

src/renderer/geometry/instanced_mesh.rs

@@ -21,7 +21,7 @@ pub struct InstancedMesh {
     last_camera_position: RwLock<Option<Vec3>>,
     aabb: AxisAlignedBoundingBox, // The AABB for the base mesh without transformations applied
     transformation: Mat4,
-    current_transformation: Mat4,
+    animation_transformation: Mat4,
     animation: Option<Box<dyn Fn(f32) -> Mat4 + Send + Sync>>,
     instances: Instances,
 }
@@ -51,7 +51,7 @@ impl InstancedMesh {
             indices: RwLock::new((0..instances.transformations.len()).collect::<Vec<usize>>()),
             aabb,
             transformation: Mat4::identity(),
-            current_transformation: Mat4::identity(),
+            animation_transformation: Mat4::identity(),
             animation: None,
             instances: instances.clone(),
         };
@@ -68,21 +68,21 @@ impl InstancedMesh {
 
     ///
     /// Set the local to world transformation applied to all instances.
-    /// This is applied before the transform for each instance.
+    /// This transformation is applied last, ie. after the instance transformation defined in [Self::set_instances] and the animation transformation defined by [Self::set_animation].
     ///
     pub fn set_transformation(&mut self, transformation: Mat4) {
         self.transformation = transformation;
-        self.current_transformation = transformation;
         *self.last_camera_position.write().unwrap() = None;
     }
 
     ///
     /// Specifies a function which takes a time parameter as input and returns a transformation that should be applied to this mesh at the given time.
     /// To actually animate this instanced mesh, call [Geometry::animate] at each frame which in turn evaluates the animation function defined by this method.
-    /// This transformation is applied first, then the local to world transformation defined by [Self::set_transformation].
+    /// This transformation is applied first, then the instance transformation defined in [Self::set_instances], then the local to world transformation defined by [Self::set_transformation].
     ///
     pub fn set_animation(&mut self, animation: impl Fn(f32) -> Mat4 + Send + Sync + 'static) {
         self.animation = Some(Box::new(animation));
+        self.animate(0.0);
     }
 
     /// Returns the number of instances that is rendered.
@@ -185,7 +185,7 @@ impl Geometry for InstancedMesh {
                 .transformations
                 .iter()
                 .map(|m| {
-                    (m * self.current_transformation)
+                    (self.transformation * m * self.animation_transformation)
                         .w
                         .truncate()
                         .distance2(viewer.position())
@@ -200,7 +200,8 @@ impl Geometry for InstancedMesh {
         }
 
         program.use_uniform("viewProjection", viewer.projection() * viewer.view());
-        program.use_uniform("modelMatrix", self.current_transformation);
+        program.use_uniform("animationTransform", self.animation_transformation);
+        program.use_uniform("modelMatrix", self.transformation);
 
         let (row1, row2, row3) = &*self.transform.read().unwrap();
         program.use_instance_attribute("row1", row1);
@@ -254,16 +255,17 @@ impl Geometry for InstancedMesh {
 
     fn aabb(&self) -> AxisAlignedBoundingBox {
         let mut aabb = AxisAlignedBoundingBox::EMPTY;
-        let local_aabb = self.aabb.transformed(self.current_transformation);
-        for transformation in &self.instances.transformations {
-            aabb.expand_with_aabb(local_aabb.transformed(*transformation));
+        for instance_transformation in &self.instances.transformations {
+            aabb.expand_with_aabb(self.aabb.transformed(
+                self.transformation * instance_transformation * self.animation_transformation,
+            ));
         }
         aabb
     }
 
     fn animate(&mut self, time: f32) {
         if let Some(animation) = &self.animation {
-            self.current_transformation = self.transformation * animation(time);
+            self.animation_transformation = animation(time);
             *self.last_camera_position.write().unwrap() = None;
         }
     }
@@ -307,6 +309,7 @@ impl Geometry for InstancedMesh {
 #[derive(Clone, Debug, Default)]
 pub struct Instances {
     /// The transformations applied to each instance.
+    /// This transformation is applied in between the animation transformation defined by [InstancedMesh::set_animation] and the transformation defined in [InstancedMesh::set_transformation].
     pub transformations: Vec<Mat4>,
     /// The texture transform applied to the uv coordinates of each instance.
     pub texture_transformations: Option<Vec<Mat3>>,

src/renderer/geometry/mesh.rs

@@ -11,7 +11,7 @@ pub struct Mesh {
     context: Context,
     aabb: AxisAlignedBoundingBox,
     transformation: Mat4,
-    current_transformation: Mat4,
+    animation_transformation: Mat4,
     animation: Option<Box<dyn Fn(f32) -> Mat4 + Send + Sync>>,
 }
 
@@ -27,7 +27,7 @@ impl Mesh {
             base_mesh: BaseMesh::new(context, cpu_mesh),
             aabb,
             transformation: Mat4::identity(),
-            current_transformation: Mat4::identity(),
+            animation_transformation: Mat4::identity(),
             animation: None,
         }
     }
@@ -66,7 +66,6 @@ impl Mesh {
     ///
     pub fn set_transformation(&mut self, transformation: Mat4) {
         self.transformation = transformation;
-        self.current_transformation = transformation;
     }
 
     ///
@@ -76,6 +75,7 @@ impl Mesh {
     ///
     pub fn set_animation(&mut self, animation: impl Fn(f32) -> Mat4 + Send + Sync + 'static) {
         self.animation = Some(Box::new(animation));
+        self.animate(0.0);
     }
 
     ///
@@ -145,25 +145,27 @@ impl<'a> IntoIterator for &'a Mesh {
 
 impl Geometry for Mesh {
     fn aabb(&self) -> AxisAlignedBoundingBox {
-        self.aabb.transformed(self.current_transformation)
+        self.aabb
+            .transformed(self.transformation * self.animation_transformation)
     }
 
     fn animate(&mut self, time: f32) {
         if let Some(animation) = &self.animation {
-            self.current_transformation = self.transformation * animation(time);
+            self.animation_transformation = animation(time);
         }
     }
 
     fn draw(&self, viewer: &dyn Viewer, program: &Program, render_states: RenderStates) {
-        if let Some(inverse) = self.current_transformation.invert() {
+        let local2world = self.transformation * self.animation_transformation;
+        if let Some(inverse) = local2world.invert() {
             program.use_uniform_if_required("normalMatrix", inverse.transpose());
         } else {
             // determinant is float zero
             return;
         }
 
         program.use_uniform("viewProjection", viewer.projection() * viewer.view());
-        program.use_uniform("modelMatrix", self.current_transformation);
+        program.use_uniform("modelMatrix", local2world);
 
         self.base_mesh.draw(program, render_states, viewer);
     }

src/renderer/geometry/shaders/mesh.vert

@@ -11,6 +11,7 @@ uniform float time;
 #endif
 
 #ifdef USE_INSTANCE_TRANSFORMS
+uniform mat4 animationTransform;
 in vec4 row1;
 in vec4 row2;
 in vec4 row3;
@@ -62,17 +63,18 @@ void main()
     transform[1] = vec4(row1.y, row2.y, row3.y, 0.0);
     transform[2] = vec4(row1.z, row2.z, row3.z, 0.0);
     transform[3] = vec4(row1.w, row2.w, row3.w, 1.0);
-    local2World = transform * local2World;
+    local2World = local2World * transform * animationTransform;
 #endif
 
-    vec4 worldPosition = local2World * vec4(position, 1.);
-    worldPosition /= worldPosition.w;
 #ifdef PARTICLES
-    worldPosition.xyz += start_position + start_velocity * time + 0.5 * acceleration * time * time;
+    mat4 animationTransform = mat4(1.0);
+    animationTransform[3].xyz = start_position + start_velocity * time + 0.5 * acceleration * time * time;
+    local2World = local2World * animationTransform;
 #endif
-    gl_Position = viewProjection * worldPosition;
 
-    pos = worldPosition.xyz;
+    vec4 worldPosition = local2World * vec4(position, 1.);
+    gl_Position = viewProjection * worldPosition;
+    pos = worldPosition.xyz / worldPosition.w;
 
     // *** NORMAL ***
 #ifdef USE_NORMALS