Fix up examples and tests

examples/benchmark.rs

@@ -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,10 +104,8 @@ 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
+        let image = rasterizer.device
-                                .create_texture(Format::R8,
+                              .create_image(Format::R8, buffer::Protection::WriteOnly, &atlas_size)
-                                                buffer::Protection::WriteOnly,
-                                                &atlas_size)
                               .unwrap();
 
         let mut results = vec![];
@@ -118,7 +116,7 @@ fn main() {
                                                &glyph_buffers,
                                                &batch,
                                                &coverage_buffer,
-                                               &texture).unwrap();
+                                               &image).unwrap();
 
             let mut draw_time = 0u64;
             unsafe {

examples/dump-outlines.rs

@@ -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
+        for (glyph_index, glyph_id) in glyph_ranges.iter().enumerate() {
-                codepoint_ranges.iter()
+            let codepoint = '!' as u32 + glyph_index as u32;
-                                .flat_map(CodepointRange::iter)
-                                .zip(glyph_ranges.iter().flat_map(GlyphRange::iter)) {
             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);

examples/generate-atlas.rs

@@ -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,13 +65,13 @@ 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
+    let image = rasterizer.device
-                            .create_texture(Format::R8, buffer::Protection::WriteOnly, &atlas_size)
+                          .create_image(Format::R8, buffer::Protection::WriteOnly, &atlas_size)
                           .unwrap();
 
     rasterizer.draw_atlas(&Rect::new(Point2D::new(0, 0), atlas_size),
@@ -79,14 +79,14 @@ fn main() {
                           &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);

examples/lorem-ipsum.rs

@@ -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 (main_compute_image, main_gl_texture) = create_image(&rasterizer, &atlas_size);
-        let (fps_compute_texture, fps_gl_texture) = create_texture(&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) {
+fn create_image(rasterizer: &Rasterizer, atlas_size: &Size2D<u32>) -> (Image, GLuint) {
-    let compute_texture = rasterizer.device.create_texture(Format::R8,
+    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 = "\

resources/shaders/accum.cl

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

resources/shaders/accum.cs.glsl

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

resources/shaders/draw.vs.glsl

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

src/coverage.rs

@@ -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)
+        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,
         })
     }

src/otf/cmap.rs

@@ -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 _length = try!(cmap_reader.read_u16::<BigEndian>().map_err(drop));
-        let language = 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 _search_range = try!(cmap_reader.read_u16::<BigEndian>().map_err(drop));
-        let entry_selector = 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 _range_shift = try!(cmap_reader.read_u16::<BigEndian>().map_err(drop));
 
         // Set up parallel array pointers.
         //

src/rasterizer.rs

@@ -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)),
+            (0, Uniform::Image(image)),
-            (1, Uniform::Texture(&coverage_buffer.texture)),
+            (1, Uniform::Image(&coverage_buffer.image)),
             (2, Uniform::UVec4(atlas_rect_uniform)),
             (3, Uniform::U32(atlas.shelf_height())),
         ];

src/tests/atlas.rs

@@ -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,
+    let available_width = 2 +
-                                   objects.iter().map(|object| object.width).max().unwrap_or(0));
+        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 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()

src/tests/buffers.rs

@@ -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 font = Font::new(file.as_slice()).unwrap();
-        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 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();
+            let mut glyph_buffer_builder = GlyphBufferBuilder::new();
-            for glyph_id in glyph_ranges.iter().flat_map(GlyphRange::iter) {
+            for glyph_id in glyph_ranges.iter() {
-                buffers.add_glyph(glyph_id as u32, &loca, &glyf).unwrap()
+                glyph_buffer_builder.add_glyph(&font, glyph_id).unwrap()
             }
         });
     }