switch to UVec2 when working with texture dimensions

crates/bevy_pbr/src/render/mesh.rs

@@ -420,7 +420,7 @@ impl FromWorld for MeshPipeline {
                 texture_view,
                 texture_format: image.texture_descriptor.format,
                 sampler,
-                size: image.size_f32(),
+                size: image.size(),
                 mip_level_count: image.texture_descriptor.mip_level_count,
             }
         };

crates/bevy_render/src/texture/fallback_image.rs

@@ -122,7 +122,7 @@ fn fallback_image_new(
         texture_view,
         texture_format: image.texture_descriptor.format,
         sampler,
-        size: image.size_f32(),
+        size: image.size(),
         mip_level_count: image.texture_descriptor.mip_level_count,
     }
 }

crates/bevy_render/src/texture/image.rs

@@ -805,7 +805,7 @@ pub struct GpuImage {
     pub texture_view: TextureView,
     pub texture_format: TextureFormat,
     pub sampler: Sampler,
-    pub size: Vec2,
+    pub size: UVec2,
     pub mip_level_count: u32,
 }
 
@@ -834,16 +834,13 @@ impl RenderAsset for Image {
             &self.data,
         );
 
+        let size = self.size();
         let texture_view = texture.create_view(
             self.texture_view_descriptor
                 .or_else(|| Some(TextureViewDescriptor::default()))
                 .as_ref()
                 .unwrap(),
         );
