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::atlas::AtlasBuilder;
use pathfinder::charmap::CodepointRange; use pathfinder::charmap::CodepointRange;
use pathfinder::coverage::CoverageBuffer; use pathfinder::coverage::CoverageBuffer;
use pathfinder::glyph_buffer::GlyphBufferBuilder; use pathfinder::outline::OutlineBuilder;
use pathfinder::otf::Font; use pathfinder::otf::Font;
use pathfinder::rasterizer::{Rasterizer, RasterizerOptions}; use pathfinder::rasterizer::{Rasterizer, RasterizerOptions};
use std::env; use std::env;
@ -63,11 +63,11 @@ fn main() {
let mut results = vec![]; let mut results = vec![];
let start = time::precise_time_ns(); let start = time::precise_time_ns();
let mut last_time = start; 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); let (mut atlas_builder, mut atlas);
loop { loop {
glyph_buffer_builder = GlyphBufferBuilder::new(); outline_builder = OutlineBuilder::new();
atlas_builder = AtlasBuilder::new(device_pixel_width as GLuint, shelf_height); atlas_builder = AtlasBuilder::new(device_pixel_width as GLuint, shelf_height);
glyph_count = 0; glyph_count = 0;
unsafe { unsafe {
@ -77,8 +77,8 @@ fn main() {
let glyph_ranges = font.glyph_ranges_for_codepoint_ranges(&codepoint_ranges) let glyph_ranges = font.glyph_ranges_for_codepoint_ranges(&codepoint_ranges)
.unwrap(); .unwrap();
for (glyph_index, glyph_id) in glyph_ranges.iter().enumerate() { for (glyph_index, glyph_id) in glyph_ranges.iter().enumerate() {
glyph_buffer_builder.add_glyph(&font, glyph_id).unwrap(); outline_builder.add_glyph(&font, glyph_id).unwrap();
atlas_builder.pack_glyph(&glyph_buffer_builder, atlas_builder.pack_glyph(&outline_builder,
glyph_index as u32, glyph_index as u32,
point_size as f32).unwrap(); point_size as f32).unwrap();
glyph_count += 1 glyph_count += 1
@ -86,8 +86,8 @@ fn main() {
} }
glyph_buffers = glyph_buffer_builder.create_buffers().unwrap(); outline_buffers = outline_builder.create_buffers().unwrap();
atlas = atlas_builder.create_atlas(&glyph_buffer_builder).unwrap(); atlas = atlas_builder.create_atlas(&outline_builder).unwrap();
let end = time::precise_time_ns(); let end = time::precise_time_ns();
results.push((end - last_time) as f64); results.push((end - last_time) as f64);
@ -114,7 +114,7 @@ fn main() {
let start_time = time::precise_time_ns(); let start_time = time::precise_time_ns();
loop { loop {
let events = let events =
rasterizer.draw_atlas(&image, &rect, &atlas, &glyph_buffers, &coverage_buffer) rasterizer.draw_atlas(&image, &rect, &atlas, &outline_buffers, &coverage_buffer)
.unwrap(); .unwrap();
let mut draw_time = 0u64; 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::atlas::AtlasBuilder;
use pathfinder::charmap::CodepointRange; use pathfinder::charmap::CodepointRange;
use pathfinder::coverage::CoverageBuffer; use pathfinder::coverage::CoverageBuffer;
use pathfinder::glyph_buffer::GlyphBufferBuilder; use pathfinder::outline::OutlineBuilder;
use pathfinder::otf::Font; use pathfinder::otf::Font;
use pathfinder::rasterizer::{Rasterizer, RasterizerOptions}; use pathfinder::rasterizer::{Rasterizer, RasterizerOptions};
use std::env; use std::env;
@ -58,7 +58,7 @@ fn main() {
// FIXME(pcwalton) // FIXME(pcwalton)
let shelf_height = (point_size * 2.0).ceil() as u32; 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); let mut atlas_builder = AtlasBuilder::new(device_pixel_width as GLuint, shelf_height);
unsafe { unsafe {
@ -67,14 +67,13 @@ fn main() {
let glyph_ranges = font.glyph_ranges_for_codepoint_ranges(&codepoint_ranges).unwrap(); let glyph_ranges = font.glyph_ranges_for_codepoint_ranges(&codepoint_ranges).unwrap();
for (glyph_index, glyph_id) in glyph_ranges.iter().enumerate() { for (glyph_index, glyph_id) in glyph_ranges.iter().enumerate() {
glyph_buffer_builder.add_glyph(&font, glyph_id).unwrap(); outline_builder.add_glyph(&font, glyph_id).unwrap();
atlas_builder.pack_glyph(&glyph_buffer_builder, glyph_index as u32, point_size) atlas_builder.pack_glyph(&outline_builder, glyph_index as u32, point_size).unwrap()
.unwrap()
} }
} }
let glyph_buffers = glyph_buffer_builder.create_buffers().unwrap(); let outline_buffers = outline_builder.create_buffers().unwrap();
let atlas = atlas_builder.create_atlas(&glyph_buffer_builder).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 atlas_size = Size2D::new(device_pixel_width as GLuint, device_pixel_height as GLuint);
let coverage_buffer = CoverageBuffer::new(&rasterizer.device, &atlas_size).unwrap(); 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); 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(); rasterizer.queue.flush().unwrap();
let draw_context = lord_drawquaad::Context::new(); 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::atlas::AtlasBuilder;
use pathfinder::charmap::CodepointRange; use pathfinder::charmap::CodepointRange;
use pathfinder::coverage::CoverageBuffer; use pathfinder::coverage::CoverageBuffer;
use pathfinder::glyph_buffer::{GlyphBufferBuilder, GlyphBuffers};
use pathfinder::glyph_range::GlyphRanges; use pathfinder::glyph_range::GlyphRanges;
use pathfinder::otf::Font; use pathfinder::otf::Font;
use pathfinder::outline::{OutlineBuffers, OutlineBuilder};
use pathfinder::rasterizer::{DrawAtlasProfilingEvents, Rasterizer, RasterizerOptions}; use pathfinder::rasterizer::{DrawAtlasProfilingEvents, Rasterizer, RasterizerOptions};
use pathfinder::shaper; use pathfinder::shaper;
use std::env; use std::env;
@ -107,23 +107,22 @@ fn main() {
let mut translation = Point2D::new(0, 0); let mut translation = Point2D::new(0, 0);
let mut dirty = true; let mut dirty = true;
let mut glyph_buffer_builder = GlyphBufferBuilder::new(); let mut outline_builder = OutlineBuilder::new();
let mut glyph_count = 0; let mut glyph_count = 0;
for glyph_id in glyph_ranges.iter() { 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 glyph_count += 1
} }
let glyph_buffers = glyph_buffer_builder.create_buffers().unwrap();
let mut fps_atlas = renderer.create_fps_atlas(&glyph_buffer_builder, let outline_buffers = outline_builder.create_buffers().unwrap();
&glyph_buffers,
glyph_count); let mut fps_atlas = renderer.create_fps_atlas(&outline_builder, &outline_buffers, glyph_count);
while !window.should_close() { while !window.should_close() {
if dirty { if dirty {
let events = renderer.redraw(point_size, let events = renderer.redraw(point_size,
&glyph_buffer_builder, &outline_builder,
&glyph_buffers, &outline_buffers,
glyph_count, glyph_count,
&glyph_positions, &glyph_positions,
&device_pixel_size, &device_pixel_size,
@ -140,7 +139,7 @@ fn main() {
renderer.draw_fps(&font, renderer.draw_fps(&font,
&mut fps_atlas, &mut fps_atlas,
&glyph_buffer_builder, &outline_builder,
&device_pixel_size, &device_pixel_size,
&glyph_ranges, &glyph_ranges,
draw_time, draw_time,
@ -374,8 +373,8 @@ impl Renderer {
fn redraw(&self, fn redraw(&self,
point_size: f32, point_size: f32,
glyph_buffer_builder: &GlyphBufferBuilder, outline_builder: &OutlineBuilder,
glyph_buffers: &GlyphBuffers, outline_buffers: &OutlineBuffers,
glyph_count: usize, glyph_count: usize,
glyph_positions: &[GlyphPos], glyph_positions: &[GlyphPos],
device_pixel_size: &Size2D<u32>, device_pixel_size: &Size2D<u32>,
@ -386,17 +385,17 @@ impl Renderer {
let mut atlas_builder = AtlasBuilder::new(ATLAS_SIZE, shelf_height); let mut atlas_builder = AtlasBuilder::new(ATLAS_SIZE, shelf_height);
for glyph_index in 0..(glyph_count as u32) { 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 rect = Rect::new(Point2D::new(0, 0), self.atlas_size);
let events = self.rasterizer.draw_atlas(&self.main_compute_image, let events = self.rasterizer.draw_atlas(&self.main_compute_image,
&rect, &rect,
&atlas, &atlas,
glyph_buffers, outline_buffers,
&self.coverage_buffer).unwrap(); &self.coverage_buffer).unwrap();
self.rasterizer.queue.flush().unwrap(); self.rasterizer.queue.flush().unwrap();
@ -410,7 +409,7 @@ impl Renderer {
} }
self.draw_glyphs(&mut atlas_builder, self.draw_glyphs(&mut atlas_builder,
glyph_buffer_builder, outline_builder,
glyph_positions, glyph_positions,
device_pixel_size, device_pixel_size,
translation, translation,
@ -431,7 +430,7 @@ impl Renderer {
fn draw_glyphs(&self, fn draw_glyphs(&self,
atlas_builder: &mut AtlasBuilder, atlas_builder: &mut AtlasBuilder,
glyph_buffer_builder: &GlyphBufferBuilder, outline_builder: &OutlineBuilder,
glyph_positions: &[GlyphPos], glyph_positions: &[GlyphPos],
device_pixel_size: &Size2D<u32>, device_pixel_size: &Size2D<u32>,
translation: &Point2D<i32>, translation: &Point2D<i32>,
@ -445,7 +444,7 @@ impl Renderer {
gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, self.composite_index_buffer); gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, self.composite_index_buffer);
let vertex_count = self.upload_quads_for_text(atlas_builder, let vertex_count = self.upload_quads_for_text(atlas_builder,
glyph_buffer_builder, outline_builder,
glyph_positions, glyph_positions,
point_size); point_size);
@ -482,7 +481,7 @@ impl Renderer {
fn upload_quads_for_text(&self, fn upload_quads_for_text(&self,
atlas_builder: &mut AtlasBuilder, atlas_builder: &mut AtlasBuilder,
glyph_buffer_builder: &GlyphBufferBuilder, outline_builder: &OutlineBuilder,
glyph_positions: &[GlyphPos], glyph_positions: &[GlyphPos],
point_size: f32) point_size: f32)
-> usize { -> usize {
@ -494,7 +493,7 @@ impl Renderer {
None => continue, None => continue,
Some(glyph_index) => glyph_index, 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_rect = atlas_builder.atlas_rect(glyph_index);
let (uv_bl, uv_tr) = (uv_rect.origin, uv_rect.bottom_right()); let (uv_bl, uv_tr) = (uv_rect.origin, uv_rect.bottom_right());
@ -529,8 +528,8 @@ impl Renderer {
} }
fn create_fps_atlas(&self, fn create_fps_atlas(&self,
glyph_buffer_builder: &GlyphBufferBuilder, outline_builder: &OutlineBuilder,
glyph_buffers: &GlyphBuffers, outline_buffers: &OutlineBuffers,
glyph_count: usize) glyph_count: usize)
-> AtlasBuilder { -> AtlasBuilder {
// FIXME(pcwalton) // FIXME(pcwalton)
@ -538,18 +537,18 @@ impl Renderer {
let mut atlas_builder = AtlasBuilder::new(ATLAS_SIZE, shelf_height); let mut atlas_builder = AtlasBuilder::new(ATLAS_SIZE, shelf_height);
for glyph_index in 0..(glyph_count as u32) { 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() .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 rect = Rect::new(Point2D::new(0, 0), self.atlas_size);
self.rasterizer.draw_atlas(&self.fps_compute_image, self.rasterizer.draw_atlas(&self.fps_compute_image,
&rect, &rect,
&atlas, &atlas,
glyph_buffers, outline_buffers,
&self.coverage_buffer).unwrap(); &self.coverage_buffer).unwrap();
atlas_builder atlas_builder
@ -558,7 +557,7 @@ impl Renderer {
fn draw_fps(&self, fn draw_fps(&self,
font: &Font, font: &Font,
atlas_builder: &mut AtlasBuilder, atlas_builder: &mut AtlasBuilder,
glyph_buffer_builder: &GlyphBufferBuilder, outline_builder: &OutlineBuilder,
device_pixel_size: &Size2D<u32>, device_pixel_size: &Size2D<u32>,
glyph_ranges: &GlyphRanges, glyph_ranges: &GlyphRanges,
draw_time: f64, draw_time: f64,
@ -615,7 +614,7 @@ impl Renderer {
} }
self.draw_glyphs(atlas_builder, self.draw_glyphs(atlas_builder,
glyph_buffer_builder, outline_builder,
&fps_glyphs, &fps_glyphs,
device_pixel_size, device_pixel_size,
&Point2D::new(FPS_PADDING, device_pixel_size.height as i32 - FPS_PADDING), &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 euclid::{Point2D, Rect, Size2D};
use gl::types::{GLenum, GLsizei, GLsizeiptr, GLuint, GLvoid}; use gl::types::{GLenum, GLsizei, GLsizeiptr, GLuint, GLvoid};
use gl; use gl;
use glyph_buffer::GlyphBufferBuilder; use outline::OutlineBuilder;
use rect_packer::RectPacker; use rect_packer::RectPacker;
use std::mem; use std::mem;
use std::os::raw::c_void; use std::os::raw::c_void;
@ -36,19 +36,19 @@ impl AtlasBuilder {
/// FIXME(pcwalton): Support the same glyph drawn at multiple point sizes. /// FIXME(pcwalton): Support the same glyph drawn at multiple point sizes.
pub fn pack_glyph(&mut self, pub fn pack_glyph(&mut self,
glyph_buffer_builder: &GlyphBufferBuilder, outline_builder: &OutlineBuilder,
glyph_index: u32, glyph_index: u32,
point_size: f32) point_size: f32)
-> Result<(), ()> { -> Result<(), ()> {
// FIXME(pcwalton): I think this will check for negative values and panic, which is // FIXME(pcwalton): I think this will check for negative values and panic, which is
// unnecessary. // unnecessary.
let pixel_size = glyph_buffer_builder.glyph_pixel_bounds(glyph_index, point_size) let pixel_size = outline_builder.glyph_pixel_bounds(glyph_index, point_size)
.size .size
.ceil() .ceil()
.cast() .cast()
.unwrap(); .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)); let atlas_origin = try!(self.rect_packer.pack(&pixel_size));
@ -74,19 +74,18 @@ impl AtlasBuilder {
Ok(()) Ok(())
} }
pub fn create_atlas(&mut self, glyph_buffer_builder: &GlyphBufferBuilder) pub fn create_atlas(&mut self, outline_builder: &OutlineBuilder) -> Result<Atlas, ()> {
-> Result<Atlas, ()> {
self.image_metadata.sort_by(|a, b| a.glyph_index.cmp(&b.glyph_index)); 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![]); let (mut current_range, mut counts, mut start_indices) = (None, vec![], vec![]);
for image_metadata in &self.image_metadata { for image_metadata in &self.image_metadata {
let glyph_index = image_metadata.glyph_index; let glyph_index = image_metadata.glyph_index;
let first_index = glyph_buffer_builder.descriptors[glyph_index as usize].start_index as let first_index = outline_builder.descriptors[glyph_index as usize]
usize; .start_index as usize;
let last_index = match glyph_buffer_builder.descriptors.get(glyph_index as usize + 1) { let last_index = match outline_builder.descriptors.get(glyph_index as usize + 1) {
Some(ref descriptor) => descriptor.start_index as usize, Some(ref descriptor) => descriptor.start_index as usize,
None => glyph_buffer_builder.indices.len(), None => outline_builder.indices.len(),
}; };
match current_range { match current_range {

2
src/lib.rs
View File

@ -27,9 +27,9 @@ extern crate test;
pub mod atlas; pub mod atlas;
pub mod charmap; pub mod charmap;
pub mod coverage; pub mod coverage;
pub mod glyph_buffer;
pub mod glyph_range; pub mod glyph_range;
pub mod otf; pub mod otf;
pub mod outline;
pub mod rasterizer; pub mod rasterizer;
pub mod rect_packer; pub mod rect_packer;
pub mod shaper; pub mod shaper;

2
src/otf/glyf.rs
View File

@ -10,10 +10,10 @@
use byteorder::{BigEndian, ReadBytesExt}; use byteorder::{BigEndian, ReadBytesExt};
use euclid::Point2D; use euclid::Point2D;
use glyph_buffer::GlyphBounds;
use otf::FontTable; use otf::FontTable;
use otf::head::HeadTable; use otf::head::HeadTable;
use otf::loca::LocaTable; use otf::loca::LocaTable;
use outline::GlyphBounds;
use std::mem; use std::mem;
use util::Jump; use util::Jump;

2
src/otf/mod.rs
View File

@ -10,7 +10,6 @@
use byteorder::{BigEndian, ReadBytesExt}; use byteorder::{BigEndian, ReadBytesExt};
use charmap::CodepointRange; use charmap::CodepointRange;
use glyph_buffer::GlyphBounds;
use glyph_range::GlyphRanges; use glyph_range::GlyphRanges;
use otf::cmap::CmapTable; use otf::cmap::CmapTable;
use otf::glyf::{GlyfTable, Point}; use otf::glyf::{GlyfTable, Point};
@ -18,6 +17,7 @@ use otf::head::HeadTable;
use otf::hhea::HheaTable; use otf::hhea::HheaTable;
use otf::hmtx::{HmtxTable, HorizontalMetrics}; use otf::hmtx::{HmtxTable, HorizontalMetrics};
use otf::loca::LocaTable; use otf::loca::LocaTable;
use outline::GlyphBounds;
use std::mem; use std::mem;
use std::u16; use std::u16;
use util::Jump; 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, glyph_index: 0,
}; };
pub struct GlyphBufferBuilder { pub struct OutlineBuilder {
pub vertices: Vec<Vertex>, pub vertices: Vec<Vertex>,
pub indices: Vec<u32>, pub indices: Vec<u32>,
pub descriptors: Vec<GlyphDescriptor>, pub descriptors: Vec<GlyphDescriptor>,
} }
impl GlyphBufferBuilder { impl OutlineBuilder {
#[inline] #[inline]
pub fn new() -> GlyphBufferBuilder { pub fn new() -> OutlineBuilder {
GlyphBufferBuilder { OutlineBuilder {
vertices: vec![DUMMY_VERTEX], vertices: vec![DUMMY_VERTEX],
indices: vec![], indices: vec![],
descriptors: vec![], descriptors: vec![],
@ -95,7 +95,7 @@ impl GlyphBufferBuilder {
self.descriptors[glyph_index as usize].glyph_id 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 // TODO(pcwalton): Try using `glMapBuffer` here. Requires precomputing contour types and
// counts. // counts.
unsafe { unsafe {
@ -123,7 +123,7 @@ impl GlyphBufferBuilder {
self.descriptors.as_ptr() as *const GlyphDescriptor as *const c_void, self.descriptors.as_ptr() as *const GlyphDescriptor as *const c_void,
gl::STATIC_DRAW); gl::STATIC_DRAW);
Ok(GlyphBuffers { Ok(OutlineBuffers {
vertices: vertices, vertices: vertices,
indices: indices, indices: indices,
descriptors: descriptors, descriptors: descriptors,
@ -132,13 +132,13 @@ impl GlyphBufferBuilder {
} }
} }
pub struct GlyphBuffers { pub struct OutlineBuffers {
pub vertices: GLuint, pub vertices: GLuint,
pub indices: GLuint, pub indices: GLuint,
pub descriptors: GLuint, pub descriptors: GLuint,
} }
impl Drop for GlyphBuffers { impl Drop for OutlineBuffers {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
gl::DeleteBuffers(1, &mut self.descriptors); gl::DeleteBuffers(1, &mut self.descriptors);

10
src/rasterizer.rs
View File

@ -19,7 +19,7 @@ use coverage::CoverageBuffer;
use euclid::rect::Rect; use euclid::rect::Rect;
use gl::types::{GLchar, GLenum, GLint, GLsizei, GLuint, GLvoid}; use gl::types::{GLchar, GLenum, GLint, GLsizei, GLuint, GLvoid};
use gl; use gl;
use glyph_buffer::{GlyphBuffers, Vertex}; use outline::{OutlineBuffers, Vertex};
use std::ascii::AsciiExt; use std::ascii::AsciiExt;
use std::env; use std::env;
use std::mem; use std::mem;
@ -146,7 +146,7 @@ impl Rasterizer {
image: &Image, image: &Image,
rect: &Rect<u32>, rect: &Rect<u32>,
atlas: &Atlas, atlas: &Atlas,
glyph_buffers: &GlyphBuffers, outline_buffers: &OutlineBuffers,
coverage_buffer: &CoverageBuffer) coverage_buffer: &CoverageBuffer)
-> Result<DrawAtlasProfilingEvents, ()> { -> Result<DrawAtlasProfilingEvents, ()> {
unsafe { unsafe {
@ -161,7 +161,7 @@ impl Rasterizer {
gl::UseProgram(self.draw_program); gl::UseProgram(self.draw_program);
// Set up the buffer layout. // 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, gl::VertexAttribIPointer(self.draw_position_attribute as GLuint,
2, 2,
gl::SHORT, gl::SHORT,
@ -175,9 +175,9 @@ impl Rasterizer {
gl::EnableVertexAttribArray(self.draw_position_attribute as GLuint); gl::EnableVertexAttribArray(self.draw_position_attribute as GLuint);
gl::EnableVertexAttribArray(self.draw_glyph_index_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::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_glyph_descriptors_uniform, 1);
gl::UniformBlockBinding(self.draw_program, self.draw_image_descriptors_uniform, 2); 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/ */ * http://creativecommons.org/publicdomain/zero/1.0/ */
use charmap::CodepointRange; use charmap::CodepointRange;
use glyph_buffer::GlyphBufferBuilder;
use memmap::{Mmap, Protection}; use memmap::{Mmap, Protection};
use otf::Font; use otf::Font;
use outline::OutlineBuilder;
use test::Bencher; use test::Bencher;
static TEST_FONT_PATH: &'static str = "resources/tests/nimbus-sans/NimbusSanL-Regu.ttf"; 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"); .expect("Couldn't find glyph ranges");
bencher.iter(|| { bencher.iter(|| {
let mut glyph_buffer_builder = GlyphBufferBuilder::new(); let mut outline_builder = OutlineBuilder::new();
for glyph_id in glyph_ranges.iter() { for glyph_id in glyph_ranges.iter() {
glyph_buffer_builder.add_glyph(&font, glyph_id).unwrap() outline_builder.add_glyph(&font, glyph_id).unwrap()
} }
}); });
} }