Scale sprite z level by their scale

crates/bevy_sprite/src/render/mod.rs

@@ -11,7 +11,7 @@ use bevy_ecs::{
     prelude::*,
     system::{lifetimeless::*, SystemParamItem},
 };
-use bevy_math::{const_vec2, Vec2};
+use bevy_math::{const_vec2, Quat, Vec2};
 use bevy_reflect::Uuid;
 use bevy_render::{
     color::Color,
@@ -171,9 +171,14 @@ impl SpecializedPipeline for SpritePipeline {
     }
 }
 
+/// Extracted informations about a [`Sprite`] used to render it.
 #[derive(Component, Clone, Copy)]
 pub struct ExtractedSprite {
-    pub transform: GlobalTransform,
+    /// 2d extracted transform from the sprite [`GlobalTransform`]
+    pub transform: Extracted2dTransform,
+    /// Z layer at which the sprite should be shown
+    pub z_layer: f32,
+    /// Color of the sprite
     pub color: Color,
     /// Select an area of the texture
     pub rect: Option<Rect>,
@@ -182,10 +187,30 @@ pub struct ExtractedSprite {
     /// Handle to the `Image` of this sprite
     /// PERF: storing a `HandleId` instead of `Handle<Image>` enables some optimizations (`ExtractedSprite` becomes `Copy` and doesn't need to be dropped)
     pub image_handle_id: HandleId,
+    /// Is it flipped along the X axis
     pub flip_x: bool,
+    /// Is it flipped along the Y axis
     pub flip_y: bool,
 }
 
+/// A 2d representation of a [`GlobalTransform`] for an [`ExtractedSprite`]
+#[derive(Clone, Copy)]
+pub struct Extracted2dTransform {
+    /// The 2d position
+    pub translation: Vec2,
+    /// The 2d scale
+    pub scale: Vec2,
+    /// The rotation
+    pub rotation: Quat,
+}
+
+impl Extracted2dTransform {
+    #[inline]
+    fn mul_vec2(&self, value: Vec2) -> Vec2 {
+        (self.rotation * (self.scale * value).extend(0.0)).truncate() + self.translation
+    }
+}
+
 #[derive(Default)]
 pub struct ExtractedSprites {
     pub sprites: Vec<ExtractedSprite>,
@@ -240,7 +265,12 @@ pub fn extract_sprites(
         // PERF: we don't check in this function that the `Image` asset is ready, since it should be in most cases and hashing the handle is expensive
         extracted_sprites.sprites.alloc().init(ExtractedSprite {
             color: sprite.color,
-            transform: *transform,
+            transform: Extracted2dTransform {
+                translation: transform.translation.truncate(),
+                scale: transform.scale.truncate(),
+                rotation: transform.rotation,
+            },
+            z_layer: transform.translation.z * transform.scale.z,
             // Use the full texture
             rect: None,
             // Pass the custom size
@@ -258,7 +288,12 @@ pub fn extract_sprites(
             let rect = Some(texture_atlas.textures[atlas_sprite.index as usize]);
             extracted_sprites.sprites.alloc().init(ExtractedSprite {
                 color: atlas_sprite.color,
-                transform: *transform,
+                transform: Extracted2dTransform {
+                    translation: transform.translation.truncate(),
+                    scale: transform.scale.truncate(),
+                    rotation: transform.rotation,
+                },
+                z_layer: transform.translation.z * transform.scale.z,
                 // Select the area in the texture atlas
                 rect,
                 // Pass the custom size
@@ -393,16 +428,9 @@ pub fn queue_sprites(
             transparent_phase.items.reserve(extracted_sprites.len());
 
             // Sort sprites by z for correct transparency and then by handle to improve batching
-            extracted_sprites.sort_unstable_by(|a, b| {
-                match a
-                    .transform
-                    .translation
-                    .z
-                    .partial_cmp(&b.transform.translation.z)
-                {
-                    Some(Ordering::Equal) | None => a.image_handle_id.cmp(&b.image_handle_id),
-                    Some(other) => other,
-                }
+            extracted_sprites.sort_unstable_by(|a, b| match a.z_layer.partial_cmp(&b.z_layer) {
+                Some(Ordering::Equal) | None => a.image_handle_id.cmp(&b.image_handle_id),
+                Some(other) => other,
             });
 
             // Impossible starting values that will be replaced on the first iteration
@@ -489,12 +517,13 @@ pub fn queue_sprites(
                 let positions = QUAD_VERTEX_POSITIONS.map(|quad_pos| {
                     extracted_sprite
                         .transform
-                        .mul_vec3((quad_pos * quad_size).extend(0.))
+                        .mul_vec2(quad_pos * quad_size)
+                        .extend(extracted_sprite.z_layer)
                         .into()
                 });
 
                 // These items will be sorted by depth with other phase items
-                let sort_key = FloatOrd(extracted_sprite.transform.translation.z);
+                let sort_key = FloatOrd(extracted_sprite.z_layer);
 
                 // Store the vertex data and add the item to the render phase
                 if current_batch.colored {

crates/bevy_text/src/text2d.rs

@@ -7,7 +7,7 @@ use bevy_ecs::{
 };
 use bevy_math::{Size, Vec3};
 use bevy_render::{texture::Image, view::Visibility, RenderWorld};
-use bevy_sprite::{ExtractedSprite, ExtractedSprites, TextureAtlas};
+use bevy_sprite::{Extracted2dTransform, ExtractedSprite, ExtractedSprites, TextureAtlas};
 use bevy_transform::prelude::{GlobalTransform, Transform};
 use bevy_window::{WindowId, Windows};
 
@@ -92,7 +92,12 @@ pub fn extract_text2d_sprite(
                 let transform = text_transform.mul_transform(glyph_transform);
 
                 extracted_sprites.sprites.push(ExtractedSprite {
-                    transform,
+                    transform: Extracted2dTransform {
+                        translation: transform.translation.truncate(),
+                        scale: transform.scale.truncate(),
+                        rotation: transform.rotation,
+                    },
+                    z_layer: transform.translation.z * transform.scale.z,
                     color,
                     rect,
                     custom_size: None,

crates/bevy_transform/src/components/global_transform.rs

@@ -212,11 +212,8 @@ impl GlobalTransform {
 
     /// Returns a [`Vec3`] of this [`Transform`] applied to `value`.
     #[inline]
-    pub fn mul_vec3(&self, mut value: Vec3) -> Vec3 {
-        value = self.scale * value;
-        value = self.rotation * value;
-        value += self.translation;
-        value
+    pub fn mul_vec3(&self, value: Vec3) -> Vec3 {
+        self.rotation * (self.scale * value) + self.translation
     }
 
     #[doc(hidden)]

crates/bevy_transform/src/components/transform.rs

@@ -222,11 +222,8 @@ impl Transform {
 
     /// Returns a [`Vec3`] of this [`Transform`] applied to `value`.
     #[inline]
-    pub fn mul_vec3(&self, mut value: Vec3) -> Vec3 {
-        value = self.scale * value;
-        value = self.rotation * value;
-        value += self.translation;
-        value
+    pub fn mul_vec3(&self, value: Vec3) -> Vec3 {
+        self.rotation * (self.scale * value) + self.translation
     }
 
     /// Changes the `scale` of this [`Transform`], multiplying the current `scale` by