Subpixel text positioning (bevyengine#1196)

* cleanup unnecessary changes from PR bevyengine#1171

* add feature to correctly render glyphs with sub-pixel positioning

Cargo.toml

@@ -72,6 +72,9 @@ serialize = ["bevy_internal/serialize"]
 wayland = ["bevy_internal/wayland"]
 x11 = ["bevy_internal/x11"]
 
+# enable rendering of font glyphs using subpixel accuracy
+subpixel_glyph_atlas = ["bevy_internal/subpixel_glyph_atlas"]
+
 [dependencies]
 bevy_dylib = {path = "crates/bevy_dylib", version = "0.4.0", default-features = false, optional = true}
 bevy_internal = {path = "crates/bevy_internal", version = "0.4.0", default-features = false}

crates/bevy_internal/Cargo.toml

@@ -38,6 +38,9 @@ serialize = ["bevy_input/serialize"]
 wayland = ["bevy_winit/wayland"]
 x11 = ["bevy_winit/x11"]
 
+# enable rendering of font glyphs using subpixel accuracy
+subpixel_glyph_atlas = ["bevy_text/subpixel_glyph_atlas"]
+
 [dependencies]
 # bevy
 bevy_app = { path = "../bevy_app", version = "0.4.0" }

crates/bevy_text/Cargo.toml

@@ -12,6 +12,9 @@ repository = "https:/bevyengine/bevy"
 license = "MIT"
 keywords = ["bevy"]
 
+[features]
+subpixel_glyph_atlas = []
+
 [dependencies]
 # bevy
 bevy_app = { path = "../bevy_app", version = "0.4.0" }

crates/bevy_text/src/font_atlas.rs

@@ -1,13 +1,44 @@
-use ab_glyph::GlyphId;
+use ab_glyph::{GlyphId, Point};
 use bevy_asset::{Assets, Handle};
 use bevy_math::Vec2;
 use bevy_render::texture::{Extent3d, Texture, TextureDimension, TextureFormat};
 use bevy_sprite::{DynamicTextureAtlasBuilder, TextureAtlas};
 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, u32>,
+ pub glyph_to_atlas_index: HashMap<(GlyphId, SubpixelOffset), u32>,
  pub texture_atlas: Handle<TextureAtlas>,
 }
 
@@ -31,27 +62,36 @@ impl FontAtlas {
  }
  }
 
