Update dependencies

Update to latest versions of all dependencies. Among other things, this
gets us on piet 0.2, though almost all of the changes were around text,
which is not yet implemented.

piet-gpu-hal/Cargo.toml

@@ -7,7 +7,7 @@ license = "MIT/Apache-2.0"
 edition = "2018"
 
 [dependencies]
-ash = "0.30"
+ash = "0.31"
 once_cell = "1.3.1"
-ash-window = { git = "https://github.com/norse-rs/ash-window.git", branch = "dyn_trait" }
+ash-window = "0.5"
 raw-window-handle = "0.3"

piet-gpu-hal/examples/collatz.rs

@@ -5,6 +5,7 @@ fn main() {
     let (instance, _) = VkInstance::new(None).unwrap();
     unsafe {
         let device = instance.device(None).unwrap();
+        let fence = device.create_fence(false).unwrap();
         let mem_flags = MemFlags::host_coherent();
         let src = (0..256).map(|x| x + 1).collect::<Vec<u32>>();
         let buffer = device
@@ -12,8 +13,10 @@ fn main() {
             .unwrap();
         device.write_buffer(&buffer, &src).unwrap();
         let code = include_bytes!("./shader/collatz.spv");
-        let pipeline = device.create_simple_compute_pipeline(code, 1).unwrap();
+        let pipeline = device.create_simple_compute_pipeline(code, 1, 0).unwrap();
-        let descriptor_set = device.create_descriptor_set(&pipeline, &[&buffer]).unwrap();
+        let descriptor_set = device
+            .create_descriptor_set(&pipeline, &[&buffer], &[])
+            .unwrap();
         let query_pool = device.create_query_pool(2).unwrap();
         let mut cmd_buf = device.create_cmd_buf().unwrap();
         cmd_buf.begin();
@@ -22,8 +25,11 @@ fn main() {
         cmd_buf.dispatch(&pipeline, &descriptor_set, (256, 1, 1));
         cmd_buf.write_timestamp(&query_pool, 1);
         cmd_buf.finish();
-        device.run_cmd_buf(&cmd_buf).unwrap();
+        device
-        let timestamps = device.reap_query_pool(query_pool);
+            .run_cmd_buf(&cmd_buf, &[], &[], Some(&fence))
+            .unwrap();
+        device.wait_and_reset(&[fence]).unwrap();
+        let timestamps = device.reap_query_pool(&query_pool);
         let mut dst: Vec<u32> = Default::default();
         device.read_buffer(&buffer, &mut dst).unwrap();
         for (i, val) in dst.iter().enumerate().take(16) {

piet-gpu/Cargo.toml

@@ -21,9 +21,9 @@ path = "../piet-gpu-hal"
 path = "../piet-gpu-types"
 
 [dependencies]
-piet = "0.0.13"
+piet = "0.2.0"
 png = "0.16.2"
 rand = "0.7.3"
-roxmltree = "0.11"
+roxmltree = "0.13"
-winit = "0.22"
+winit = "0.23"
 clap = "2.33"

piet-gpu/bin/cli.rs

@@ -2,7 +2,7 @@ use std::fs::File;
 use std::io::BufWriter;
 use std::path::Path;
 
-use clap::{Arg, App};
+use clap::{App, Arg};
 
 use piet_gpu_hal::vulkan::VkInstance;
 use piet_gpu_hal::{CmdBuf, Device, Error, MemFlags};
@@ -22,18 +22,30 @@ fn dump_scene(buf: &[u8]) {
 fn dump_state(buf: &[u8]) {
     for i in 0..(buf.len() / 48) {
         let j = i * 48;
-        let floats = (0..11).map(|k| {
+        let floats = (0..11)
+            .map(|k| {
                 let mut buf_f32 = [0u8; 4];
                 buf_f32.copy_from_slice(&buf[j + k * 4..j + k * 4 + 4]);
                 f32::from_le_bytes(buf_f32)
-        }).collect::<Vec<_>>();
+            })
-        println!("{}: [{} {} {} {} {} {}] ({}, {})-({} {}) {} {}",
+            .collect::<Vec<_>>();
+        println!(
+            "{}: [{} {} {} {} {} {}] ({}, {})-({} {}) {} {}",
             i,
-            floats[0], floats[1], floats[2], floats[3], floats[4], floats[5],
+            floats[0],
-            floats[6], floats[7], floats[8], floats[9],
+            floats[1],
-            floats[10], buf[j + 44]);
+            floats[2],
+            floats[3],
+            floats[4],
+            floats[5],
+            floats[6],
+            floats[7],
+            floats[8],
+            floats[9],
+            floats[10],
+            buf[j + 44]
+        );
     }
-
 }
 
 /// Interpret the output of the binning stage, for diagnostic purposes.
@@ -41,22 +53,31 @@ fn dump_state(buf: &[u8]) {
 fn trace_merge(buf: &[u32]) {
     for bin in 0..256 {
         println!("bin {}:", bin);
-        let mut starts = (0..16).map(|i| Some((bin * 16 + i) * 64)).collect::<Vec<Option<usize>>>();
+        let mut starts = (0..16)
+            .map(|i| Some((bin * 16 + i) * 64))
+            .collect::<Vec<Option<usize>>>();
         loop {
-            let min_start = starts.iter().map(|st|
+            let min_start = starts
-                st.map(|st|
+                .iter()
+                .map(|st| {
+                    st.map(|st| {
                         if buf[st / 4] == 0 {
                             !0
                         } else {
                             buf[st / 4 + 2]
-                    }).unwrap_or(!0)).min().unwrap();
+                        }
+                    })
+                    .unwrap_or(!0)
+                })
+                .min()
+                .unwrap();
             if min_start == !0 {
                 break;
             }
             let mut selected = !0;
             for i in 0..16 {
                 if let Some(st) = starts[i] {
-                    if buf[st/4] != 0 && buf[st/4 + 2] == min_start {
+                    if buf[st / 4] != 0 && buf[st / 4 + 2] == min_start {
                         selected = i;
                         break;
                     }
@@ -64,16 +85,15 @@ fn trace_merge(buf: &[u32]) {
             }
             let st = starts[selected].unwrap();
             println!("selected {}, start {:x}", selected, st);
-            for j in 0..buf[st/4] {
+            for j in 0..buf[st / 4] {
-                println!("{:x}", buf[st/4 + 2 + j as usize])
+                println!("{:x}", buf[st / 4 + 2 + j as usize])
             }
-            if buf[st/4 + 1] == 0 {
+            if buf[st / 4 + 1] == 0 {
                 starts[selected] = None;
             } else {
-                starts[selected] = Some(buf[st/4 + 1] as usize);
+                starts[selected] = Some(buf[st / 4 + 1] as usize);
             }
         }
-
     }
 }
 
@@ -103,7 +123,10 @@ fn trace_ptcl(buf: &[u32]) {
                             let x1 = f32::from_bits(buf[segs / 4 + i * 5 + 2]);
                             let y1 = f32::from_bits(buf[segs / 4 + i * 5 + 3]);
                             let y_edge = f32::from_bits(buf[segs / 4 + i * 5 + 4]);
-                            println!("      ({:.3}, {:.3}) - ({:.3}, {:.3}) | {:.3}", x0, y0, x1, y1, y_edge);
+                            println!(
+                                "      ({:.3}, {:.3}) - ({:.3}, {:.3}) | {:.3}",
+                                x0, y0, x1, y1, y_edge
+                            );
                         }
                         loop {
                             seg_chunk = buf[seg_chunk / 4 + 1] as usize;
@@ -115,7 +138,10 @@ fn trace_ptcl(buf: &[u32]) {
                     4 => {
                         let line_width = f32::from_bits(buf[tile_offset / 4 + 2]);
                         let rgba_color = buf[tile_offset / 4 + 3];
-                        println!("  {:x}: stroke {:x} {}", tile_offset, rgba_color, line_width);
+                        println!(
+                            "  {:x}: stroke {:x} {}",
+                            tile_offset, rgba_color, line_width
+                        );
                         let mut seg_chunk = buf[tile_offset / 4 + 1] as usize;
                         let n = buf[seg_chunk / 4] as usize;
                         let segs = buf[seg_chunk / 4 + 2] as usize;
@@ -126,7 +152,10 @@ fn trace_ptcl(buf: &[u32]) {
                             let x1 = f32::from_bits(buf[segs / 4 + i * 5 + 2]);
                             let y1 = f32::from_bits(buf[segs / 4 + i * 5 + 3]);
                             let y_edge = f32::from_bits(buf[segs / 4 + i * 5 + 4]);
-                            println!("      ({:.3}, {:.3}) - ({:.3}, {:.3}) | {:.3}", x0, y0, x1, y1, y_edge);
+                            println!(
+                                "      ({:.3}, {:.3}) - ({:.3}, {:.3}) | {:.3}",
+                                x0, y0, x1, y1, y_edge
+                            );
                         }
                         loop {
                             seg_chunk = buf[seg_chunk / 4 + 1] as usize;
@@ -152,18 +181,16 @@ fn trace_ptcl(buf: &[u32]) {
     }
 }
 
-
 fn main() -> Result<(), Error> {
     let matches = App::new("piet-gpu test")
-        .arg(Arg::with_name("INPUT")
+        .arg(Arg::with_name("INPUT").index(1))
-            .index(1))
+        .arg(Arg::with_name("flip").short("f").long("flip"))
-        .arg(Arg::with_name("flip")
+        .arg(
-            .short("f")
+            Arg::with_name("scale")
-            .long("flip"))
-        .arg(Arg::with_name("scale")
                 .short("s")
                 .long("scale")
-            .takes_value(true))
+                .takes_value(true),
+        )
         .get_matches();
     let (instance, _) = VkInstance::new(None)?;
     unsafe {
@@ -175,7 +202,8 @@ fn main() -> Result<(), Error> {
 
         let mut ctx = PietGpuRenderContext::new();
         if let Some(input) = matches.value_of("INPUT") {
-            let mut scale = matches.value_of("scale")
+            let mut scale = matches
+                .value_of("scale")
                 .map(|scale| scale.parse().unwrap())
                 .unwrap_or(8.0);
             if matches.is_present("flip") {
@@ -198,11 +226,16 @@ fn main() -> Result<(), Error> {
         renderer.record(&mut cmd_buf, &query_pool);
         cmd_buf.copy_image_to_buffer(&renderer.image_dev, &image_buf);
         cmd_buf.finish();
+        let start = std::time::Instant::now();
         device.run_cmd_buf(&cmd_buf, &[], &[], Some(&fence))?;
         device.wait_and_reset(&[fence])?;
+        println!("elapsed = {:?}", start.elapsed());
         let ts = device.reap_query_pool(&query_pool).unwrap();
         println!("Element kernel time: {:.3}ms", ts[0] * 1e3);
-        println!("Tile allocation kernel time: {:.3}ms", (ts[1] - ts[0]) * 1e3);
+        println!(
+            "Tile allocation kernel time: {:.3}ms",
+            (ts[1] - ts[0]) * 1e3
+        );
         println!("Coarse path kernel time: {:.3}ms", (ts[2] - ts[1]) * 1e3);
         println!("Backdrop kernel time: {:.3}ms", (ts[3] - ts[2]) * 1e3);
         println!("Binning kernel time: {:.3}ms", (ts[4] - ts[3]) * 1e3);

piet-gpu/src/lib.rs

@@ -162,12 +162,20 @@ pub struct Renderer<D: Device> {
 }
 
 impl<D: Device> Renderer<D> {
-    pub unsafe fn new(device: &D, scene: &[u8], n_paths: usize, n_pathseg: usize) -> Result<Self, Error> {
+    pub unsafe fn new(
+        device: &D,
+        scene: &[u8],
+        n_paths: usize,
+        n_pathseg: usize,
+    ) -> Result<Self, Error> {
         let host = MemFlags::host_coherent();
         let dev = MemFlags::device_local();
 
         let n_elements = scene.len() / piet_gpu_types::scene::Element::fixed_size();
-        println!("scene: {} elements, {} paths, {} path_segments", n_elements, n_paths, n_pathseg);
+        println!(
+            "scene: {} elements, {} paths, {} path_segments",
+            n_elements, n_paths, n_pathseg
+        );
 
         let scene_buf = device
             .create_buffer(std::mem::size_of_val(&scene[..]) as u64, host)
@@ -256,17 +264,20 @@ impl<D: Device> Renderer<D> {
         let coarse_pipeline = device.create_simple_compute_pipeline(coarse_code, 5, 0)?;
         let coarse_ds = device.create_descriptor_set(
             &coarse_pipeline,
-            &[&anno_buf, &bin_buf, &tile_buf, &coarse_alloc_buf_dev, &ptcl_buf],
+            &[
+                &anno_buf,
+                &bin_buf,
+                &tile_buf,
+                &coarse_alloc_buf_dev,
+                &ptcl_buf,
+            ],
             &[],
         )?;
 
         let k4_code = include_bytes!("../shader/kernel4.spv");
         let k4_pipeline = device.create_simple_compute_pipeline(k4_code, 2, 1)?;
-        let k4_ds = device.create_descriptor_set(
+        let k4_ds =
-            &k4_pipeline,
+            device.create_descriptor_set(&k4_pipeline, &[&ptcl_buf, &tile_buf], &[&image_dev])?;
-            &[&ptcl_buf, &tile_buf],
-            &[&image_dev]
-        )?;
 
         Ok(Renderer {
             scene_buf,

piet-gpu/src/render_ctx.rs

@@ -1,28 +1,28 @@
-use std::borrow::Cow;
+use std::{borrow::Cow, ops::RangeBounds};
 
 use piet_gpu_types::encoder::{Encode, Encoder};
 
 use piet_gpu_types::scene::{CubicSeg, Element, Fill, LineSeg, QuadSeg, SetLineWidth, Stroke};
 
-use piet::kurbo::{Affine, PathEl, Point, Rect, Shape};
+use piet::{
+    kurbo::Size,
+    kurbo::{Affine, PathEl, Point, Rect, Shape},
+    HitTestPosition, TextAttribute, TextStorage,
+};
 
 use piet::{
-    Color, Error, FixedGradient, Font, FontBuilder, HitTestPoint, HitTestTextPosition, ImageFormat,
+    Color, Error, FixedGradient, FontFamily, HitTestPoint, ImageFormat, InterpolationMode,
-    InterpolationMode, IntoBrush, LineMetric, RenderContext, StrokeStyle, Text, TextLayout,
+    IntoBrush, LineMetric, RenderContext, StrokeStyle, Text, TextLayout, TextLayoutBuilder,
-    TextLayoutBuilder,
 };
 
 pub struct PietGpuImage;
 
-pub struct PietGpuFont;
-
-pub struct PietGpuFontBuilder;
-
 #[derive(Clone)]
 pub struct PietGpuTextLayout;
 
 pub struct PietGpuTextLayoutBuilder;
 
+#[derive(Clone)]
 pub struct PietGpuText;
 
 pub struct PietGpuRenderContext {
@@ -103,7 +103,7 @@ impl RenderContext for PietGpuRenderContext {
             self.stroke_width = width;
         }
         let brush = brush.make_brush(self, || shape.bounding_box()).into_owned();
-        let path = shape.to_bez_path(TOLERANCE);
+        let path = shape.path_elements(TOLERANCE);
         self.encode_path(path, false);
         match brush {
             PietGpuBrush::Solid(rgba_color) => {
@@ -126,7 +126,7 @@ impl RenderContext for PietGpuRenderContext {
 
     fn fill(&mut self, shape: impl Shape, brush: &impl IntoBrush<Self>) {
         let brush = brush.make_brush(self, || shape.bounding_box()).into_owned();
-        let path = shape.to_bez_path(TOLERANCE);
+        let path = shape.path_elements(TOLERANCE);
         self.encode_path(path, true);
         match brush {
             PietGpuBrush::Solid(rgba_color) => {
@@ -146,23 +146,7 @@ impl RenderContext for PietGpuRenderContext {
         &mut self.inner_text
     }
 
-    fn draw_text(
+    fn draw_text(&mut self, _layout: &Self::TextLayout, _pos: impl Into<Point>) {}
-        &mut self,
-        _layout: &Self::TextLayout,
-        pos: impl Into<Point>,
-        brush: &impl IntoBrush<Self>,
-    ) {
-        let _pos = pos.into();
-
-        let brush: PietGpuBrush = brush.make_brush(self, || Rect::ZERO).into_owned();
-
-        match brush {
-            PietGpuBrush::Solid(_rgba) => {
-                // TODO: draw text
-            }
-            _ => {}
-        }
-    }
 
     fn save(&mut self) -> Result<(), Error> {
         Ok(())
@@ -335,70 +319,81 @@ impl PietGpuRenderContext {
 }
 
 impl Text for PietGpuText {
-    type Font = PietGpuFont;
-    type FontBuilder = PietGpuFontBuilder;
     type TextLayout = PietGpuTextLayout;
     type TextLayoutBuilder = PietGpuTextLayoutBuilder;
 
-    fn new_font_by_name(&mut self, _name: &str, _size: f64) -> Self::FontBuilder {
+    fn load_font(&mut self, _data: &[u8]) -> Result<FontFamily, Error> {
-        unimplemented!();
+        Ok(FontFamily::default())
     }
 
-    fn new_text_layout(
+    fn new_text_layout(&mut self, _text: impl TextStorage) -> Self::TextLayoutBuilder {
-        &mut self,
+        PietGpuTextLayoutBuilder
-        _font: &Self::Font,
-        _text: &str,
-        _width: impl Into<Option<f64>>,
-    ) -> Self::TextLayoutBuilder {
-        unimplemented!();
     }
-}
 
-impl Font for PietGpuFont {}
+    fn font_family(&mut self, _family_name: &str) -> Option<FontFamily> {
-
+        Some(FontFamily::default())
-impl FontBuilder for PietGpuFontBuilder {
-    type Out = PietGpuFont;
-
-    fn build(self) -> Result<Self::Out, Error> {
-        unimplemented!();
     }
 }
 
 impl TextLayoutBuilder for PietGpuTextLayoutBuilder {
     type Out = PietGpuTextLayout;
 
+    fn max_width(self, _width: f64) -> Self {
+        self
+    }
+
+    fn alignment(self, _alignment: piet::TextAlignment) -> Self {
+        self
+    }
+
+    fn default_attribute(self, _attribute: impl Into<TextAttribute>) -> Self {
+        self
+    }
+
+    fn range_attribute(
+        self,
+        _range: impl RangeBounds<usize>,
+        _attribute: impl Into<TextAttribute>,
+    ) -> Self {
+        self
+    }
+
     fn build(self) -> Result<Self::Out, Error> {
-        unimplemented!()
+        Ok(PietGpuTextLayout)
     }
 }
 
 impl TextLayout for PietGpuTextLayout {
-    fn width(&self) -> f64 {
+    fn size(&self) -> Size {
-        0.0
+        Size::ZERO
     }
 
-    fn update_width(&mut self, _new_width: impl Into<Option<f64>>) -> Result<(), Error> {
+    fn image_bounds(&self) -> Rect {
-        unimplemented!()
+        Rect::ZERO
     }
 
     fn line_text(&self, _line_number: usize) -> Option<&str> {
-        unimplemented!()
+        None
     }
 
     fn line_metric(&self, _line_number: usize) -> Option<LineMetric> {
-        unimplemented!()
+        None
     }
 
     fn line_count(&self) -> usize {
-        unimplemented!()
+        0
     }
 
     fn hit_test_point(&self, _point: Point) -> HitTestPoint {
-        unimplemented!()
+        HitTestPoint::default()
     }
 
-    fn hit_test_text_position(&self, _text_position: usize) -> Option<HitTestTextPosition> {
+    fn hit_test_text_position(&self, _text_position: usize) -> HitTestPosition {
-        unimplemented!()
+        HitTestPosition::default()
+    }
+
+    fn text(&self) -> &str {
+        ""
     }
 }