mirror of
https://github.com/bevyengine/bevy
synced 2025-02-18 15:08:36 +00:00
a7be8a2655
# Objective
The physical width and height (pixels) of an image is always integers,
but for `GpuImage` bevy currently stores them as `Vec2` (`f32`).
Switching to `UVec2` makes this more consistent with the [underlying
texture data](https://docs.rs/wgpu/latest/wgpu/struct.Extent3d.html).
I'm not sure if this is worth the change in the surface level API. If
not, feel free to close this PR.
## Solution
- Replace uses of `Vec2` with `UVec2` when referring to texture
dimensions.
- Use integer types for the texture atlas dimensions and sections.
[`Sprite::rect`](a81a2d1da3/crates/bevy_sprite/src/sprite.rs (L29))
remains unchanged, so manually specifying a sub-pixel region of an image
is still possible.
---
## Changelog
- `GpuImage` now stores its size as `UVec2` instead of `Vec2`.
- Texture atlases store their size and sections as `UVec2` and `URect`
respectively.
- `UiImageSize` stores its size as `UVec2`.
## Migration Guide
- Change floating point types (`Vec2`, `Rect`) to their respective
unsigned integer versions (`UVec2`, `URect`) when using `GpuImage`,
`TextureAtlasLayout`, `TextureAtlasBuilder`,
`DynamicAtlasTextureBuilder` or `FontAtlas`.
114 lines
3.3 KiB
Rust
114 lines
3.3 KiB
Rust
use ab_glyph::{GlyphId, Point};
|
|
use bevy_asset::{Assets, Handle};
|
|
use bevy_math::UVec2;
|
|
use bevy_render::{
|
|
render_asset::RenderAssetUsages,
|
|
render_resource::{Extent3d, TextureDimension, TextureFormat},
|
|
texture::Image,
|
|
};
|
|
use bevy_sprite::{DynamicTextureAtlasBuilder, TextureAtlasLayout};
|
|
use bevy_utils::HashMap;
|
|
|
|
#[cfg(feature = "subpixel_glyph_atlas")]
|
|
#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
|
|
pub struct SubpixelOffset {
|
|
x: u16,
|
|
y: u16,
|
|
}
|
|
|
|
#[cfg(feature = "subpixel_glyph_atlas")]
|
|
impl From<Point> for SubpixelOffset {
|
|
fn from(p: Point) -> Self {
|
|
fn f(v: f32) -> u16 {
|
|
((v % 1.) * (u16::MAX as f32)) as u16
|
|
}
|
|
Self {
|
|
x: f(p.x),
|
|
y: f(p.y),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(not(feature = "subpixel_glyph_atlas"))]
|
|
#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
|
|
pub struct SubpixelOffset;
|
|
|
|
#[cfg(not(feature = "subpixel_glyph_atlas"))]
|
|
impl From<Point> for SubpixelOffset {
|
|
fn from(_: Point) -> Self {
|
|
Self
|
|
}
|
|
}
|
|
|
|
pub struct FontAtlas {
|
|
pub dynamic_texture_atlas_builder: DynamicTextureAtlasBuilder,
|
|
pub glyph_to_atlas_index: HashMap<(GlyphId, SubpixelOffset), usize>,
|
|
pub texture_atlas: Handle<TextureAtlasLayout>,
|
|
pub texture: Handle<Image>,
|
|
}
|
|
|
|
impl FontAtlas {
|
|
pub fn new(
|
|
textures: &mut Assets<Image>,
|
|
texture_atlases: &mut Assets<TextureAtlasLayout>,
|
|
size: UVec2,
|
|
) -> FontAtlas {
|
|
let texture = textures.add(Image::new_fill(
|
|
Extent3d {
|
|
width: size.x,
|
|
height: size.y,
|
|
depth_or_array_layers: 1,
|
|
},
|
|
TextureDimension::D2,
|
|
&[0, 0, 0, 0],
|
|
TextureFormat::Rgba8UnormSrgb,
|
|
// Need to keep this image CPU persistent in order to add additional glyphs later on
|
|
RenderAssetUsages::MAIN_WORLD | RenderAssetUsages::RENDER_WORLD,
|
|
));
|
|
let texture_atlas = TextureAtlasLayout::new_empty(size);
|
|
Self {
|
|
texture_atlas: texture_atlases.add(texture_atlas),
|
|
glyph_to_atlas_index: HashMap::default(),
|
|
dynamic_texture_atlas_builder: DynamicTextureAtlasBuilder::new(size, 0),
|
|
texture,
|
|
}
|
|
}
|
|
|
|
pub fn get_glyph_index(
|
|
&self,
|
|
glyph_id: GlyphId,
|
|
subpixel_offset: SubpixelOffset,
|
|
) -> Option<usize> {
|
|
self.glyph_to_atlas_index
|
|
.get(&(glyph_id, subpixel_offset))
|
|
.copied()
|
|
}
|
|
|
|
pub fn has_glyph(&self, glyph_id: GlyphId, subpixel_offset: SubpixelOffset) -> bool {
|
|
self.glyph_to_atlas_index
|
|
.contains_key(&(glyph_id, subpixel_offset))
|
|
}
|
|
|
|
pub fn add_glyph(
|
|
&mut self,
|
|
textures: &mut Assets<Image>,
|
|
texture_atlases: &mut Assets<TextureAtlasLayout>,
|
|
glyph_id: GlyphId,
|
|
subpixel_offset: SubpixelOffset,
|
|
texture: &Image,
|
|
) -> bool {
|
|
let texture_atlas = texture_atlases.get_mut(&self.texture_atlas).unwrap();
|
|
if let Some(index) = self.dynamic_texture_atlas_builder.add_texture(
|
|
texture_atlas,
|
|
textures,
|
|
texture,
|
|
&self.texture,
|
|
) {
|
|
self.glyph_to_atlas_index
|
|
.insert((glyph_id, subpixel_offset), index);
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
}
|