diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 01:47:29 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 01:47:29 +0000 |
commit | 0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d (patch) | |
tree | a31f07c9bcca9d56ce61e9a1ffd30ef350d513aa /gfx/wr/wr_glyph_rasterizer/examples/basic.rs | |
parent | Initial commit. (diff) | |
download | firefox-esr-0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d.tar.xz firefox-esr-0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d.zip |
Adding upstream version 115.8.0esr.upstream/115.8.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'gfx/wr/wr_glyph_rasterizer/examples/basic.rs')
-rw-r--r-- | gfx/wr/wr_glyph_rasterizer/examples/basic.rs | 177 |
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(); + } + _ => (), + } + }); +} |