1 files changed, 177 insertions, 0 deletions
diff --git a/gfx/wr/wr_glyph_rasterizer/examples/basic.rs b/gfx/wr/wr_glyph_rasterizer/examples/basic.rs
new file mode 100644
index 0000000000..4c46004cdf
--- /dev/null
+++ b/gfx/wr/wr_glyph_rasterizer/examples/basic.rs
@@ -0,0 +1,177 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::sync::Arc;
+use std::mem;
+
+use api::{
+    IdNamespace, FontTemplate, FontKey, FontInstanceKey, FontInstanceOptions,
+    FontInstancePlatformOptions, ColorF, FontInstanceFlags, units::DevicePoint,
+};
+use glutin::ContextBuilder;
+use glutin::dpi::PhysicalSize;
+use glutin::event::{Event, WindowEvent};
+use glutin::event_loop::{ControlFlow, EventLoop};
+use glutin::window::WindowBuilder;
+use rayon::ThreadPoolBuilder;
+use wr_glyph_rasterizer::RasterizedGlyph;
+use wr_glyph_rasterizer::{
+    SharedFontResources, BaseFontInstance, GlyphRasterizer, FontInstance, GlyphKey,
+    SubpixelDirection, profiler::GlyphRasterizeProfiler,
+};
+
+#[path = "common/boilerplate.rs"]
+mod boilerplate;
+
+struct Profiler;
+
+impl GlyphRasterizeProfiler for Profiler {
+    fn start_time(&mut self) {}
+    fn end_time(&mut self) -> f64 {
+        0.
+    }
+    fn set(&mut self, _value: f64) {}
+}
+
+fn load_glyphs() -> Vec<RasterizedGlyph> {
+    let namespace = IdNamespace(0);
+    let mut fonts = SharedFontResources::new(namespace);
+
+    let font_key = FontKey::new(namespace, 0);
+    let raw_font_data = include_bytes!("../../wrench/reftests/text/FreeSans.ttf");
+    let font_template = FontTemplate::Raw(Arc::new(raw_font_data.to_vec()), 0);
+    let shared_font_key = fonts
+        .font_keys
+        .add_key(&font_key, &font_template)
+        .expect("Failed to add font key");
+
+    let font_instance_key = FontInstanceKey::new(namespace, 1);
+    fonts.templates.add_font(shared_font_key, font_template);
+    assert!(fonts.templates.has_font(&shared_font_key));
+
+    // AddFontInstance will only be processed here, not in the resource cache, so it
+    // is safe to take the options rather than clone them.
+    let base = BaseFontInstance::new(
+        font_instance_key,
+        shared_font_key,
+        32.,
+        mem::take(&mut Some(FontInstanceOptions::default())),
+        mem::take(&mut Some(FontInstancePlatformOptions::default())),
+        mem::take(&mut Vec::new()),
+    );
+    let shared_instance = fonts
+        .instance_keys
+        .add_key(base)
+        .expect("Failed to add font instance key");
+    fonts.instances.add_font_instance(shared_instance);
+
+    let workers = {
+        let worker = ThreadPoolBuilder::new()
+            .thread_name(|idx| format!("WRWorker#{}", idx))
+            .build();
+        Arc::new(worker.unwrap())
+    };
+    let mut glyph_rasterizer = GlyphRasterizer::new(workers, false);
+
+    glyph_rasterizer.add_font(
+        shared_font_key,
+        fonts
+            .templates
+            .get_font(&shared_font_key)
+            .expect("Could not find FontTemplate"),
+    );
+
+    let mut font = FontInstance::new(
+        fonts
+            .instances
+            .get_font_instance(font_instance_key)
+            .expect("Could not found BaseFontInstance"),
+        ColorF::BLACK.into(),
+        api::FontRenderMode::Alpha,
+        FontInstanceFlags::SUBPIXEL_POSITION | FontInstanceFlags::FONT_SMOOTHING,
+    );
+
+    glyph_rasterizer.prepare_font(&mut font);
+
+    let glyph_keys = [
+        glyph_rasterizer
+            .get_glyph_index(shared_font_key, 'A')
+            .expect("Failed to get glyph index"),
+        glyph_rasterizer
+            .get_glyph_index(shared_font_key, 'B')
+            .expect("Failed to get glyph index"),
+        glyph_rasterizer
+            .get_glyph_index(shared_font_key, 'C')
+            .expect("Failed to get glyph index"),
+    ];
+
+    let glyph_keys = glyph_keys.map(|g| {
+        GlyphKey::new(
+            g,
+            DevicePoint::new(100., 100.),
+            SubpixelDirection::Horizontal,
+        )
+    });
+
+    glyph_rasterizer.request_glyphs(font, &glyph_keys, |_| true);
+
+    let mut glyphs = vec![];
+    glyph_rasterizer.resolve_glyphs(
+        |job, _| {
+            if let Ok(glyph) = job.result {
+                glyphs.push(glyph);
+            }
+        },
+        &mut Profiler,
+    );
+
+    glyphs
+}
+
+fn main() {
+    let glyphs = load_glyphs();
+
+    let el = EventLoop::new();
+    let wb = WindowBuilder::new()
+        .with_title("A fantastic window!")
+        .with_inner_size(PhysicalSize::new(1900. as f64, 1300. as f64));
+
+    let windowed_context = ContextBuilder::new()
+        .with_gl(glutin::GlRequest::GlThenGles {
+            opengl_version: (3, 2),
+            opengles_version: (3, 0),
+        })
+        .build_windowed(wb, &el)
+        .unwrap();
+
+    let windowed_context = unsafe { windowed_context.make_current().unwrap() };
+
+    let gl = boilerplate::load(windowed_context.context(), glyphs);
+
+    el.run(move |event, _, control_flow| {
+        *control_flow = ControlFlow::Wait;
+
+        match event {
+            Event::LoopDestroyed => (),
+            Event::WindowEvent { event, .. } => match event {
+                WindowEvent::Resized(physical_size) => windowed_context.resize(physical_size),
+                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+                _ => (),
+            },
+            Event::RedrawRequested(_) => {
+                let size = windowed_context.window().inner_size();
+                let scale_factor = windowed_context.window().scale_factor();
+                gl.draw_frame(
+                    size.width as f32,
+                    size.height as f32,
+                    [0., 0., 0., 1.0],
+                    [1., 1., 1., 1.0],
+                    scale_factor as f32,
+                );
+                windowed_context.swap_buffers().unwrap();
+            }
+            _ => (),
+        }
+    });
+}