Get things working on Windows

examples/generate-atlas.rs

@@ -81,21 +81,23 @@ fn main() {
     }
 
     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();
 
-    let image = rasterizer.device
-                          .create_image(Format::R8, buffer::Protection::WriteOnly, &atlas_size)
+    let image = rasterizer.device()
+                          .create_image(Format::R8, buffer::Protection::ReadWrite, &atlas_size)
                           .unwrap();
 
     let rect = Rect::new(Point2D::new(0, 0), atlas_size);
 
     rasterizer.draw_atlas(&image, &rect, &atlas, &outlines, &coverage_buffer).unwrap();
-    rasterizer.queue.flush().unwrap();
+    rasterizer.queue().flush().unwrap();
 
     let draw_context = lord_drawquaad::Context::new();
 
     let mut gl_texture = 0;
     unsafe {
+        gl::MemoryBarrier(gl::SHADER_IMAGE_ACCESS_BARRIER_BIT | gl::TEXTURE_FETCH_BARRIER_BIT);
+
         gl::GenTextures(1, &mut gl_texture);
         image.bind_to(&ExternalImage::GlTexture(gl_texture)).unwrap();
 

examples/lorem-ipsum.rs

@@ -17,7 +17,8 @@ use compute_shader::image::{ExternalImage, Format, Image};
 use compute_shader::instance::Instance;
 use euclid::{Point2D, Rect, Size2D};
 use gl::types::{GLchar, GLint, GLsizei, GLsizeiptr, GLuint, GLvoid};
-use glfw::{Action, Context, Key, OpenGlProfileHint, WindowEvent, WindowHint, WindowMode};
+use glfw::{Action, Context, Key, OpenGlProfileHint, SwapInterval, WindowEvent};
+use glfw::{WindowHint, WindowMode};
 use memmap::{Mmap, Protection};
 use pathfinder::atlas::{Atlas, AtlasBuilder};
 use pathfinder::charmap::{CodepointRanges, GlyphMapping};
@@ -66,6 +67,7 @@ fn main() {
     window.set_scroll_polling(true);
     window.set_size_polling(true);
     window.set_framebuffer_size_polling(true);
+    glfw.set_swap_interval(SwapInterval::Sync(1));
 
     gl::load_with(|symbol| window.get_proc_address(symbol) as *const c_void);
 
@@ -164,6 +166,7 @@ fn main() {
 
             let mut draw_time = 0u64;
             unsafe {
+                gl::Flush();
                 gl::GetQueryObjectui64v(events.draw, gl::QUERY_RESULT, &mut draw_time);
             }
 
@@ -435,6 +438,8 @@ impl Renderer {
         self.rasterizer.queue().flush().unwrap();
 
         unsafe {
+            gl::MemoryBarrier(gl::SHADER_IMAGE_ACCESS_BARRIER_BIT | gl::TEXTURE_FETCH_BARRIER_BIT);
+
             gl::Viewport(0,
                          0,
                          device_pixel_size.width as GLint,
@@ -771,7 +776,7 @@ fn create_program(vertex_shader_source: &str, fragment_shader_source: &str) -> G
 
 fn create_image(rasterizer: &Rasterizer, atlas_size: &Size2D<u32>) -> (Image, GLuint) {
     let compute_image = rasterizer.device().create_image(Format::R8,
-                                                         buffer::Protection::WriteOnly,
+                                                         buffer::Protection::ReadWrite,
                                                          &atlas_size).unwrap();
 
     let mut gl_texture = 0;

resources/shaders/accum.cs.glsl

@@ -19,13 +19,14 @@
 #extension GL_ARB_explicit_uniform_location : require
 #extension GL_ARB_shader_image_load_store : require
 #extension GL_ARB_shader_storage_buffer_object : require
+#extension GL_ARB_shading_language_420pack : require
 
 layout(local_size_x = 1024) in;
 
-uniform restrict writeonly uimage2DRect uImage;
-uniform sampler2DRect uCoverage;
-uniform uvec4 uAtlasRect;
-uniform uint uAtlasShelfHeight;
+layout(r8, binding = 0) uniform restrict writeonly image2DRect uImage;
+layout(r32f, binding = 1) uniform restrict readonly image2DRect uCoverage;
+layout(location = 2) uniform uvec4 uAtlasRect;
+layout(location = 3) uniform uint uAtlasShelfHeight;
 
 void main() {
     // Determine the boundaries of the column we'll be traversing.
@@ -35,13 +36,15 @@ void main() {
     uint firstRow = shelfIndex * uAtlasShelfHeight;
     uint lastRow = (shelfIndex + 1u) * uAtlasShelfHeight;
 
+    uint atlasHeight = uAtlasRect.w - uAtlasRect.y;
+    if (firstRow >= atlasHeight)
+        return;
+
     // Sweep down the column, accumulating coverage as we go.
     float coverage = 0.0f;
     for (uint row = firstRow; row < lastRow; row++) {
         ivec2 coord = ivec2(column, row);
-        coverage += texelFetch(uCoverage, coord).r;
-
-        uint gray = uint(clamp(coverage, 0.0f, 1.0f) * 255.0f);
-        imageStore(uImage, coord + ivec2(uAtlasRect.xy), uvec4(gray, 255, 255, 255));
+        coverage += imageLoad(uCoverage, coord).r;
+        imageStore(uImage, coord + ivec2(uAtlasRect.xy), vec4(coverage, 0.0, 0.0, 1.0));
     }
 }

src/rasterizer.rs

@@ -240,6 +240,7 @@ impl Rasterizer {
             } else {
                 gl::PATCHES
             };
+
             // Now draw the glyph ranges.
             gl::BeginQuery(gl::TIME_ELAPSED, self.draw_query);
             atlas.draw(primitive);
@@ -254,6 +255,7 @@ impl Rasterizer {
             // OpenCL, but I don't know how to do that portably (i.e. on Mac…) Just using
             // `glFlush()` seems to work in practice.
             gl::Flush();
+            gl::MemoryBarrier(gl::ALL_BARRIER_BITS);
         }
 
         let accum_uniforms = [