From 23fa0351780257740cda06dbaac210efe9511d40 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Fri, 3 Feb 2017 17:18:05 -0800 Subject: [PATCH] Rename "glyph buffer" to "outline", since "glyph" is ambiguous --- examples/benchmark.rs | 16 ++++----- examples/generate-atlas.rs | 15 ++++---- examples/lorem-ipsum.rs | 53 ++++++++++++++--------------- src/atlas.rs | 27 +++++++-------- src/lib.rs | 2 +- src/otf/glyf.rs | 2 +- src/otf/mod.rs | 2 +- src/{glyph_buffer.rs => outline.rs} | 16 ++++----- src/rasterizer.rs | 10 +++--- src/tests/buffers.rs | 6 ++-- 10 files changed, 73 insertions(+), 76 deletions(-) rename src/{glyph_buffer.rs => outline.rs} (95%) diff --git a/examples/benchmark.rs b/examples/benchmark.rs index 24af2e8f..3ef0765d 100644 --- a/examples/benchmark.rs +++ b/examples/benchmark.rs @@ -22,7 +22,7 @@ use memmap::{Mmap, Protection}; use pathfinder::atlas::AtlasBuilder; use pathfinder::charmap::CodepointRange; use pathfinder::coverage::CoverageBuffer; -use pathfinder::glyph_buffer::GlyphBufferBuilder; +use pathfinder::outline::OutlineBuilder; use pathfinder::otf::Font; use pathfinder::rasterizer::{Rasterizer, RasterizerOptions}; use std::env; @@ -63,11 +63,11 @@ fn main() { let mut results = vec![]; let start = time::precise_time_ns(); let mut last_time = start; - let (mut glyph_buffer_builder, mut glyph_buffers, mut glyph_count); + let (mut outline_builder, mut outline_buffers, mut glyph_count); let (mut atlas_builder, mut atlas); loop { - glyph_buffer_builder = GlyphBufferBuilder::new(); + outline_builder = OutlineBuilder::new(); atlas_builder = AtlasBuilder::new(device_pixel_width as GLuint, shelf_height); glyph_count = 0; unsafe { @@ -77,8 +77,8 @@ fn main() { let glyph_ranges = font.glyph_ranges_for_codepoint_ranges(&codepoint_ranges) .unwrap(); for (glyph_index, glyph_id) in glyph_ranges.iter().enumerate() { - glyph_buffer_builder.add_glyph(&font, glyph_id).unwrap(); - atlas_builder.pack_glyph(&glyph_buffer_builder, + outline_builder.add_glyph(&font, glyph_id).unwrap(); + atlas_builder.pack_glyph(&outline_builder, glyph_index as u32, point_size as f32).unwrap(); glyph_count += 1 @@ -86,8 +86,8 @@ fn main() { } - glyph_buffers = glyph_buffer_builder.create_buffers().unwrap(); - atlas = atlas_builder.create_atlas(&glyph_buffer_builder).unwrap(); + outline_buffers = outline_builder.create_buffers().unwrap(); + atlas = atlas_builder.create_atlas(&outline_builder).unwrap(); let end = time::precise_time_ns(); results.push((end - last_time) as f64); @@ -114,7 +114,7 @@ fn main() { let start_time = time::precise_time_ns(); loop { let events = - rasterizer.draw_atlas(&image, &rect, &atlas, &glyph_buffers, &coverage_buffer) + rasterizer.draw_atlas(&image, &rect, &atlas, &outline_buffers, &coverage_buffer) .unwrap(); let mut draw_time = 0u64; diff --git a/examples/generate-atlas.rs b/examples/generate-atlas.rs index c6c1b046..7777e678 100644 --- a/examples/generate-atlas.rs +++ b/examples/generate-atlas.rs @@ -19,7 +19,7 @@ use memmap::{Mmap, Protection}; use pathfinder::atlas::AtlasBuilder; use pathfinder::charmap::CodepointRange; use pathfinder::coverage::CoverageBuffer; -use pathfinder::glyph_buffer::GlyphBufferBuilder; +use pathfinder::outline::OutlineBuilder; use pathfinder::otf::Font; use pathfinder::rasterizer::{Rasterizer, RasterizerOptions}; use std::env; @@ -58,7 +58,7 @@ fn main() { // FIXME(pcwalton) let shelf_height = (point_size * 2.0).ceil() as u32; - let mut glyph_buffer_builder = GlyphBufferBuilder::new(); + let mut outline_builder = OutlineBuilder::new(); let mut atlas_builder = AtlasBuilder::new(device_pixel_width as GLuint, shelf_height); unsafe { @@ -67,14 +67,13 @@ fn main() { let glyph_ranges = font.glyph_ranges_for_codepoint_ranges(&codepoint_ranges).unwrap(); for (glyph_index, glyph_id) in glyph_ranges.iter().enumerate() { - glyph_buffer_builder.add_glyph(&font, glyph_id).unwrap(); - atlas_builder.pack_glyph(&glyph_buffer_builder, glyph_index as u32, point_size) - .unwrap() + outline_builder.add_glyph(&font, glyph_id).unwrap(); + atlas_builder.pack_glyph(&outline_builder, glyph_index as u32, point_size).unwrap() } } - let glyph_buffers = glyph_buffer_builder.create_buffers().unwrap(); - let atlas = atlas_builder.create_atlas(&glyph_buffer_builder).unwrap(); + let outline_buffers = outline_builder.create_buffers().unwrap(); + let atlas = atlas_builder.create_atlas(&outline_builder).unwrap(); let atlas_size = Size2D::new(device_pixel_width as GLuint, device_pixel_height as GLuint); let coverage_buffer = CoverageBuffer::new(&rasterizer.device, &atlas_size).unwrap(); @@ -85,7 +84,7 @@ fn main() { let rect = Rect::new(Point2D::new(0, 0), atlas_size); - rasterizer.draw_atlas(&image, &rect, &atlas, &glyph_buffers, &coverage_buffer).unwrap(); + rasterizer.draw_atlas(&image, &rect, &atlas, &outline_buffers, &coverage_buffer).unwrap(); rasterizer.queue.flush().unwrap(); let draw_context = lord_drawquaad::Context::new(); diff --git a/examples/lorem-ipsum.rs b/examples/lorem-ipsum.rs index a92d66c3..994ce388 100644 --- a/examples/lorem-ipsum.rs +++ b/examples/lorem-ipsum.rs @@ -22,9 +22,9 @@ use memmap::{Mmap, Protection}; use pathfinder::atlas::AtlasBuilder; use pathfinder::charmap::CodepointRange; use pathfinder::coverage::CoverageBuffer; -use pathfinder::glyph_buffer::{GlyphBufferBuilder, GlyphBuffers}; use pathfinder::glyph_range::GlyphRanges; use pathfinder::otf::Font; +use pathfinder::outline::{OutlineBuffers, OutlineBuilder}; use pathfinder::rasterizer::{DrawAtlasProfilingEvents, Rasterizer, RasterizerOptions}; use pathfinder::shaper; use std::env; @@ -107,23 +107,22 @@ fn main() { let mut translation = Point2D::new(0, 0); let mut dirty = true; - let mut glyph_buffer_builder = GlyphBufferBuilder::new(); + let mut outline_builder = OutlineBuilder::new(); let mut glyph_count = 0; for glyph_id in glyph_ranges.iter() { - glyph_buffer_builder.add_glyph(&font, glyph_id).unwrap(); + outline_builder.add_glyph(&font, glyph_id).unwrap(); glyph_count += 1 } - let glyph_buffers = glyph_buffer_builder.create_buffers().unwrap(); - let mut fps_atlas = renderer.create_fps_atlas(&glyph_buffer_builder, - &glyph_buffers, - glyph_count); + let outline_buffers = outline_builder.create_buffers().unwrap(); + + let mut fps_atlas = renderer.create_fps_atlas(&outline_builder, &outline_buffers, glyph_count); while !window.should_close() { if dirty { let events = renderer.redraw(point_size, - &glyph_buffer_builder, - &glyph_buffers, + &outline_builder, + &outline_buffers, glyph_count, &glyph_positions, &device_pixel_size, @@ -140,7 +139,7 @@ fn main() { renderer.draw_fps(&font, &mut fps_atlas, - &glyph_buffer_builder, + &outline_builder, &device_pixel_size, &glyph_ranges, draw_time, @@ -374,8 +373,8 @@ impl Renderer { fn redraw(&self, point_size: f32, - glyph_buffer_builder: &GlyphBufferBuilder, - glyph_buffers: &GlyphBuffers, + outline_builder: &OutlineBuilder, + outline_buffers: &OutlineBuffers, glyph_count: usize, glyph_positions: &[GlyphPos], device_pixel_size: &Size2D, @@ -386,17 +385,17 @@ impl Renderer { let mut atlas_builder = AtlasBuilder::new(ATLAS_SIZE, shelf_height); for glyph_index in 0..(glyph_count as u32) { - atlas_builder.pack_glyph(&glyph_buffer_builder, glyph_index, point_size).unwrap() + atlas_builder.pack_glyph(&outline_builder, glyph_index, point_size).unwrap() } - let atlas = atlas_builder.create_atlas(&glyph_buffer_builder).unwrap(); + let atlas = atlas_builder.create_atlas(&outline_builder).unwrap(); let rect = Rect::new(Point2D::new(0, 0), self.atlas_size); let events = self.rasterizer.draw_atlas(&self.main_compute_image, &rect, &atlas, - glyph_buffers, + outline_buffers, &self.coverage_buffer).unwrap(); self.rasterizer.queue.flush().unwrap(); @@ -410,7 +409,7 @@ impl Renderer { } self.draw_glyphs(&mut atlas_builder, - glyph_buffer_builder, + outline_builder, glyph_positions, device_pixel_size, translation, @@ -431,7 +430,7 @@ impl Renderer { fn draw_glyphs(&self, atlas_builder: &mut AtlasBuilder, - glyph_buffer_builder: &GlyphBufferBuilder, + outline_builder: &OutlineBuilder, glyph_positions: &[GlyphPos], device_pixel_size: &Size2D, translation: &Point2D, @@ -445,7 +444,7 @@ impl Renderer { gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, self.composite_index_buffer); let vertex_count = self.upload_quads_for_text(atlas_builder, - glyph_buffer_builder, + outline_builder, glyph_positions, point_size); @@ -482,7 +481,7 @@ impl Renderer { fn upload_quads_for_text(&self, atlas_builder: &mut AtlasBuilder, - glyph_buffer_builder: &GlyphBufferBuilder, + outline_builder: &OutlineBuilder, glyph_positions: &[GlyphPos], point_size: f32) -> usize { @@ -494,7 +493,7 @@ impl Renderer { None => continue, Some(glyph_index) => glyph_index, }; - let glyph_bounds = glyph_buffer_builder.glyph_bounds(glyph_index); + let glyph_bounds = outline_builder.glyph_bounds(glyph_index); let uv_rect = atlas_builder.atlas_rect(glyph_index); let (uv_bl, uv_tr) = (uv_rect.origin, uv_rect.bottom_right()); @@ -529,8 +528,8 @@ impl Renderer { } fn create_fps_atlas(&self, - glyph_buffer_builder: &GlyphBufferBuilder, - glyph_buffers: &GlyphBuffers, + outline_builder: &OutlineBuilder, + outline_buffers: &OutlineBuffers, glyph_count: usize) -> AtlasBuilder { // FIXME(pcwalton) @@ -538,18 +537,18 @@ impl Renderer { let mut atlas_builder = AtlasBuilder::new(ATLAS_SIZE, shelf_height); for glyph_index in 0..(glyph_count as u32) { - atlas_builder.pack_glyph(&glyph_buffer_builder, glyph_index, FPS_DISPLAY_POINT_SIZE) + atlas_builder.pack_glyph(&outline_builder, glyph_index, FPS_DISPLAY_POINT_SIZE) .unwrap() } - let atlas = atlas_builder.create_atlas(&glyph_buffer_builder).unwrap(); + let atlas = atlas_builder.create_atlas(&outline_builder).unwrap(); let rect = Rect::new(Point2D::new(0, 0), self.atlas_size); self.rasterizer.draw_atlas(&self.fps_compute_image, &rect, &atlas, - glyph_buffers, + outline_buffers, &self.coverage_buffer).unwrap(); atlas_builder @@ -558,7 +557,7 @@ impl Renderer { fn draw_fps(&self, font: &Font, atlas_builder: &mut AtlasBuilder, - glyph_buffer_builder: &GlyphBufferBuilder, + outline_builder: &OutlineBuilder, device_pixel_size: &Size2D, glyph_ranges: &GlyphRanges, draw_time: f64, @@ -615,7 +614,7 @@ impl Renderer { } self.draw_glyphs(atlas_builder, - glyph_buffer_builder, + outline_builder, &fps_glyphs, device_pixel_size, &Point2D::new(FPS_PADDING, device_pixel_size.height as i32 - FPS_PADDING), diff --git a/src/atlas.rs b/src/atlas.rs index c6311fa9..7ef3f444 100644 --- a/src/atlas.rs +++ b/src/atlas.rs @@ -11,7 +11,7 @@ use euclid::{Point2D, Rect, Size2D}; use gl::types::{GLenum, GLsizei, GLsizeiptr, GLuint, GLvoid}; use gl; -use glyph_buffer::GlyphBufferBuilder; +use outline::OutlineBuilder; use rect_packer::RectPacker; use std::mem; use std::os::raw::c_void; @@ -36,19 +36,19 @@ impl AtlasBuilder { /// FIXME(pcwalton): Support the same glyph drawn at multiple point sizes. pub fn pack_glyph(&mut self, - glyph_buffer_builder: &GlyphBufferBuilder, + outline_builder: &OutlineBuilder, glyph_index: u32, point_size: f32) -> Result<(), ()> { // FIXME(pcwalton): I think this will check for negative values and panic, which is // unnecessary. - let pixel_size = glyph_buffer_builder.glyph_pixel_bounds(glyph_index, point_size) - .size - .ceil() - .cast() - .unwrap(); + let pixel_size = outline_builder.glyph_pixel_bounds(glyph_index, point_size) + .size + .ceil() + .cast() + .unwrap(); - let glyph_id = glyph_buffer_builder.glyph_id(glyph_index); + let glyph_id = outline_builder.glyph_id(glyph_index); let atlas_origin = try!(self.rect_packer.pack(&pixel_size)); @@ -74,19 +74,18 @@ impl AtlasBuilder { Ok(()) } - pub fn create_atlas(&mut self, glyph_buffer_builder: &GlyphBufferBuilder) - -> Result { + pub fn create_atlas(&mut self, outline_builder: &OutlineBuilder) -> Result { self.image_metadata.sort_by(|a, b| a.glyph_index.cmp(&b.glyph_index)); let (mut current_range, mut counts, mut start_indices) = (None, vec![], vec![]); for image_metadata in &self.image_metadata { let glyph_index = image_metadata.glyph_index; - let first_index = glyph_buffer_builder.descriptors[glyph_index as usize].start_index as - usize; - let last_index = match glyph_buffer_builder.descriptors.get(glyph_index as usize + 1) { + let first_index = outline_builder.descriptors[glyph_index as usize] + .start_index as usize; + let last_index = match outline_builder.descriptors.get(glyph_index as usize + 1) { Some(ref descriptor) => descriptor.start_index as usize, - None => glyph_buffer_builder.indices.len(), + None => outline_builder.indices.len(), }; match current_range { diff --git a/src/lib.rs b/src/lib.rs index 962290a5..4783d16d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -27,9 +27,9 @@ extern crate test; pub mod atlas; pub mod charmap; pub mod coverage; -pub mod glyph_buffer; pub mod glyph_range; pub mod otf; +pub mod outline; pub mod rasterizer; pub mod rect_packer; pub mod shaper; diff --git a/src/otf/glyf.rs b/src/otf/glyf.rs index d3f252d2..7a6389b7 100644 --- a/src/otf/glyf.rs +++ b/src/otf/glyf.rs @@ -10,10 +10,10 @@ use byteorder::{BigEndian, ReadBytesExt}; use euclid::Point2D; -use glyph_buffer::GlyphBounds; use otf::FontTable; use otf::head::HeadTable; use otf::loca::LocaTable; +use outline::GlyphBounds; use std::mem; use util::Jump; diff --git a/src/otf/mod.rs b/src/otf/mod.rs index 15e573bc..fe92cf84 100644 --- a/src/otf/mod.rs +++ b/src/otf/mod.rs @@ -10,7 +10,6 @@ use byteorder::{BigEndian, ReadBytesExt}; use charmap::CodepointRange; -use glyph_buffer::GlyphBounds; use glyph_range::GlyphRanges; use otf::cmap::CmapTable; use otf::glyf::{GlyfTable, Point}; @@ -18,6 +17,7 @@ use otf::head::HeadTable; use otf::hhea::HheaTable; use otf::hmtx::{HmtxTable, HorizontalMetrics}; use otf::loca::LocaTable; +use outline::GlyphBounds; use std::mem; use std::u16; use util::Jump; diff --git a/src/glyph_buffer.rs b/src/outline.rs similarity index 95% rename from src/glyph_buffer.rs rename to src/outline.rs index 75bdde96..bdbde6e4 100644 --- a/src/glyph_buffer.rs +++ b/src/outline.rs @@ -21,16 +21,16 @@ static DUMMY_VERTEX: Vertex = Vertex { glyph_index: 0, }; -pub struct GlyphBufferBuilder { +pub struct OutlineBuilder { pub vertices: Vec, pub indices: Vec, pub descriptors: Vec, } -impl GlyphBufferBuilder { +impl OutlineBuilder { #[inline] - pub fn new() -> GlyphBufferBuilder { - GlyphBufferBuilder { + pub fn new() -> OutlineBuilder { + OutlineBuilder { vertices: vec![DUMMY_VERTEX], indices: vec![], descriptors: vec![], @@ -95,7 +95,7 @@ impl GlyphBufferBuilder { self.descriptors[glyph_index as usize].glyph_id } - pub fn create_buffers(&self) -> Result { + pub fn create_buffers(&self) -> Result { // TODO(pcwalton): Try using `glMapBuffer` here. Requires precomputing contour types and // counts. unsafe { @@ -123,7 +123,7 @@ impl GlyphBufferBuilder { self.descriptors.as_ptr() as *const GlyphDescriptor as *const c_void, gl::STATIC_DRAW); - Ok(GlyphBuffers { + Ok(OutlineBuffers { vertices: vertices, indices: indices, descriptors: descriptors, @@ -132,13 +132,13 @@ impl GlyphBufferBuilder { } } -pub struct GlyphBuffers { +pub struct OutlineBuffers { pub vertices: GLuint, pub indices: GLuint, pub descriptors: GLuint, } -impl Drop for GlyphBuffers { +impl Drop for OutlineBuffers { fn drop(&mut self) { unsafe { gl::DeleteBuffers(1, &mut self.descriptors); diff --git a/src/rasterizer.rs b/src/rasterizer.rs index dd979d3d..a9497b8c 100644 --- a/src/rasterizer.rs +++ b/src/rasterizer.rs @@ -19,7 +19,7 @@ use coverage::CoverageBuffer; use euclid::rect::Rect; use gl::types::{GLchar, GLenum, GLint, GLsizei, GLuint, GLvoid}; use gl; -use glyph_buffer::{GlyphBuffers, Vertex}; +use outline::{OutlineBuffers, Vertex}; use std::ascii::AsciiExt; use std::env; use std::mem; @@ -146,7 +146,7 @@ impl Rasterizer { image: &Image, rect: &Rect, atlas: &Atlas, - glyph_buffers: &GlyphBuffers, + outline_buffers: &OutlineBuffers, coverage_buffer: &CoverageBuffer) -> Result { unsafe { @@ -161,7 +161,7 @@ impl Rasterizer { gl::UseProgram(self.draw_program); // Set up the buffer layout. - gl::BindBuffer(gl::ARRAY_BUFFER, glyph_buffers.vertices); + gl::BindBuffer(gl::ARRAY_BUFFER, outline_buffers.vertices); gl::VertexAttribIPointer(self.draw_position_attribute as GLuint, 2, gl::SHORT, @@ -175,9 +175,9 @@ impl Rasterizer { gl::EnableVertexAttribArray(self.draw_position_attribute as GLuint); gl::EnableVertexAttribArray(self.draw_glyph_index_attribute as GLuint); - gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, glyph_buffers.indices); + gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, outline_buffers.indices); - gl::BindBufferBase(gl::UNIFORM_BUFFER, 1, glyph_buffers.descriptors); + gl::BindBufferBase(gl::UNIFORM_BUFFER, 1, outline_buffers.descriptors); gl::BindBufferBase(gl::UNIFORM_BUFFER, 2, atlas.images()); gl::UniformBlockBinding(self.draw_program, self.draw_glyph_descriptors_uniform, 1); gl::UniformBlockBinding(self.draw_program, self.draw_image_descriptors_uniform, 2); diff --git a/src/tests/buffers.rs b/src/tests/buffers.rs index d05e3425..50ec62b9 100644 --- a/src/tests/buffers.rs +++ b/src/tests/buffers.rs @@ -2,9 +2,9 @@ * http://creativecommons.org/publicdomain/zero/1.0/ */ use charmap::CodepointRange; -use glyph_buffer::GlyphBufferBuilder; use memmap::{Mmap, Protection}; use otf::Font; +use outline::OutlineBuilder; use test::Bencher; static TEST_FONT_PATH: &'static str = "resources/tests/nimbus-sans/NimbusSanL-Regu.ttf"; @@ -19,9 +19,9 @@ fn bench_add_glyphs(bencher: &mut Bencher) { .expect("Couldn't find glyph ranges"); bencher.iter(|| { - let mut glyph_buffer_builder = GlyphBufferBuilder::new(); + let mut outline_builder = OutlineBuilder::new(); for glyph_id in glyph_ranges.iter() { - glyph_buffer_builder.add_glyph(&font, glyph_id).unwrap() + outline_builder.add_glyph(&font, glyph_id).unwrap() } }); }