Formatting

bevy_kayak_ui/src/render/font/extract.rs

@@ -21,29 +21,22 @@ pub fn extract_texts(
     _dpi: f32,
 ) -> Vec<ExtractQuadBundle> {
     let mut extracted_texts = Vec::new();
-    let (background_color, text_layout, layout, font, properties) =
-        match render_primitive {
-            RenderPrimitive::Text {
-                color,
-                text_layout,
-                layout,
-                font,
-                properties,
-                ..
-            } => (
-                color,
-                text_layout,
-                layout,
-                font,
-                *properties,
-            ),
-            _ => panic!(""),
-        };
+    let (background_color, text_layout, layout, font, properties) = match render_primitive {
+        RenderPrimitive::Text {
+            color,
+            text_layout,
+            layout,
+            font,
+            properties,
+            ..
+        } => (color, text_layout, layout, font, *properties),
+        _ => panic!(""),
+    };
 
     let font_handle = font_mapping.get_handle(font.clone()).unwrap();
     let font = match fonts.get(font_handle.clone()) {
         Some(font) => font,
-        None => return Vec::new()
+        None => return Vec::new(),
     };
 
     let base_position = Vec2::new(layout.posx, layout.posy + properties.font_size);

kayak_core/src/render_primitive.rs

-use kayak_font::{TextLayout, TextProperties};
 use crate::{
     color::Color,
     layout_cache::Rect,
     render_command::RenderCommand,
     styles::{Corner, Edge, Style},
 };
+use kayak_font::{TextLayout, TextProperties};
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum RenderPrimitive {

kayak_font/examples/bevy.rs

 use bevy::{
-    DefaultPlugins,
     math::{const_vec2, Vec2},
-    prelude::{App as BevyApp, AssetServer, Commands, Component, Handle, Input, KeyCode, Query, Res, ResMut, Sprite, SpriteBundle, Transform, With, Without},
+    prelude::{
+        App as BevyApp, AssetServer, Commands, Component, Handle, Input, KeyCode, Query, Res,
+        ResMut, Sprite, SpriteBundle, Transform, With, Without,
+    },
     render::{camera::OrthographicCameraBundle, color::Color},
     window::WindowDescriptor,
+    DefaultPlugins,
 };
 
-use kayak_font::{Alignment, bevy::KayakFontPlugin, KayakFont};
+use kayak_font::{bevy::KayakFontPlugin, Alignment, KayakFont};
 use renderer::{FontRenderPlugin, Text};
 
 mod renderer;
@@ -14,7 +17,8 @@ mod renderer;
 const FONT_SIZE: f32 = 24.0;
 const INITIAL_SIZE: Vec2 = const_vec2!([400.0, 300.0]);
 const INITIAL_POS: Vec2 = const_vec2!([-200.0, 0.0]);
-const INSTRUCTIONS: &str = "Press 'A' and 'D' to shrink and grow the text box.\nPress 'Space' to cycle text alignment.";
+const INSTRUCTIONS: &str =
+    "Press 'A' and 'D' to shrink and grow the text box.\nPress 'Space' to cycle text alignment.";
 
 #[derive(Component)]
 struct Instructions;
@@ -37,16 +41,19 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
         })
         .insert(font_handle.clone());
 
-    commands.spawn()
-        .insert_bundle(SpriteBundle {
-            sprite: Sprite {
-                color: Color::DARK_GRAY,
-                custom_size: Some(INITIAL_SIZE),
-                ..Default::default()
-            },
-            transform: Transform::from_xyz((INITIAL_SIZE.x / 2.0) + INITIAL_POS.x, (-INITIAL_SIZE.y / 4.0) - 20.0, -0.05),
+    commands.spawn().insert_bundle(SpriteBundle {
+        sprite: Sprite {
+            color: Color::DARK_GRAY,
+            custom_size: Some(INITIAL_SIZE),
             ..Default::default()
-        });
+        },
+        transform: Transform::from_xyz(
+            (INITIAL_SIZE.x / 2.0) + INITIAL_POS.x,
+            (-INITIAL_SIZE.y / 4.0) - 20.0,
+            -0.05,
+        ),
+        ..Default::default()
+    });
 
     commands
         .spawn()
@@ -63,12 +70,18 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
         .insert(font_handle.clone());
 }
 
