wip: adding font to font collection to all asset loader threads

Author: RobertBrewitz

src/plugin.rs

@@ -1,7 +1,7 @@
 use crate::{
     VelloFont, VelloRenderSettings,
     render::{VelloCanvasSettings, VelloRenderPlugin},
-    text::VelloFontLoader,
+    text::{VelloFontLoader, VelloFontLoaderPlugin},
 };
 use bevy::{prelude::*, render::view::RenderLayers};
 use vello::AaConfig;
@@ -32,15 +32,18 @@ impl Default for VelloPlugin {
 
 impl Plugin for VelloPlugin {
     fn build(&self, app: &mut App) {
-        app.add_plugins(VelloRenderPlugin {
-            canvas_settings: VelloCanvasSettings {
-                render_layers: self.canvas_render_layers.clone(),
+        app.add_plugins((
+            VelloRenderPlugin {
+                canvas_settings: VelloCanvasSettings {
+                    render_layers: self.canvas_render_layers.clone(),
+                },
+                render_settings: VelloRenderSettings {
+                    use_cpu: self.use_cpu,
+                    antialiasing: self.antialiasing,
+                },
             },
-            render_settings: VelloRenderSettings {
-                use_cpu: self.use_cpu,
-                antialiasing: self.antialiasing,
-            },
-        })
+            VelloFontLoaderPlugin,
+        ))
         .init_asset::<VelloFont>()
         .init_asset_loader::<VelloFontLoader>();
         #[cfg(feature = "svg")]

src/render/extract.rs

@@ -3,8 +3,8 @@ use crate::prelude::*;
 use bevy::{
     prelude::*,
     render::{
-        camera::ExtractedCamera, extract_component::ExtractComponent,
-        sync_world::TemporaryRenderEntity, view::RenderLayers, Extract, MainWorld,
+        Extract, MainWorld, camera::ExtractedCamera, extract_component::ExtractComponent,
+        sync_world::TemporaryRenderEntity, view::RenderLayers,
     },
 };
 

src/render/systems.rs

@@ -1,10 +1,10 @@
 use super::{
-    extract::{ExtractedVelloText, SSRenderTarget},
-    prepare::PreparedAffine,
     VelloCanvasMaterial, VelloCanvasSettings, VelloEntityCountData, VelloFrameProfileData,
     VelloRenderItem, VelloRenderQueue, VelloRenderSettings, VelloRenderer,
+    extract::{ExtractedVelloText, SSRenderTarget},
+    prepare::PreparedAffine,
 };
-use crate::{render::extract::ExtractedVelloScene, VelloFont};
+use crate::{VelloFont, render::extract::ExtractedVelloScene};
 use bevy::{
     prelude::*,
     render::{

src/text/context.rs

@@ -16,3 +16,15 @@ thread_local! {
     });
     pub static LAYOUT_CONTEXT: RefCell<LayoutContext<Brush>> = RefCell::new(LayoutContext::new());
 }
+
+// static ONE_FONT_CONTEXT: std::sync::OnceLock<FontContext> = std::sync::OnceLock::new();
+//
+// pub fn get_font_context() -> &'static FontContext {
+//     ONE_FONT_CONTEXT.get_or_init(|| FontContext {
+//         collection: Collection::new(CollectionOptions {
+//             shared: true,
+//             system_fonts: false,
+//         }),
+//         ..Default::default()
+//     })
+// }

src/text/font.rs

@@ -1,17 +1,18 @@
 use std::borrow::Cow;
 
 use super::{
+    VelloTextAnchor,
     context::{FONT_CONTEXT, LAYOUT_CONTEXT},
     vello_text::VelloTextSection,
-    VelloTextAnchor,
 };
 use bevy::{prelude::*, reflect::TypePath, render::render_asset::RenderAsset};
 use parley::{FontWeight, InlineBox, PositionedLayoutItem, StyleProperty};
-use vello::{kurbo::Affine, peniko::Fill, Scene};
+use vello::{Scene, kurbo::Affine, peniko::Fill};
 
-#[derive(Asset, TypePath, Debug, Clone, Deref, DerefMut)]
+#[derive(Asset, TypePath, Debug, Clone)]
 pub struct VelloFont {
     pub family_name: String,
+    pub bytes: Vec<u8>,
 }
 
 impl RenderAsset for VelloFont {
@@ -30,8 +31,9 @@ impl RenderAsset for VelloFont {
 impl VelloFont {
     pub fn sizeof(&self, text: &VelloTextSection) -> Vec2 {
         FONT_CONTEXT.with_borrow_mut(|font_context| {
-            println!(
-                "font fams in collection {:?}",
+            debug!(
+                "Thread {:?} sizeof collection {:?}",
+                std::thread::current().id(),
                 font_context.collection.family_names().collect::<Vec<_>>()
             );
 
@@ -66,9 +68,7 @@ impl VelloFont {
 
                 let layout = builder.build(&text.value);
 
-                let res = Vec2::new(layout.width(), layout.height());
-                println!("sizeof: {:?}", res);
-                res
+                Vec2::new(layout.width(), layout.height())
             })
         })
     }
@@ -82,6 +82,12 @@ impl VelloFont {
     ) {
         FONT_CONTEXT.with_borrow_mut(|font_context| {
             LAYOUT_CONTEXT.with_borrow_mut(|layout_context| {
+                debug!(
+                    "Thread {:?} render collection {:?}",
+                    std::thread::current().id(),
+                    font_context.collection.family_names().collect::<Vec<_>>()
+                );
+
                 // TODO: fix scale magic number
                 let mut builder = layout_context.ranged_builder(font_context, &text.value, 1.0);
 
@@ -95,6 +101,7 @@ impl VelloFont {
                     builder.push_default(StyleProperty::LineHeight(line_height));
                 }
 
+                debug!("Family name: {:?}", self.family_name);
                 builder.push_default(StyleProperty::FontStack(parley::FontStack::Single(
                     parley::FontFamily::Named(Cow::Borrowed(&self.family_name)),
                 )));
@@ -120,6 +127,7 @@ impl VelloFont {
                         let glyph_xform = synthesis
                             .skew()
                             .map(|angle| Affine::skew(angle.to_radians().tan() as f64, 0.0));
+
                         scene
                             .draw_glyphs(font)
                             .brush(&text.style.brush)
@@ -146,6 +154,7 @@ impl VelloFont {
 
                 let width = layout.width() as f64;
                 let height = layout.height() as f64;
+                debug!("Width: {:?}, Height: {:?}", width, height);
 
                 match text_anchor {
                     VelloTextAnchor::TopLeft => {

src/text/font_loader.rs

@@ -1,10 +1,49 @@
 use super::{context::FONT_CONTEXT, font::VelloFont};
 use crate::integrations::VectorLoaderError;
-use bevy::asset::{AssetLoader, LoadContext, io::Reader};
+use bevy::{
+    asset::{AssetLoader, LoadContext, io::Reader},
+    prelude::*,
+    tasks::ComputeTaskPool,
+};
 
 #[derive(Default)]
 pub struct VelloFontLoader;
 
+pub struct VelloFontLoaderPlugin;
+
+impl Plugin for VelloFontLoaderPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(Update, font_context_sync);
+    }
+}
+
+fn font_context_sync(vello_fonts: Res<Assets<VelloFont>>) {
+    if vello_fonts.is_changed() {
+        if let Some(compute_task_pool) = ComputeTaskPool::try_get() {
+            let compute_threads = compute_task_pool.thread_num();
+
+            for _ in 0..compute_threads {
+                for (_handle, font) in vello_fonts.iter() {
+                    let font = font.clone();
+
+                    compute_task_pool
+                        .spawn(async move {
+                            debug!(
+                                "Thread {:?} registering font {:?}",
+                                std::thread::current().id(),
+                                font.family_name
+                            );
+                            FONT_CONTEXT.with_borrow_mut(|font_context| {
+                                font_context.collection.register_fonts(font.bytes.clone());
+                            });
+                        })
+                        .detach();
+                }
+            }
+        }
+    }
+}
+
 impl AssetLoader for VelloFontLoader {
     type Asset = VelloFont;
 
@@ -22,20 +61,18 @@ impl AssetLoader for VelloFontLoader {
         reader.read_to_end(&mut bytes).await?;
 
         FONT_CONTEXT.with_borrow_mut(|font_context| {
-            let registered_fonts = font_context.collection.register_fonts(bytes);
+            let registered_fonts = font_context.collection.register_fonts(bytes.clone());
             // TODO: handle multiple fonts in the same font file
             let (family_id, _font_info_vec) = registered_fonts.first().unwrap();
             let family_name = font_context.collection.family_name(*family_id).unwrap();
             let vello_font = VelloFont {
                 family_name: family_name.to_string(),
+                bytes,
             };
-            println!("font fams in collection {:?}", font_context.collection.family_names().collect::<Vec<_>>());
-            println!("vello font {:?}", vello_font);
             Ok(vello_font)
         })
     }
 
-
     fn extensions(&self) -> &[&str] {
         &["ttf"]
     }

src/text/mod.rs

@@ -6,5 +6,5 @@ mod font_loader;
 mod vello_text;
 
 pub use font::VelloFont;
-pub(crate) use font_loader::VelloFontLoader;
+pub(crate) use font_loader::{VelloFontLoader, VelloFontLoaderPlugin};
 pub use vello_text::{VelloTextAnchor, VelloTextSection, VelloTextStyle};