-        let size = Vec2::new(
-            self.texture_descriptor.size.width as f32,
-            self.texture_descriptor.size.height as f32,
-        );
         let sampler = match self.sampler {
             ImageSampler::Default => (***default_sampler).clone(),
             ImageSampler::Descriptor(descriptor) => {
@@ -922,7 +919,6 @@ impl CompressedImageFormats {
 
 #[cfg(test)]
 mod test {
-
     use super::*;
     use crate::render_asset::RenderAssetUsages;
 
@@ -945,9 +941,11 @@ mod test {
             image.size_f32()
         );
     }
+
     #[test]
     fn image_default_size() {
         let image = Image::default();
+        assert_eq!(UVec2::ONE, image.size());
         assert_eq!(Vec2::ONE, image.size_f32());
     }
 }

crates/bevy_sprite/src/dynamic_texture_atlas_builder.rs

@@ -1,6 +1,6 @@
 use crate::TextureAtlasLayout;
 use bevy_asset::{Assets, Handle};
-use bevy_math::{IVec2, Rect, Vec2};
+use bevy_math::{IVec2, Rect, UVec2};
 use bevy_render::{
     render_asset::{RenderAsset, RenderAssetUsages},
     texture::{Image, TextureFormatPixelInfo},
@@ -23,7 +23,7 @@ impl DynamicTextureAtlasBuilder {
     ///
     /// * `size` - total size for the atlas
     /// * `padding` - gap added between textures in the atlas, both in x axis and y axis
-    pub fn new(size: Vec2, padding: i32) -> Self {
+    pub fn new(size: UVec2, padding: i32) -> Self {
         Self {
             atlas_allocator: AtlasAllocator::new(to_size2(size)),
             padding,
@@ -102,6 +102,6 @@ fn to_rect(rectangle: guillotiere::Rectangle) -> Rect {
     }
 }
 
-fn to_size2(vec2: Vec2) -> guillotiere::Size {
+fn to_size2(vec2: UVec2) -> guillotiere::Size {
     guillotiere::Size::new(vec2.x as i32, vec2.y as i32)
 }

crates/bevy_sprite/src/mesh2d/mesh.rs

@@ -304,7 +304,7 @@ impl FromWorld for Mesh2dPipeline {
                 texture_view,
                 texture_format: image.texture_descriptor.format,
                 sampler,
-                size: image.size_f32(),
+                size: image.size(),
                 mip_level_count: image.texture_descriptor.mip_level_count,
             }
         };

crates/bevy_sprite/src/render/mod.rs

@@ -101,7 +101,7 @@ impl FromWorld for SpritePipeline {
                 texture_view,
                 texture_format: image.texture_descriptor.format,
                 sampler,
-                size: image.size_f32(),
+                size: image.size(),
                 mip_level_count: image.texture_descriptor.mip_level_count,
             }
         };
@@ -617,7 +617,7 @@ pub fn prepare_sprites(
                         continue;
                     };
 
-                    batch_image_size = Vec2::new(gpu_image.size.x, gpu_image.size.y);
+                    batch_image_size = gpu_image.size.as_vec2();
                     batch_image_handle = extracted_sprite.image_handle_id;
                     image_bind_groups
                         .values

crates/bevy_sprite/src/texture_atlas.rs

@@ -1,6 +1,6 @@
 use bevy_asset::{Asset, AssetId, Assets, Handle};
 use bevy_ecs::component::Component;
-use bevy_math::{Rect, Vec2};
+use bevy_math::{Rect, UVec2};
 use bevy_reflect::Reflect;
 use bevy_render::texture::Image;
 use bevy_utils::HashMap;
@@ -19,7 +19,7 @@ use bevy_utils::HashMap;
 #[reflect(Debug)]
 pub struct TextureAtlasLayout {
     // TODO: add support to Uniforms derive to write dimensions and sprites to the same buffer
-    pub size: Vec2,
+    pub size: UVec2,
     /// The specific areas of the atlas where each texture can be found
     pub textures: Vec<Rect>,
     /// Maps from a specific image handle to the index in `textures` where they can be found.
@@ -51,7 +51,7 @@ pub struct TextureAtlas {
 
 impl TextureAtlasLayout {
     /// Create a new empty layout with custom `dimensions`
-    pub fn new_empty(dimensions: Vec2) -> Self {
+    pub fn new_empty(dimensions: UVec2) -> Self {
         Self {
             size: dimensions,
             texture_handles: None,
@@ -73,16 +73,16 @@ impl TextureAtlasLayout {
     /// * `padding` - Optional padding between cells
     /// * `offset` - Optional global grid offset
     pub fn from_grid(
-        tile_size: Vec2,
-        columns: usize,
-        rows: usize,
-        padding: Option<Vec2>,
-        offset: Option<Vec2>,
+        tile_size: UVec2,
+        columns: u32,
+        rows: u32,
+        padding: Option<UVec2>,
+        offset: Option<UVec2>,
     ) -> Self {
         let padding = padding.unwrap_or_default();
         let offset = offset.unwrap_or_default();
         let mut sprites = Vec::new();
-        let mut current_padding = Vec2::ZERO;
+        let mut current_padding = UVec2::ZERO;
 
         for y in 0..rows {
             if y > 0 {
@@ -93,18 +93,18 @@ impl TextureAtlasLayout {
                     current_padding.x = padding.x;
                 }
 
-                let cell = Vec2::new(x as f32, y as f32);
+                let cell = UVec2::new(x, y);
 
                 let rect_min = (tile_size + current_padding) * cell + offset;
 
                 sprites.push(Rect {
-                    min: rect_min,
-                    max: rect_min + tile_size,
+                    min: rect_min.as_vec2(),
+                    max: (rect_min + tile_size).as_vec2(),
                 });
             }
         }
 
-        let grid_size = Vec2::new(columns as f32, rows as f32);
+        let grid_size = UVec2::new(columns, rows);
 
         Self {
             size: ((tile_size + current_padding) * grid_size) - current_padding,

crates/bevy_sprite/src/texture_atlas_builder.rs

@@ -287,7 +287,7 @@ impl<'a> TextureAtlasBuilder<'a> {
 
         Ok((
             TextureAtlasLayout {
-                size: atlas_texture.size_f32(),
+                size: atlas_texture.size(),
                 textures: texture_rects,
                 texture_handles: Some(texture_ids),
             },

crates/bevy_text/src/font_atlas.rs

@@ -1,6 +1,6 @@
 use ab_glyph::{GlyphId, Point};
 use bevy_asset::{Assets, Handle};
-use bevy_math::Vec2;
+use bevy_math::UVec2;
 use bevy_render::{
     render_asset::RenderAssetUsages,
     render_resource::{Extent3d, TextureDimension, TextureFormat},
@@ -51,12 +51,12 @@ impl FontAtlas {
     pub fn new(
         textures: &mut Assets<Image>,
         texture_atlases: &mut Assets<TextureAtlasLayout>,
-        size: Vec2,
+        size: UVec2,
     ) -> FontAtlas {
         let texture = textures.add(Image::new_fill(
             Extent3d {
-                width: size.x as u32,
-                height: size.y as u32,
+                width: size.x,
+                height: size.y,
                 depth_or_array_layers: 1,
             },
             TextureDimension::D2,

crates/bevy_text/src/font_atlas_set.rs

@@ -3,7 +3,7 @@ use ab_glyph::{GlyphId, OutlinedGlyph, Point};
 use bevy_asset::{AssetEvent, AssetId};
 use bevy_asset::{Assets, Handle};
 use bevy_ecs::prelude::*;
-use bevy_math::Vec2;
+use bevy_math::UVec2;
 use bevy_reflect::Reflect;
 use bevy_render::texture::Image;
 use bevy_sprite::TextureAtlasLayout;
@@ -84,13 +84,7 @@ impl FontAtlasSet {
         let font_atlases = self
             .font_atlases
             .entry(FloatOrd(font_size))
-            .or_insert_with(|| {
-                vec![FontAtlas::new(
-                    textures,
-                    texture_atlases,
-                    Vec2::splat(512.0),
-                )]
-            });
+            .or_insert_with(|| vec![FontAtlas::new(textures, texture_atlases, UVec2::splat(512))]);
 
         let glyph_texture = Font::get_outlined_glyph_texture(outlined_glyph);
         let add_char_to_font_atlas = |atlas: &mut FontAtlas| -> bool {
@@ -110,11 +104,11 @@ impl FontAtlasSet {
                 .height
                 .max(glyph_texture.width());
             // Pick the higher of 512 or the smallest power of 2 greater than glyph_max_size
-            let containing = (1u32 << (32 - glyph_max_size.leading_zeros())).max(512) as f32;
+            let containing = (1u32 << (32 - glyph_max_size.leading_zeros())).max(512);
             font_atlases.push(FontAtlas::new(
                 textures,
                 texture_atlases,
-                Vec2::new(containing, containing),
+                UVec2::splat(containing),
             ));
             if !font_atlases.last_mut().unwrap().add_glyph(
                 textures,

crates/bevy_ui/src/render/mod.rs

@@ -419,7 +419,7 @@ pub fn extract_uinodes(
                     continue;
                 };
                 let mut atlas_rect = layout.textures[atlas.index];
-                let mut atlas_size = layout.size;
+                let mut atlas_size = layout.size.as_vec2();
                 let scale = uinode.size() / atlas_rect.size();
                 atlas_rect.min *= scale;
                 atlas_rect.max *= scale;
@@ -607,7 +607,7 @@ pub fn extract_text_uinodes(
                     color,
                     rect,
                     image: atlas_info.texture.id(),
-                    atlas_size: Some(atlas.size * inverse_scale_factor),
+                    atlas_size: Some(atlas.size.as_vec2() * inverse_scale_factor),
                     clip: clip.map(|clip| clip.clip),
                     flip_x: false,
                     flip_y: false,

examples/2d/sprite_sheet.rs

@@ -42,7 +42,7 @@ fn setup(
     mut texture_atlases: ResMut<Assets<TextureAtlasLayout>>,
 ) {
     let texture = asset_server.load("textures/rpg/chars/gabe/gabe-idle-run.png");
-    let atlas = TextureAtlasLayout::from_grid(Vec2::new(24.0, 24.0), 7, 1, None, None);
+    let atlas = TextureAtlasLayout::from_grid(UVec2::splat(24), 7, 1, None, None);
     let texture_atlas = texture_atlases.add(atlas);
     // Use only the subset of sprites in the sheet that make up the run animation
     let animation_indices = AnimationIndices { first: 1, last: 6 };

examples/stress_tests/many_animated_sprites.rs

@@ -66,7 +66,7 @@ fn setup(
     let half_y = (map_size.y / 2.0) as i32;
 
     let texture_handle = assets.load("textures/rpg/chars/gabe/gabe-idle-run.png");
-    let texture_atlas = TextureAtlasLayout::from_grid(Vec2::new(24.0, 24.0), 7, 1, None, None);
+    let texture_atlas = TextureAtlasLayout::from_grid(UVec2::splat(24), 7, 1, None, None);
     let texture_atlas_handle = texture_atlases.add(texture_atlas);
 
     // Spawns the camera

examples/ui/ui_texture_atlas.rs

@@ -31,7 +31,7 @@ fn setup(
     };
 
     let texture_handle = asset_server.load("textures/rpg/chars/gabe/gabe-idle-run.png");
-    let texture_atlas = TextureAtlasLayout::from_grid(Vec2::new(24.0, 24.0), 7, 1, None, None);
+    let texture_atlas = TextureAtlasLayout::from_grid(UVec2::splat(24), 7, 1, None, None);
     let texture_atlas_handle = texture_atlases.add(texture_atlas);
 
     // root node