- pub fn get_glyph_index(&self, glyph_id: GlyphId) -> Option<u32> {
- self.glyph_to_atlas_index.get(&glyph_id).copied()
+ pub fn get_glyph_index(
+ &self,
+ glyph_id: GlyphId,
+ subpixel_offset: SubpixelOffset,
+ ) -> Option<u32> {
+ self.glyph_to_atlas_index
+ .get(&(glyph_id, subpixel_offset))
+ .copied()
  }
 
- pub fn has_glyph(&self, glyph_id: GlyphId) -> bool {
- self.glyph_to_atlas_index.contains_key(&glyph_id)
+ 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<Texture>,
  texture_atlases: &mut Assets<TextureAtlas>,
  glyph_id: GlyphId,
+ subpixel_offset: SubpixelOffset,
  texture: &Texture,
  ) -> 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.glyph_to_atlas_index.insert(glyph_id, index);
+ self.glyph_to_atlas_index
+ .insert((glyph_id, subpixel_offset), index);
  true
  } else {
  false

crates/bevy_text/src/font_atlas_set.rs

@@ -1,5 +1,5 @@
 use crate::{error::TextError, Font, FontAtlas};
-use ab_glyph::{GlyphId, OutlinedGlyph};
+use ab_glyph::{GlyphId, OutlinedGlyph, Point};
 use bevy_asset::{Assets, Handle};
 use bevy_core::FloatOrd;
 use bevy_math::Vec2;
@@ -35,11 +35,13 @@ impl FontAtlasSet {
  self.font_atlases.iter()
  }
 
- pub fn has_glyph(&self, glyph_id: GlyphId, font_size: f32) -> bool {
+ pub fn has_glyph(&self, glyph_id: GlyphId, glyph_position: Point, font_size: f32) -> bool {
  self.font_atlases
  .get(&FloatOrd(font_size))
  .map_or(false, |font_atlas| {
- font_atlas.iter().any(|atlas| atlas.has_glyph(glyph_id))
+ font_atlas
+ .iter()
+ .any(|atlas| atlas.has_glyph(glyph_id, glyph_position.into()))
  })
  }
 
@@ -51,6 +53,7 @@ impl FontAtlasSet {
  ) -> Result<GlyphAtlasInfo, TextError> {
  let glyph = outlined_glyph.glyph();
  let glyph_id = glyph.id;
+ let glyph_position = glyph.position;
  let font_size = glyph.scale.y;
  let font_atlases = self
  .font_atlases
@@ -64,7 +67,13 @@ impl FontAtlasSet {
  });
  let glyph_texture = Font::get_outlined_glyph_texture(outlined_glyph);
  let add_char_to_font_atlas = |atlas: &mut FontAtlas| -> bool {
- atlas.add_glyph(textures, texture_atlases, glyph_id, &glyph_texture)
+ atlas.add_glyph(
+ textures,
+ texture_atlases,
+ glyph_id,
+ glyph_position.into(),
+ &glyph_texture,
+ )
  };
  if !font_atlases.iter_mut().any(add_char_to_font_atlas) {
  font_atlases.push(FontAtlas::new(
@@ -76,19 +85,23 @@ impl FontAtlasSet {
  textures,
  texture_atlases,
  glyph_id,
+ glyph_position.into(),
  &glyph_texture,
  ) {
  return Err(TextError::FailedToAddGlyph(glyph_id));
  }
  }
 
- Ok(self.get_glyph_atlas_info(font_size, glyph_id).unwrap())
+ Ok(self
+ .get_glyph_atlas_info(font_size, glyph_id, glyph_position)
+ .unwrap())
  }
 
  pub fn get_glyph_atlas_info(
  &self,
  font_size: f32,
  glyph_id: GlyphId,
+ position: Point,
  ) -> Option<GlyphAtlasInfo> {
  self.font_atlases
  .get(&FloatOrd(font_size))
@@ -97,7 +110,7 @@ impl FontAtlasSet {
  .iter()
  .find_map(|atlas| {
  atlas
- .get_glyph_index(glyph_id)
+ .get_glyph_index(glyph_id, position.into())
  .map(|glyph_index| (glyph_index, atlas.texture_atlas.clone_weak()))
  })
  .map(|(glyph_index, texture_atlas)| GlyphAtlasInfo {

crates/bevy_text/src/glyph_brush.rs

@@ -1,4 +1,4 @@
-use ab_glyph::{Font as _, FontArc, ScaleFont as _};
+use ab_glyph::{Font as _, FontArc, Glyph, ScaleFont as _};
 use bevy_asset::{Assets, Handle};
 use bevy_math::{Size, Vec2};
 use bevy_render::prelude::Texture;
@@ -80,16 +80,16 @@ impl GlyphBrush {
  font_id: _,
  } = sg;
  let glyph_id = glyph.id;
- let base_x = glyph.position.x.floor();
- glyph.position.x = 0.;
+ let glyph_position = glyph.position;
+ let adjust = GlyphPlacementAdjuster::new(&mut glyph);
  if let Some(outlined_glyph) = font.font.outline_glyph(glyph) {
  let bounds = outlined_glyph.px_bounds();
  let handle_font_atlas: Handle<FontAtlasSet> = handle.as_weak();
  let font_atlas_set = font_atlas_set_storage
  .get_or_insert_with(handle_font_atlas, FontAtlasSet::default);
 
  let atlas_info = font_atlas_set
- .get_glyph_atlas_info(font_size, glyph_id)
+ .get_glyph_atlas_info(font_size, glyph_id, glyph_position)
  .map(Ok)
  .unwrap_or_else(|| {
  font_atlas_set.add_glyph_to_atlas(texture_atlases, textures, outlined_glyph)
@@ -100,11 +100,9 @@ impl GlyphBrush {
  let glyph_width = glyph_rect.width();
  let glyph_height = glyph_rect.height();
 
- let x = base_x + bounds.min.x + glyph_width / 2.0 - min_x;
- // the 0.5 accounts for odd-numbered heights (bump up by 1 pixel)
- // max_y = text block height, and up is negative (whereas for transform, up is positive)
+ let x = bounds.min.x + glyph_width / 2.0 - min_x;
  let y = max_y - bounds.max.y + glyph_height / 2.0;
- let position = Vec2::new(x, y);
+ let position = adjust.position(Vec2::new(x, y));
 
  positioned_glyphs.push(PositionedGlyph {
  position,
@@ -129,3 +127,38 @@ pub struct PositionedGlyph {
  pub position: Vec2,
  pub atlas_info: GlyphAtlasInfo,
 }
+
+#[cfg(feature = "subpixel_glyph_atlas")]
+struct GlyphPlacementAdjuster;
+
+#[cfg(feature = "subpixel_glyph_atlas")]
+impl GlyphPlacementAdjuster {
+ #[inline(always)]
+ pub fn new(_: &mut Glyph) -> Self {
+ Self
+ }
+
+ #[inline(always)]
+ pub fn position(&self, p: Vec2) -> Vec2 {
+ p
+ }
+}
+
+#[cfg(not(feature = "subpixel_glyph_atlas"))]
+struct GlyphPlacementAdjuster(f32);
+
+#[cfg(not(feature = "subpixel_glyph_atlas"))]
+impl GlyphPlacementAdjuster {
+ #[inline(always)]
+ pub fn new(glyph: &mut Glyph) -> Self {
+ let v = glyph.position.x.round();
+ glyph.position.x = 0.;
+ glyph.position.y = glyph.position.y.ceil();
+ Self(v)
+ }
+
+ #[inline(always)]
+ pub fn position(&self, v: Vec2) -> Vec2 {
+ Vec2::new(self.0, 0.) + v
+ }
+}

docs/cargo_features.md

@@ -71,3 +71,9 @@ Vorbis audio format support.
 ### wayland
 
 Enable this to use Wayland display server protocol other than X11.
+
+### subpixel_glyph_atlas
+
+Enable this to cache glyphs using subpixel accuracy. This increases texture
+memory usage as each position requires a separate sprite in the glyph atlas, but
+provide more accurate character spacing.