-fn control_text(keyboard_input: ResMut<Input<KeyCode>>, mut text_box: Query<&mut Text, Without<Instructions>>, mut instructions: Query<&mut Text, With<Instructions>>, mut bg: Query<&mut Sprite>) {
-    let speed = if keyboard_input.pressed(KeyCode::LShift) || keyboard_input.pressed(KeyCode::RShift) {
-        2.5
-    } else {
-        1.0
-    };
+fn control_text(
+    keyboard_input: ResMut<Input<KeyCode>>,
+    mut text_box: Query<&mut Text, Without<Instructions>>,
+    mut instructions: Query<&mut Text, With<Instructions>>,
+    mut bg: Query<&mut Sprite>,
+) {
+    let speed =
+        if keyboard_input.pressed(KeyCode::LShift) || keyboard_input.pressed(KeyCode::RShift) {
+            2.5
+        } else {
+            1.0
+        };
 
     if keyboard_input.just_pressed(KeyCode::Space) {
         for mut text in text_box.iter_mut() {
@@ -95,7 +108,9 @@ fn control_text(keyboard_input: ResMut<Input<KeyCode>>, mut text_box: Query<&mut
 
         let mut instructions = instructions.single_mut();
         instructions.content = String::from(INSTRUCTIONS);
-        instructions.content.push_str(&format!("\nSize: {}", text.size.x));
+        instructions
+            .content
+            .push_str(&format!("\nSize: {}", text.size.x));
     }
 
     for mut sprite in bg.iter_mut() {
@@ -117,4 +132,4 @@ fn main() {
         .add_startup_system(startup)
         .add_system(control_text)
         .run();
-}
+}
\ No newline at end of file

kayak_font/examples/renderer/extract.rs

@@ -19,7 +19,6 @@ pub fn extract(
 
     for (text, font_handle) in texts.iter() {
         if let Some(font) = fonts.get(font_handle) {
-
             let properties = TextProperties {
                 font_size: text.font_size,
                 line_height: text.line_height,
@@ -28,10 +27,7 @@ pub fn extract(
                 ..Default::default()
             };
 
-            let text_layout = font.measure(
-                &text.content,
-                properties
-            );
+            let text_layout = font.measure(&text.content, properties);
 
             for glyph_rect in text_layout.glyphs() {
                 let mut position = Vec2::from(glyph_rect.position);

kayak_font/src/font.rs

@@ -5,8 +5,8 @@ use bevy::{prelude::Handle, reflect::TypeUuid, render::texture::Image};
 use unicode_segmentation::UnicodeSegmentation;
 
 use crate::layout::{Alignment, Line, TextLayout};
-use crate::{utility, Sdf, TextProperties, Glyph, GlyphRect};
 use crate::utility::{BreakableWord, MISSING, SPACE};
+use crate::{utility, Glyph, GlyphRect, Sdf, TextProperties};
 
 #[cfg(feature = "bevy_renderer")]
 #[derive(Debug, Clone, TypeUuid, PartialEq)]
@@ -31,9 +31,17 @@ pub struct KayakFont {
 impl KayakFont {
     pub fn new(sdf: Sdf, #[cfg(feature = "bevy_renderer")] atlas_image: Handle<Image>) -> Self {
         let max_glyph_size = sdf.max_glyph_size();
-        assert!(sdf.glyphs.len() < u32::MAX as usize, "SDF contains too many glyphs");
-
-        let char_ids: HashMap<char, u32> = sdf.glyphs.iter().enumerate().map(|(idx, glyph)| (glyph.unicode, idx as u32)).collect();
+        assert!(
+            sdf.glyphs.len() < u32::MAX as usize,
+            "SDF contains too many glyphs"
+        );
+
+        let char_ids: HashMap<char, u32> = sdf
+            .glyphs
+            .iter()
+            .enumerate()
+            .map(|(idx, glyph)| (glyph.unicode, idx as u32))
+            .collect();
 
         let missing_glyph = if char_ids.contains_key(&MISSING) {
             Some(MISSING)
@@ -43,7 +51,6 @@ impl KayakFont {
             None
         };
 
-
         Self {
             sdf,
             #[cfg(feature = "bevy_renderer")]
@@ -127,7 +134,6 @@ impl KayakFont {
 
         let words = utility::split_breakable_words(content).collect::<Vec<_>>();
         for (index, word) in words.iter().enumerate() {
-
             // Check if this is the last word of the line.
             let mut will_break = break_index.map(|idx| index + 1 == idx).unwrap_or_default();
 
@@ -147,7 +153,8 @@ impl KayakFont {
                         // Skip finding a line break since we're guaranteed not to find one until `idx`
                     }
                     _ => {
-                        let (next_break, next_skip) = self.find_next_break(index, line.width, properties, &words);
+                        let (next_break, next_skip) =
+                            self.find_next_break(index, line.width, properties, &words);
                         break_index = next_break;
                         skip_until_index = next_skip;
                         will_break |= break_index.map(|idx| index + 1 == idx).unwrap_or_default();
@@ -175,10 +182,12 @@ impl KayakFont {
                     } else if utility::is_tab(c) {
                         line.width += tab_width;
                     } else {
-                        let glyph = self.get_glyph(c).or_else(|| if let Some(missing) = self.missing_glyph {
-                            self.get_glyph(missing)
-                        } else {
-                            None
+                        let glyph = self.get_glyph(c).or_else(|| {
+                            if let Some(missing) = self.missing_glyph {
+                                self.get_glyph(missing)
+                            } else {
+                                None
+                            }
                         });
 
                         if let Some(glyph) = glyph {
@@ -262,7 +271,13 @@ impl KayakFont {
     /// * `properties`: The associated text properties
     /// * `words`: The list of breakable words
     ///
-    fn find_next_break(&self, curr_index: usize, line_width: f32, properties: TextProperties, words: &[BreakableWord]) -> (Option<usize>, Option<usize>) {
+    fn find_next_break(
+        &self,
+        curr_index: usize,
+        line_width: f32,
+        properties: TextProperties,
+        words: &[BreakableWord],
+    ) -> (Option<usize>, Option<usize>) {
         // Line Break Rules:
         //
         // Break before Next if...
@@ -396,7 +411,9 @@ impl KayakFont {
     ///
     /// Returns `None` if no glyph was found.
     pub fn get_glyph(&self, c: char) -> Option<&Glyph> {
-        self.char_ids.get(&c).and_then(|index| self.sdf.glyphs.get(*index as usize))
+        self.char_ids
+            .get(&c)
+            .and_then(|index| self.sdf.glyphs.get(*index as usize))
     }
 
     /// Calculates the appropriate glyph size for a desired font size.
@@ -405,6 +422,9 @@ impl KayakFont {
     /// in the atlas.
     fn calc_glyph_size(&self, font_size: f32) -> (f32, f32) {
         let font_scale = font_size / self.sdf.atlas.font_size;
-        (self.max_glyph_size.0 * font_scale, self.max_glyph_size.1 * font_scale)
+        (
+            self.max_glyph_size.0 * font_scale,
+            self.max_glyph_size.1 * font_scale,
+        )
     }
 }

kayak_font/src/layout.rs

@@ -92,8 +92,18 @@ pub struct TextLayout {
 
 impl TextLayout {
     /// Create a new [`TextLayout`].
-    pub fn new(glyphs: Vec<GlyphRect>, lines: Vec<Line>, size: (f32, f32), properties: TextProperties) -> Self {
-        Self { glyphs, lines, size, properties }
+    pub fn new(
+        glyphs: Vec<GlyphRect>,
+        lines: Vec<Line>,
+        size: (f32, f32),
+        properties: TextProperties,
+    ) -> Self {
+        Self {
+            glyphs,
+            lines,
+            size,
+            properties,
+        }
     }
 
     /// Returns the calculated lines for the text content.

kayak_font/src/utility.rs

@@ -55,7 +55,11 @@ pub struct BreakableWordIter<'a> {
 
 impl<'a> BreakableWordIter<'a> {
     pub fn new(text: &'a str) -> Self {
-        Self { text, iter: LineBreakIterator::new(text), index: 0 }
+        Self {
+            text,
+            iter: LineBreakIterator::new(text),
+            index: 0,
+        }
     }
 }
 
@@ -78,4 +82,3 @@ impl<'a> Iterator for BreakableWordIter<'a> {
         self.iter.size_hint()
     }
 }
-