8b7b44d839
# Objective Promote the `Rect` utility of `sprite::Rect`, which defines a rectangle by its minimum and maximum corners, to the `bevy_math` crate to make it available as a general math type to all crates without the need to depend on the `bevy_sprite` crate. Fixes #5575 ## Solution Move `sprite::Rect` into `bevy_math` and fix all uses. Implement `Reflect` for `Rect` directly into the `bevy_reflect` crate by having `bevy_reflect` depend on `bevy_math`. This looks like a new dependency, but the `bevy_reflect` was "cheating" for other math types by directly depending on `glam` to reflect other math types, thereby giving the illusion that there was no dependency on `bevy_math`. In practice conceptually Bevy's math types are reflected into the `bevy_reflect` crate to avoid a dependency of that crate to a "lower level" utility crate like `bevy_math` (which in turn would make `bevy_reflect` be a dependency of most other crates, and increase the risk of circular dependencies). So this change simply formalizes that dependency in `Cargo.toml`. The `Rect` struct is also augmented in this change with a collection of utility methods to improve its usability. A few uses cases are updated to use those new methods, resulting is more clear and concise syntax. --- ## Changelog ### Changed - Moved the `sprite::Rect` type into `bevy_math`. ### Added - Added several utility methods to the `math::Rect` type. ## Migration Guide The `bevy::sprite::Rect` type moved to the math utility crate as `bevy::math::Rect`. You should change your imports from `use bevy::sprite::Rect` to `use bevy::math::Rect`.
98 lines
3.5 KiB
Rust
98 lines
3.5 KiB
Rust
use crate::TextureAtlas;
|
|
use bevy_asset::Assets;
|
|
use bevy_math::{IVec2, Rect, Vec2};
|
|
use bevy_render::texture::{Image, TextureFormatPixelInfo};
|
|
use guillotiere::{size2, Allocation, AtlasAllocator};
|
|
|
|
pub struct DynamicTextureAtlasBuilder {
|
|
pub atlas_allocator: AtlasAllocator,
|
|
pub padding: i32,
|
|
}
|
|
|
|
impl DynamicTextureAtlasBuilder {
|
|
pub fn new(size: Vec2, padding: i32) -> Self {
|
|
Self {
|
|
atlas_allocator: AtlasAllocator::new(to_size2(size)),
|
|
padding,
|
|
}
|
|
}
|
|
|
|
pub fn add_texture(
|
|
&mut self,
|
|
texture_atlas: &mut TextureAtlas,
|
|
textures: &mut Assets<Image>,
|
|
texture: &Image,
|
|
) -> Option<usize> {
|
|
let allocation = self.atlas_allocator.allocate(size2(
|
|
texture.texture_descriptor.size.width as i32 + self.padding,
|
|
texture.texture_descriptor.size.height as i32 + self.padding,
|
|
));
|
|
if let Some(allocation) = allocation {
|
|
let atlas_texture = textures.get_mut(&texture_atlas.texture).unwrap();
|
|
self.place_texture(atlas_texture, allocation, texture);
|
|
let mut rect: Rect = to_rect(allocation.rectangle);
|
|
rect.max -= self.padding as f32;
|
|
Some(texture_atlas.add_texture(rect))
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
// fn resize(
|
|
// &mut self,
|
|
// texture_atlas: &mut TextureAtlas,
|
|
// textures: &mut Assets<Texture>,
|
|
// size: Vec2,
|
|
// ) {
|
|
// let new_size2 = to_size2(new_size);
|
|
// self.atlas_texture = Texture::new_fill(new_size, &[0,0,0,0]);
|
|
// let change_list = self.atlas_allocator.resize_and_rearrange(new_size2);
|
|
|
|
// for change in change_list.changes {
|
|
// if let Some(changed_texture_handle) = self.allocation_textures.remove(&change.old.id)
|
|
// { let changed_texture = textures.get(&changed_texture_handle).unwrap();
|
|
// self.place_texture(change.new, changed_texture_handle, changed_texture);
|
|
// }
|
|
// }
|
|
|
|
// for failure in change_list.failures {
|
|
// let failed_texture = self.allocation_textures.remove(&failure.id).unwrap();
|
|
// queued_textures.push(failed_texture);
|
|
// }
|
|
// }
|
|
|
|
fn place_texture(
|
|
&mut self,
|
|
atlas_texture: &mut Image,
|
|
allocation: Allocation,
|
|
texture: &Image,
|
|
) {
|
|
let mut rect = allocation.rectangle;
|
|
rect.max.x -= self.padding;
|
|
rect.max.y -= self.padding;
|
|
let atlas_width = atlas_texture.texture_descriptor.size.width as usize;
|
|
let rect_width = rect.width() as usize;
|
|
let format_size = atlas_texture.texture_descriptor.format.pixel_size();
|
|
|
|
for (texture_y, bound_y) in (rect.min.y..rect.max.y).map(|i| i as usize).enumerate() {
|
|
let begin = (bound_y * atlas_width + rect.min.x as usize) * format_size;
|
|
let end = begin + rect_width * format_size;
|
|
let texture_begin = texture_y * rect_width * format_size;
|
|
let texture_end = texture_begin + rect_width * format_size;
|
|
atlas_texture.data[begin..end]
|
|
.copy_from_slice(&texture.data[texture_begin..texture_end]);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn to_rect(rectangle: guillotiere::Rectangle) -> Rect {
|
|
Rect {
|
|
min: IVec2::new(rectangle.min.x, rectangle.min.y).as_vec2(),
|
|
max: IVec2::new(rectangle.max.x, rectangle.max.y).as_vec2(),
|
|
}
|
|
}
|
|
|
|
fn to_size2(vec2: Vec2) -> guillotiere::Size {
|
|
guillotiere::Size::new(vec2.x as i32, vec2.y as i32)
|
|
}
|