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

Fix up examples and tests

This commit is contained in:
Patrick Walton 2017-02-02 16:40:46 -08:00
parent c41cd1f150
commit 3fb592e05a
12 changed files with 61 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
examples/benchmark.rs
View File

@ -13,8 +13,8 @@ extern crate time;
use bencher::stats::{self, Stats};
use compute_shader::buffer;
use compute_shader::image::Format;
use compute_shader::instance::Instance;
use compute_shader::texture::Format;
use euclid::{Point2D, Rect, Size2D};
use gl::types::GLuint;
use glfw::{Context, OpenGlProfileHint, WindowHint, WindowMode};
@ -104,11 +104,9 @@ fn main() {
let atlas_size = Size2D::new(ATLAS_SIZE, ATLAS_SIZE);
let coverage_buffer = CoverageBuffer::new(&rasterizer.device, &atlas_size).unwrap();
let texture = rasterizer.device
.create_texture(Format::R8,
buffer::Protection::WriteOnly,
&atlas_size)
.unwrap();
let image = rasterizer.device
.create_image(Format::R8, buffer::Protection::WriteOnly, &atlas_size)
.unwrap();
let mut results = vec![];
let start_time = time::precise_time_ns();
@ -118,7 +116,7 @@ fn main() {
&glyph_buffers,
&batch,
&coverage_buffer,
&texture).unwrap();
&image).unwrap();
let mut draw_time = 0u64;
unsafe {

9
examples/dump-outlines.rs
View File

@ -7,7 +7,6 @@ extern crate pathfinder;
use euclid::Point2D;
use memmap::{Mmap, Protection};
use pathfinder::batch::GlyphRange;
use pathfinder::charmap::CodepointRange;
use pathfinder::otf::Font;
use std::char;
@ -19,10 +18,8 @@ fn main() {
let font = Font::new(file.as_slice()).unwrap();
let codepoint_ranges = [CodepointRange::new('!' as u32, '~' as u32)];
let glyph_ranges = font.cmap.glyph_ranges_for_codepoint_ranges(&codepoint_ranges).unwrap();
for (codepoint, glyph_id) in
codepoint_ranges.iter()
.flat_map(CodepointRange::iter)
.zip(glyph_ranges.iter().flat_map(GlyphRange::iter)) {
for (glyph_index, glyph_id) in glyph_ranges.iter().enumerate() {
let codepoint = '!' as u32 + glyph_index as u32;
println!("Glyph {}: codepoint {} '{}':",
glyph_id,
codepoint,
@ -32,7 +29,7 @@ fn main() {
let mut last_point_was_off_curve = false;
font.glyf.as_ref().unwrap().for_each_point(&font.head,
font.loca.as_ref().unwrap(),
glyph_id as u32,
glyph_id,
|point| {
if point.first_point_in_contour {
println!("M {},{}", point.position.x, point.position.y);

14
examples/generate-atlas.rs
View File

@ -10,8 +10,8 @@ extern crate memmap;
extern crate pathfinder;
use compute_shader::buffer;
use compute_shader::image::{ExternalImage, Format};
use compute_shader::instance::Instance;
use compute_shader::texture::{ExternalTexture, Format};
use euclid::{Point2D, Rect, Size2D};
use gl::types::{GLint, GLuint};
use glfw::{Action, Context, Key, OpenGlProfileHint, WindowEvent, WindowHint, WindowMode};
@ -65,28 +65,28 @@ fn main() {
}
let glyph_buffers = glyph_buffer_builder.create_buffers().unwrap();
let batch = batch_builder.create_batch(buffer_builder).unwrap();
let batch = batch_builder.create_batch(&glyph_buffer_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();
let texture = rasterizer.device
.create_texture(Format::R8, buffer::Protection::WriteOnly, &atlas_size)
.unwrap();
let image = rasterizer.device
.create_image(Format::R8, buffer::Protection::WriteOnly, &atlas_size)
.unwrap();
rasterizer.draw_atlas(&Rect::new(Point2D::new(0, 0), atlas_size),
&batch_builder.atlas,
&glyph_buffers,
&batch,
&coverage_buffer,
&texture).unwrap();
&image).unwrap();
let draw_context = lord_drawquaad::Context::new();
let mut gl_texture = 0;
unsafe {
gl::GenTextures(1, &mut gl_texture);
texture.bind_to(&ExternalTexture::Gl(gl_texture)).unwrap();
image.bind_to(&ExternalImage::GlTexture(gl_texture)).unwrap();
gl::BindTexture(gl::TEXTURE_RECTANGLE, gl_texture);
gl::TexParameteri(gl::TEXTURE_RECTANGLE, gl::TEXTURE_MIN_FILTER, gl::LINEAR as GLint);

30
examples/lorem-ipsum.rs
View File

@ -13,8 +13,8 @@ extern crate memmap;
extern crate pathfinder;
use compute_shader::buffer;
use compute_shader::image::{ExternalImage, Format, Image};
use compute_shader::instance::Instance;
use compute_shader::texture::{ExternalTexture, Format, Texture};
use euclid::{Point2D, Rect, Size2D};
use gl::types::{GLchar, GLint, GLsizei, GLsizeiptr, GLuint, GLvoid};
use glfw::{Action, Context, Key, OpenGlProfileHint, WindowEvent, WindowHint, WindowMode};
@ -227,9 +227,9 @@ struct Renderer {
atlas_size: Size2D<u32>,
coverage_buffer: CoverageBuffer,
main_compute_texture: Texture,
main_compute_image: Image,
main_gl_texture: GLuint,
fps_compute_texture: Texture,
fps_compute_image: Image,
fps_gl_texture: GLuint,
query: GLuint,
@ -332,8 +332,8 @@ impl Renderer {
let coverage_buffer = CoverageBuffer::new(&rasterizer.device, &atlas_size).unwrap();
let (main_compute_texture, main_gl_texture) = create_texture(&rasterizer, &atlas_size);
let (fps_compute_texture, fps_gl_texture) = create_texture(&rasterizer, &atlas_size);
let (main_compute_image, main_gl_texture) = create_image(&rasterizer, &atlas_size);
let (fps_compute_image, fps_gl_texture) = create_image(&rasterizer, &atlas_size);
let mut query = 0;
unsafe {
@ -363,9 +363,9 @@ impl Renderer {
atlas_size: atlas_size,
coverage_buffer: coverage_buffer,
main_compute_texture: main_compute_texture,
main_compute_image: main_compute_image,
main_gl_texture: main_gl_texture,
fps_compute_texture: fps_compute_texture,
fps_compute_image: fps_compute_image,
fps_gl_texture: fps_gl_texture,
query: query,
@ -395,7 +395,7 @@ impl Renderer {
glyph_buffers,
&batch,
&self.coverage_buffer,
&self.main_compute_texture).unwrap();
&self.main_compute_image).unwrap();
self.rasterizer.queue.flush().unwrap();
unsafe {
@ -547,7 +547,7 @@ impl Renderer {
glyph_buffers,
&batch,
&self.coverage_buffer,
&self.fps_compute_texture).unwrap();
&self.fps_compute_image).unwrap();
batch_builder
}
@ -702,15 +702,15 @@ fn create_program(vertex_shader_source: &str, fragment_shader_source: &str) -> G
}
}
fn create_texture(rasterizer: &Rasterizer, atlas_size: &Size2D<u32>) -> (Texture, GLuint) {
let compute_texture = rasterizer.device.create_texture(Format::R8,
buffer::Protection::WriteOnly,
&atlas_size).unwrap();
fn create_image(rasterizer: &Rasterizer, atlas_size: &Size2D<u32>) -> (Image, GLuint) {
let compute_image = rasterizer.device.create_image(Format::R8,
buffer::Protection::WriteOnly,
&atlas_size).unwrap();
let mut gl_texture = 0;
unsafe {
gl::GenTextures(1, &mut gl_texture);
compute_texture.bind_to(&ExternalTexture::Gl(gl_texture)).unwrap();
compute_image.bind_to(&ExternalImage::GlTexture(gl_texture)).unwrap();
gl::BindTexture(gl::TEXTURE_RECTANGLE, gl_texture);
gl::TexParameteri(gl::TEXTURE_RECTANGLE, gl::TEXTURE_MIN_FILTER, gl::LINEAR as GLint);
@ -719,7 +719,7 @@ fn create_texture(rasterizer: &Rasterizer, atlas_size: &Size2D<u32>) -> (Texture
gl::TexParameteri(gl::TEXTURE_RECTANGLE, gl::TEXTURE_WRAP_T, gl::CLAMP_TO_EDGE as GLint);
}
(compute_texture, gl_texture)
(compute_image, gl_texture)
}
static COMPOSITE_VERTEX_SHADER: &'static str = "\

4
resources/shaders/accum.cl
View File

@ -16,7 +16,7 @@
const sampler_t SAMPLER = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
__kernel void accum(__write_only image2d_t gTexture,
__kernel void accum(__write_only image2d_t gImage,
__read_only image2d_t gCoverage,
uint4 kAtlasRect,
uint kAtlasShelfHeight) {
@ -32,7 +32,7 @@ __kernel void accum(__write_only image2d_t gTexture,
coverage += read_imagef(gCoverage, SAMPLER, coord).r;
uint gray = convert_uint(clamp(coverage, 0.0f, 1.0f) * 255.0f);
write_imageui(gTexture, coord + (int2)kAtlasRect.xy, (uint4)(gray, 255, 255, 255));
write_imageui(gImage, coord + (int2)kAtlasRect.xy, (uint4)(gray, 255, 255, 255));
}
}

4
resources/shaders/accum.cs.glsl
View File

@ -22,7 +22,7 @@
layout(local_size_x = 1024) in;
uniform restrict writeonly uimage2DRect uTexture;
uniform restrict writeonly uimage2DRect uImage;
uniform sampler2DRect uCoverage;
uniform uvec4 uAtlasRect;
uniform uint uAtlasShelfHeight;
@ -42,6 +42,6 @@ void main() {
coverage += texelFetch(uCoverage, coord).r;
uint gray = uint(clamp(coverage, 0.0f, 1.0f) * 255.0f);
imageStore(uTexture, coord + ivec2(uAtlasRect.xy), uvec4(gray, 255, 255, 255));
imageStore(uImage, coord + ivec2(uAtlasRect.xy), uvec4(gray, 255, 255, 255));
}
}

2
resources/shaders/draw.vs.glsl
View File

@ -18,7 +18,7 @@
#define IMAGE_DESCRIPTOR_POINT_SIZE(d) (d).z
// Information about the metrics of each glyph.
layout(std140) struct GlyphDescriptor {
struct GlyphDescriptor {
// The left/bottom/right/top offsets of the glyph from point (0, 0) in glyph space.
ivec4 extents;
// x: Units per em.

12
src/coverage.rs
View File

@ -10,26 +10,26 @@
use compute_shader::buffer::Protection;
use compute_shader::device::Device;
use compute_shader::texture::{ExternalTexture, Format, Texture};
use compute_shader::image::{ExternalImage, Format, Image};
use euclid::size::Size2D;
use gl::types::{GLint, GLuint};
use gl;
pub struct CoverageBuffer {
pub texture: Texture,
pub image: Image,
pub framebuffer: GLuint,
}
impl CoverageBuffer {
pub fn new(device: &Device, size: &Size2D<u32>) -> Result<CoverageBuffer, ()> {
let texture = try!(device.create_texture(Format::R32F, Protection::ReadWrite, size)
.map_err(drop));
let image = try!(device.create_image(Format::R32F, Protection::ReadWrite, size)
.map_err(drop));
let mut framebuffer = 0;
unsafe {
let mut gl_texture = 0;
gl::GenTextures(1, &mut gl_texture);
try!(texture.bind_to(&ExternalTexture::Gl(gl_texture)).map_err(drop));
try!(image.bind_to(&ExternalImage::GlTexture(gl_texture)).map_err(drop));
gl::BindTexture(gl::TEXTURE_RECTANGLE, gl_texture);
gl::TexParameteri(gl::TEXTURE_RECTANGLE, gl::TEXTURE_MIN_FILTER, gl::LINEAR as GLint);
@ -52,7 +52,7 @@ impl CoverageBuffer {
}
Ok(CoverageBuffer {
texture: texture,
image: image,
framebuffer: framebuffer,
})
}

10
src/otf/cmap.rs
View File

@ -82,12 +82,12 @@ impl<'a> CmapTable<'a> {
}
// Read the mapping table header.
let length = try!(cmap_reader.read_u16::<BigEndian>().map_err(drop));
let language = try!(cmap_reader.read_u16::<BigEndian>().map_err(drop));
let _length = try!(cmap_reader.read_u16::<BigEndian>().map_err(drop));
let _language = try!(cmap_reader.read_u16::<BigEndian>().map_err(drop));
let seg_count = try!(cmap_reader.read_u16::<BigEndian>().map_err(drop)) / 2;
let search_range = try!(cmap_reader.read_u16::<BigEndian>().map_err(drop));
let entry_selector = try!(cmap_reader.read_u16::<BigEndian>().map_err(drop));
let range_shift = try!(cmap_reader.read_u16::<BigEndian>().map_err(drop));
let _search_range = try!(cmap_reader.read_u16::<BigEndian>().map_err(drop));
let _entry_selector = try!(cmap_reader.read_u16::<BigEndian>().map_err(drop));
let _range_shift = try!(cmap_reader.read_u16::<BigEndian>().map_err(drop));
// Set up parallel array pointers.
//

8
src/rasterizer.rs
View File

@ -11,11 +11,11 @@
use atlas::Atlas;
use batch::Batch;
use compute_shader::device::Device;
use compute_shader::image::Image;
use compute_shader::instance::{Instance, ShadingLanguage};
use compute_shader::profile_event::ProfileEvent;
use compute_shader::program::Program;
use compute_shader::queue::{Queue, Uniform};
use compute_shader::texture::Texture;
use coverage::CoverageBuffer;
use euclid::rect::Rect;
use gl::types::{GLchar, GLenum, GLint, GLsizei, GLuint, GLvoid};
@ -149,7 +149,7 @@ impl Rasterizer {
glyph_buffers: &GlyphBuffers,
batch: &Batch,
coverage_buffer: &CoverageBuffer,
texture: &Texture)
image: &Image)
-> Result<DrawAtlasProfilingEvents, ()> {
unsafe {
gl::BindFramebuffer(gl::FRAMEBUFFER, coverage_buffer.framebuffer);
@ -237,8 +237,8 @@ impl Rasterizer {
];
let accum_uniforms = [
(0, Uniform::Texture(texture)),
(1, Uniform::Texture(&coverage_buffer.texture)),
(0, Uniform::Image(image)),
(1, Uniform::Image(&coverage_buffer.image)),
(2, Uniform::UVec4(atlas_rect_uniform)),
(3, Uniform::U32(atlas.shelf_height())),
];

6
src/tests/atlas.rs
View File

@ -10,9 +10,9 @@ fn place_objects(available_width: u32, objects: Vec<(u32, u32)>) -> (Atlas, Vec<
.map(|&(width, height)| Size2D::new(width, height))
.collect();
let available_width = cmp::max(available_width,
objects.iter().map(|object| object.width).max().unwrap_or(0));
let shelf_height = objects.iter().map(|object| object.height).max().unwrap_or(0);
let available_width = 2 +
cmp::max(available_width, objects.iter().map(|object| object.width).max().unwrap_or(0));
let shelf_height = objects.iter().map(|object| object.height).max().unwrap_or(0) + 2;
let mut atlas = Atlas::new(available_width, shelf_height);
let rects = objects.iter()

20
src/tests/buffers.rs
View File

@ -1,11 +1,10 @@
/* Any copyright is dedicated to the Public Domain.
* http://creativecommons.org/publicdomain/zero/1.0/ */
use batch::GlyphRange;
use buffers::GlyphBuffers;
use charmap::CodepointRange;
use glyph_buffer::GlyphBufferBuilder;
use memmap::{Mmap, Protection};
use otf::FontData;
use otf::Font;
use test::Bencher;
static TEST_FONT_PATH: &'static str = "resources/tests/nimbus-sans/NimbusSanL-Regu.ttf";
@ -14,19 +13,16 @@ static TEST_FONT_PATH: &'static str = "resources/tests/nimbus-sans/NimbusSanL-Re
fn bench_add_glyphs(bencher: &mut Bencher) {
let file = Mmap::open_path(TEST_FONT_PATH, Protection::Read).expect("Couldn't open test font");
unsafe {
let font = FontData::new(file.as_slice());
let cmap = font.cmap_table().unwrap();
let glyf = font.glyf_table().unwrap();
let head = font.head_table().unwrap();
let loca = font.loca_table(&head).unwrap();
let font = Font::new(file.as_slice()).unwrap();
let codepoint_ranges = [CodepointRange::new('!' as u32, '~' as u32)];
let glyph_ranges = cmap.glyph_ranges_for_codepoint_ranges(&codepoint_ranges)
let glyph_ranges = font.cmap
.glyph_ranges_for_codepoint_ranges(&codepoint_ranges)
.expect("Couldn't find glyph ranges");
bencher.iter(|| {
let mut buffers = GlyphBuffers::new();
for glyph_id in glyph_ranges.iter().flat_map(GlyphRange::iter) {
buffers.add_glyph(glyph_id as u32, &loca, &glyf).unwrap()
let mut glyph_buffer_builder = GlyphBufferBuilder::new();
for glyph_id in glyph_ranges.iter() {
glyph_buffer_builder.add_glyph(&font, glyph_id).unwrap()
}
});
}