michael/pathfinder
michael
/
pathfinder
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Rename "glyph buffer" to "outline", since "glyph" is ambiguous

This commit is contained in:
Patrick Walton 2017-02-03 17:18:05 -08:00
parent d5be9e1f16
commit 23fa035178
10 changed files with 73 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
examples/benchmark.rs
View File

@ -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;

15
examples/generate-atlas.rs
View File

@ -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();

53
examples/lorem-ipsum.rs
View File

@ -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<u32>,
@ -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<u32>,
translation: &Point2D<i32>,
@ -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<u32>,
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),

27
src/atlas.rs
View File

@ -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<Atlas, ()> {
pub fn create_atlas(&mut self, outline_builder: &OutlineBuilder) -> Result<Atlas, ()> {
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 {

2
src/lib.rs
View File

@ -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;

2
src/otf/glyf.rs
View File

@ -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;

2
src/otf/mod.rs
View File

@ -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;

16
src/glyph_buffer.rs → src/outline.rs
View File

@ -21,16 +21,16 @@ static DUMMY_VERTEX: Vertex = Vertex {
glyph_index: 0,
};
pub struct GlyphBufferBuilder {
pub struct OutlineBuilder {
pub vertices: Vec<Vertex>,
pub indices: Vec<u32>,
pub descriptors: Vec<GlyphDescriptor>,
}
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<GlyphBuffers, ()> {
pub fn create_buffers(&self) -> Result<OutlineBuffers, ()> {
// 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);

10
src/rasterizer.rs
View File

@ -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<u32>,
atlas: &Atlas,
glyph_buffers: &GlyphBuffers,
outline_buffers: &OutlineBuffers,
coverage_buffer: &CoverageBuffer)
-> Result<DrawAtlasProfilingEvents, ()> {
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);

6
src/tests/buffers.rs
View File

@ -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()
}
});
}