From 86a4e944ed1041597f3efcbeba642d15159c96a3 Mon Sep 17 00:00:00 2001
From: Dzmitry Malyshau <kvarkus@gmail.com>
Date: Mon, 27 Apr 2020 21:26:34 -0400
Subject: [PATCH 01/12] Split serde feature into trace+replay

---
 .github/workflows/ci.yml       |   9 +++
 wgpu-core/Cargo.toml           |  10 +--
 wgpu-core/src/binding_model.rs |  41 ++++------
 wgpu-core/src/id.rs            |   9 +--
 wgpu-core/src/instance.rs      |  27 +++----
 wgpu-types/Cargo.toml          |   4 +
 wgpu-types/src/lib.rs          | 141 ++++++++++++++++++++++-----------
 7 files changed, 136 insertions(+), 105 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 41363271a9..6ac9a72e12 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -27,30 +27,37 @@ jobs:
             name: iOS Stable
             channel: stable
             build_command: rustup target add aarch64-apple-ios; cargo clippy --target aarch64-apple-ios
+            additional_core_features:
           - os: macos-10.15
             name: MacOS Stable
             channel: stable
             build_command: cargo clippy
+            additional_core_features: trace
           - os: macos-10.15
             name: MacOS Nightly
             channel: nightly
             build_command: cargo test
+            additional_core_features:
           - os: ubuntu-18.04
             name: Ubuntu Stable
             channel: stable
             build_command: cargo clippy
+            additional_core_features: trace,replay
           - os: ubuntu-18.04
             name: Ubuntu Nightly
             channel: nightly
             build_command: cargo test
+            additional_core_features:
           - os: windows-2019
             name: Windows Stable
             channel: stable
             build_command: rustup default stable-msvc; cargo clippy
+            additional_core_features: replay
           - os: windows-2019
             name: Windows Nightly
             channel: nightly
             build_command: rustup default nightly-msvc; cargo test
+            additional_core_features:
     steps:
     - uses: actions/checkout@v2
     - if: matrix.channel == 'nightly'
@@ -63,3 +70,5 @@ jobs:
       run: rustup component add clippy
     - name: cargo clippy/test
       run: ${{ matrix.build_command }}
+    - if: matrix.additional_core_features != ''
+      run: cargo check --manifest-path wgpu-core/Cargo.toml --features ${{ matrix.additional_core_features }}
diff --git a/wgpu-core/Cargo.toml b/wgpu-core/Cargo.toml
index 0b1185bbd5..494c80ae30 100644
--- a/wgpu-core/Cargo.toml
+++ b/wgpu-core/Cargo.toml
@@ -16,8 +16,9 @@ license = "MPL-2.0"
 
 [features]
 default = []
+trace = ["serde", "wgt/trace"]
+replay = ["serde", "wgt/replay"]
 metal-auto-capture = ["gfx-backend-metal/auto-capture"]
-serde = ["wgt/serde", "serde_crate"]
 #NOTE: glutin feature is not stable, use at your own risk
 #glutin = ["gfx-backend-gl/glutin"]
 
@@ -33,15 +34,10 @@ gfx-descriptor = "0.1"
 gfx-memory = "0.1"
 parking_lot = "0.10"
 peek-poke = "0.2"
+serde = { version = "1.0", features = ["serde_derive"], optional = true }
 smallvec = "1"
 vec_map = "0.8"
 
-[dependencies.serde_crate]
-package = "serde"
-version = "1.0"
-features = ["serde_derive"]
-optional = true
-
 [dependencies.wgt]
 path = "../wgpu-types"
 package = "wgpu-types"
diff --git a/wgpu-core/src/binding_model.rs b/wgpu-core/src/binding_model.rs
index e8c20477e3..17cfff5cd1 100644
--- a/wgpu-core/src/binding_model.rs
+++ b/wgpu-core/src/binding_model.rs
@@ -12,17 +12,16 @@ use arrayvec::ArrayVec;
 use gfx_descriptor::{DescriptorCounts, DescriptorSet};
 use wgt::{BufferAddress, TextureComponentType};
 
-#[cfg(feature = "serde")]
-use serde_crate::{Deserialize, Serialize};
+#[cfg(feature = "replay")]
+use serde::Deserialize;
+#[cfg(feature = "trace")]
+use serde::Serialize;
 use std::borrow::Borrow;
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Serialize, Deserialize),
-    serde(crate = "serde_crate")
-)]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum BindingType {
     UniformBuffer = 0,
     StorageBuffer = 1,
@@ -36,11 +35,8 @@ pub enum BindingType {
 
 #[repr(C)]
 #[derive(Clone, Debug, Hash, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Serialize, Deserialize),
-    serde(crate = "serde_crate")
-)]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct BindGroupLayoutEntry {
     pub binding: u32,
     pub visibility: wgt::ShaderStage,
@@ -86,11 +82,8 @@ pub struct PipelineLayout<B: hal::Backend> {
 
 #[repr(C)]
 #[derive(Debug)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Serialize, Deserialize),
-    serde(crate = "serde_crate")
-)]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct BufferBinding {
     pub buffer: BufferId,
     pub offset: BufferAddress,
@@ -99,11 +92,8 @@ pub struct BufferBinding {
 
 #[repr(C)]
 #[derive(Debug)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Serialize, Deserialize),
-    serde(crate = "serde_crate")
-)]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum BindingResource {
     Buffer(BufferBinding),
     Sampler(SamplerId),
@@ -112,11 +102,8 @@ pub enum BindingResource {
 
 #[repr(C)]
 #[derive(Debug)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Serialize, Deserialize),
-    serde(crate = "serde_crate")
-)]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct BindGroupEntry {
     pub binding: u32,
     pub resource: BindingResource,
diff --git a/wgpu-core/src/id.rs b/wgpu-core/src/id.rs
index f50477cbeb..e5bb1f1846 100644
--- a/wgpu-core/src/id.rs
+++ b/wgpu-core/src/id.rs
@@ -3,8 +3,6 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use crate::{Epoch, Index};
-#[cfg(feature = "serde")]
-use serde_crate::{Deserialize, Serialize};
 use std::{fmt, marker::PhantomData, mem, num::NonZeroU64};
 use wgt::Backend;
 
@@ -13,11 +11,8 @@ const EPOCH_MASK: u32 = (1 << (32 - BACKEND_BITS)) - 1;
 type Dummy = crate::backend::Empty;
 
 #[repr(transparent)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Serialize, Deserialize),
-    serde(crate = "serde_crate")
-)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
 pub struct Id<T>(NonZeroU64, PhantomData<T>);
 
 // required for PeekPoke
diff --git a/wgpu-core/src/instance.rs b/wgpu-core/src/instance.rs
index c49e412695..edab05ea19 100644
--- a/wgpu-core/src/instance.rs
+++ b/wgpu-core/src/instance.rs
@@ -12,8 +12,10 @@ use crate::{
 
 use wgt::{Backend, BackendBit, DeviceDescriptor, PowerPreference, BIND_BUFFER_ALIGNMENT};
 
-#[cfg(feature = "serde")]
-use serde_crate::{Deserialize, Serialize};
+#[cfg(feature = "replay")]
+use serde::Deserialize;
+#[cfg(feature = "trace")]
+use serde::Serialize;
 
 use hal::{
     self,
@@ -25,11 +27,8 @@ use hal::{
 
 #[repr(C)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Serialize, Deserialize),
-    serde(crate = "serde_crate")
-)]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct RequestAdapterOptions {
     pub power_preference: PowerPreference,
     pub compatible_surface: Option<SurfaceId>,
@@ -124,11 +123,8 @@ pub struct Adapter<B: hal::Backend> {
 
 /// Metadata about a backend adapter.
 #[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Serialize, Deserialize),
-    serde(crate = "serde_crate")
-)]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct AdapterInfo {
     /// Adapter name
     pub name: String,
@@ -163,11 +159,8 @@ impl AdapterInfo {
 
 /// Supported physical device types
 #[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Serialize, Deserialize),
-    serde(crate = "serde_crate")
-)]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum DeviceType {
     /// Other
     Other,
diff --git a/wgpu-types/Cargo.toml b/wgpu-types/Cargo.toml
index 616e7e5e03..79b2d1e933 100644
--- a/wgpu-types/Cargo.toml
+++ b/wgpu-types/Cargo.toml
@@ -14,6 +14,10 @@ license = "MPL-2.0"
 
 [lib]
 
+[features]
+trace = ["serde"]
+replay = ["serde"]
+
 [dependencies]
 bitflags = "1.0"
 serde = { version = "1.0", features = ["serde_derive"], optional = true }
diff --git a/wgpu-types/src/lib.rs b/wgpu-types/src/lib.rs
index 2f7c0a928f..afb44f6553 100644
--- a/wgpu-types/src/lib.rs
+++ b/wgpu-types/src/lib.rs
@@ -4,13 +4,16 @@
 
 #[cfg(feature = "peek-poke")]
 use peek_poke::PeekPoke;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
+#[cfg(feature = "replay")]
+use serde::Deserialize;
+#[cfg(feature = "trace")]
+use serde::Serialize;
 use std::{io, ptr, slice};
 
 #[repr(u8)]
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum Backend {
     Empty = 0,
     Vulkan = 1,
@@ -23,7 +26,8 @@ pub enum Backend {
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum PowerPreference {
     Default = 0,
     LowPower = 1,
@@ -32,7 +36,8 @@ pub enum PowerPreference {
 
 bitflags::bitflags! {
     #[repr(transparent)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    #[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
     pub struct BackendBit: u32 {
         const VULKAN = 1 << Backend::Vulkan as u32;
         const GL = 1 << Backend::Gl as u32;
@@ -58,14 +63,16 @@ impl From<Backend> for BackendBit {
 
 #[repr(C)]
 #[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct Extensions {
     pub anisotropic_filtering: bool,
 }
 
 #[repr(C)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct Limits {
     pub max_bind_groups: u32,
 }
@@ -82,7 +89,8 @@ impl Default for Limits {
 
 #[repr(C)]
 #[derive(Clone, Debug, Default)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct DeviceDescriptor {
     pub extensions: Extensions,
     pub limits: Limits,
@@ -130,7 +138,8 @@ pub fn read_spirv<R: io::Read + io::Seek>(mut x: R) -> io::Result<Vec<u32>> {
 
 bitflags::bitflags! {
     #[repr(transparent)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    #[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
     pub struct ShaderStage: u32 {
         const NONE = 0;
         const VERTEX = 1;
@@ -141,7 +150,8 @@ bitflags::bitflags! {
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum TextureViewDimension {
     D1,
     D2,
@@ -155,7 +165,8 @@ pub type BufferAddress = u64;
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum BlendFactor {
     Zero = 0,
     One = 1,
@@ -174,7 +185,8 @@ pub enum BlendFactor {
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum BlendOperation {
     Add = 0,
     Subtract = 1,
@@ -191,7 +203,8 @@ impl Default for BlendOperation {
 
 #[repr(C)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct BlendDescriptor {
     pub src_factor: BlendFactor,
     pub dst_factor: BlendFactor,
@@ -224,7 +237,8 @@ impl Default for BlendDescriptor {
 
 #[repr(C)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct ColorStateDescriptor {
     pub format: TextureFormat,
     pub alpha_blend: BlendDescriptor,
@@ -234,7 +248,8 @@ pub struct ColorStateDescriptor {
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum PrimitiveTopology {
     PointList = 0,
     LineList = 1,
@@ -245,7 +260,8 @@ pub enum PrimitiveTopology {
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum FrontFace {
     Ccw = 0,
     Cw = 1,
@@ -259,7 +275,8 @@ impl Default for FrontFace {
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum CullMode {
     None = 0,
     Front = 1,
@@ -274,7 +291,8 @@ impl Default for CullMode {
 
 #[repr(C)]
 #[derive(Clone, Debug, Default, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct RasterizationStateDescriptor {
     pub front_face: FrontFace,
     pub cull_mode: CullMode,
@@ -285,7 +303,8 @@ pub struct RasterizationStateDescriptor {
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum TextureFormat {
     // Normal 8 bit formats
     R8Unorm = 0,
@@ -342,7 +361,8 @@ pub enum TextureFormat {
 
 bitflags::bitflags! {
     #[repr(transparent)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    #[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
     pub struct ColorWrite: u32 {
         const RED = 1;
         const GREEN = 2;
@@ -361,7 +381,8 @@ impl Default for ColorWrite {
 
 #[repr(C)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct DepthStencilStateDescriptor {
     pub format: TextureFormat,
     pub depth_write_enabled: bool,
@@ -380,7 +401,8 @@ impl DepthStencilStateDescriptor {
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum IndexFormat {
     Uint16 = 0,
     Uint32 = 1,
@@ -388,7 +410,8 @@ pub enum IndexFormat {
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum StencilOperation {
     Keep = 0,
     Zero = 1,
@@ -408,7 +431,8 @@ impl Default for StencilOperation {
 
 #[repr(C)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct StencilStateFaceDescriptor {
     pub compare: CompareFunction,
     pub fail_op: StencilOperation,
@@ -433,7 +457,8 @@ impl Default for StencilStateFaceDescriptor {
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum CompareFunction {
     Undefined = 0,
     Never = 1,
@@ -459,7 +484,8 @@ pub type ShaderLocation = u32;
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum InputStepMode {
     Vertex = 0,
     Instance = 1,
@@ -467,7 +493,8 @@ pub enum InputStepMode {
 
 #[repr(C)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct VertexAttributeDescriptor {
     pub offset: BufferAddress,
     pub format: VertexFormat,
@@ -476,7 +503,8 @@ pub struct VertexAttributeDescriptor {
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum VertexFormat {
     Uchar2 = 0,
     Uchar4 = 1,
@@ -512,7 +540,8 @@ pub enum VertexFormat {
 
 bitflags::bitflags! {
     #[repr(transparent)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    #[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
     pub struct BufferUsage: u32 {
         const MAP_READ = 1;
         const MAP_WRITE = 2;
@@ -553,7 +582,8 @@ pub type DynamicOffset = u32;
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum PresentMode {
     /// The presentation engine does **not** wait for a vertical blanking period and
     /// the request is presented immediately. This is a low-latency presentation mode,
@@ -573,7 +603,8 @@ pub enum PresentMode {
 
 bitflags::bitflags! {
     #[repr(transparent)]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    #[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
     pub struct TextureUsage: u32 {
         const COPY_SRC = 1;
         const COPY_DST = 2;
@@ -585,7 +616,8 @@ bitflags::bitflags! {
 
 #[repr(C)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct SwapChainDescriptor {
     pub usage: TextureUsage,
     pub format: TextureFormat,
@@ -596,7 +628,8 @@ pub struct SwapChainDescriptor {
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 #[cfg_attr(feature = "peek-poke", derive(PeekPoke))]
 pub enum LoadOp {
     Clear = 0,
@@ -605,7 +638,8 @@ pub enum LoadOp {
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 #[cfg_attr(feature = "peek-poke", derive(PeekPoke))]
 pub enum StoreOp {
     Clear = 0,
@@ -614,7 +648,8 @@ pub enum StoreOp {
 
 #[repr(C)]
 #[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 #[cfg_attr(feature = "peek-poke", derive(PeekPoke))]
 pub struct RenderPassColorAttachmentDescriptorBase<T> {
     pub attachment: T,
@@ -626,7 +661,8 @@ pub struct RenderPassColorAttachmentDescriptorBase<T> {
 
 #[repr(C)]
 #[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 #[cfg_attr(feature = "peek-poke", derive(PeekPoke))]
 pub struct RenderPassDepthStencilAttachmentDescriptorBase<T> {
     pub attachment: T,
@@ -640,7 +676,8 @@ pub struct RenderPassDepthStencilAttachmentDescriptorBase<T> {
 
 #[repr(C)]
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 #[cfg_attr(feature = "peek-poke", derive(PeekPoke))]
 pub struct Color {
     pub r: f64,
@@ -690,7 +727,8 @@ impl Color {
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum TextureDimension {
     D1,
     D2,
@@ -699,7 +737,8 @@ pub enum TextureDimension {
 
 #[repr(C)]
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct Origin3d {
     pub x: u32,
     pub y: u32,
@@ -718,7 +757,8 @@ impl Default for Origin3d {
 
 #[repr(C)]
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct Extent3d {
     pub width: u32,
     pub height: u32,
@@ -739,7 +779,8 @@ pub struct TextureDescriptor {
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum TextureAspect {
     All,
     StencilOnly,
@@ -754,7 +795,8 @@ impl Default for TextureAspect {
 
 #[repr(C)]
 #[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct TextureViewDescriptor {
     pub format: TextureFormat,
     pub dimension: TextureViewDimension,
@@ -767,7 +809,8 @@ pub struct TextureViewDescriptor {
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum AddressMode {
     ClampToEdge = 0,
     Repeat = 1,
@@ -782,7 +825,8 @@ impl Default for AddressMode {
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum FilterMode {
     Nearest = 0,
     Linear = 1,
@@ -796,7 +840,8 @@ impl Default for FilterMode {
 
 #[repr(C)]
 #[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct SamplerDescriptor {
     pub address_mode_u: AddressMode,
     pub address_mode_v: AddressMode,
@@ -811,14 +856,16 @@ pub struct SamplerDescriptor {
 
 #[repr(C)]
 #[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct CommandBufferDescriptor {
     pub todo: u32,
 }
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum TextureComponentType {
     Float,
     Sint,

From 42e101225b32bdba7f0635d6a81b21ee3ade17c4 Mon Sep 17 00:00:00 2001
From: Dzmitry Malyshau <kvarkus@gmail.com>
Date: Mon, 27 Apr 2020 22:06:38 -0400
Subject: [PATCH 02/12] Split limits and private features, add tracing module

---
 wgpu-core/src/command/allocator.rs |  9 ++++---
 wgpu-core/src/command/compute.rs   |  2 +-
 wgpu-core/src/command/mod.rs       |  5 ++--
 wgpu-core/src/command/render.rs    | 17 ++++++++++---
 wgpu-core/src/command/transfer.rs  |  4 +--
 wgpu-core/src/conv.rs              |  8 +++---
 wgpu-core/src/device/mod.rs        | 39 +++++++++++++++++++++---------
 wgpu-core/src/device/trace.rs      | 26 ++++++++++++++++++++
 wgpu-core/src/instance.rs          |  5 +++-
 wgpu-core/src/lib.rs               |  3 +--
 wgpu-core/src/swap_chain.rs        | 13 ++++++----
 11 files changed, 95 insertions(+), 36 deletions(-)
 create mode 100644 wgpu-core/src/device/trace.rs

diff --git a/wgpu-core/src/command/allocator.rs b/wgpu-core/src/command/allocator.rs
index 436bb550ad..6eb18b1853 100644
--- a/wgpu-core/src/command/allocator.rs
+++ b/wgpu-core/src/command/allocator.rs
@@ -4,7 +4,8 @@
 
 use super::CommandBuffer;
 use crate::{
-    hub::GfxBackend, id::DeviceId, track::TrackerSet, Features, LifeGuard, Stored, SubmissionIndex,
+    hub::GfxBackend, id::DeviceId, track::TrackerSet, LifeGuard, PrivateFeatures, Stored,
+    SubmissionIndex,
 };
 
 use hal::{command::CommandBuffer as _, device::Device as _, pool::CommandPool as _};
@@ -76,7 +77,8 @@ impl<B: GfxBackend> CommandAllocator<B> {
         &self,
         device_id: Stored<DeviceId>,
         device: &B::Device,
-        features: Features,
+        limits: wgt::Limits,
+        private_features: PrivateFeatures,
         lowest_active_index: SubmissionIndex,
     ) -> CommandBuffer<B> {
         //debug_assert_eq!(device_id.backend(), B::VARIANT);
@@ -108,7 +110,8 @@ impl<B: GfxBackend> CommandAllocator<B> {
             life_guard: LifeGuard::new(),
             trackers: TrackerSet::new(B::VARIANT),
             used_swap_chain: None,
-            features,
+            limits,
+            private_features,
         }
     }
 }
diff --git a/wgpu-core/src/command/compute.rs b/wgpu-core/src/command/compute.rs
index d74035cc3e..179190d4c1 100644
--- a/wgpu-core/src/command/compute.rs
+++ b/wgpu-core/src/command/compute.rs
@@ -79,7 +79,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let (mut cmb_guard, mut token) = hub.command_buffers.write(&mut token);
         let cmb = &mut cmb_guard[encoder_id];
         let raw = cmb.raw.last_mut().unwrap();
-        let mut binder = Binder::new(cmb.features.max_bind_groups);
+        let mut binder = Binder::new(cmb.limits.max_bind_groups);
 
         let (pipeline_layout_guard, mut token) = hub.pipeline_layouts.read(&mut token);
         let (bind_group_guard, mut token) = hub.bind_groups.read(&mut token);
diff --git a/wgpu-core/src/command/mod.rs b/wgpu-core/src/command/mod.rs
index 9529afc0f8..8a57b2cf4c 100644
--- a/wgpu-core/src/command/mod.rs
+++ b/wgpu-core/src/command/mod.rs
@@ -19,7 +19,7 @@ use crate::{
     id,
     resource::{Buffer, Texture},
     track::TrackerSet,
-    Features, LifeGuard, Stored,
+    LifeGuard, PrivateFeatures, Stored,
 };
 
 use peek_poke::PeekPoke;
@@ -138,7 +138,8 @@ pub struct CommandBuffer<B: hal::Backend> {
     pub(crate) life_guard: LifeGuard,
     pub(crate) trackers: TrackerSet,
     pub(crate) used_swap_chain: Option<(Stored<id::SwapChainId>, B::Framebuffer)>,
-    pub(crate) features: Features,
+    limits: wgt::Limits,
+    private_features: PrivateFeatures,
 }
 
 impl<B: GfxBackend> CommandBuffer<B> {
diff --git a/wgpu-core/src/command/render.rs b/wgpu-core/src/command/render.rs
index bb9c186493..97520ca968 100644
--- a/wgpu-core/src/command/render.rs
+++ b/wgpu-core/src/command/render.rs
@@ -431,7 +431,10 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                         };
 
                         Some(hal::pass::Attachment {
-                            format: Some(conv::map_texture_format(view.format, device.features)),
+                            format: Some(conv::map_texture_format(
+                                view.format,
+                                device.private_features,
+                            )),
                             samples: view.samples,
                             ops: conv::map_load_store_ops(at.depth_load_op, at.depth_store_op),
                             stencil_ops: conv::map_load_store_ops(
@@ -495,7 +498,10 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                     };
 
                     colors.push(hal::pass::Attachment {
-                        format: Some(conv::map_texture_format(view.format, device.features)),
+                        format: Some(conv::map_texture_format(
+                            view.format,
+                            device.private_features,
+                        )),
                         samples: view.samples,
                         ops: conv::map_load_store_ops(at.load_op, at.store_op),
                         stencil_ops: hal::pass::AttachmentOps::DONT_CARE,
@@ -541,7 +547,10 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                     };
 
                     resolves.push(hal::pass::Attachment {
-                        format: Some(conv::map_texture_format(view.format, device.features)),
+                        format: Some(conv::map_texture_format(
+                            view.format,
+                            device.private_features,
+                        )),
                         samples: view.samples,
                         ops: hal::pass::AttachmentOps::new(
                             hal::pass::AttachmentLoadOp::DontCare,
@@ -788,7 +797,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         };
 
         let mut state = State {
-            binder: Binder::new(cmb.features.max_bind_groups),
+            binder: Binder::new(cmb.limits.max_bind_groups),
             blend_color: OptionalState::Unused,
             stencil_reference: OptionalState::Unused,
             pipeline: OptionalState::Required,
diff --git a/wgpu-core/src/command/transfer.rs b/wgpu-core/src/command/transfer.rs
index 62fcb56f8b..e26d5a1865 100644
--- a/wgpu-core/src/command/transfer.rs
+++ b/wgpu-core/src/command/transfer.rs
@@ -153,7 +153,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         assert!(dst_texture.usage.contains(TextureUsage::COPY_DST));
         let dst_barriers = dst_pending.map(|pending| pending.into_hal(dst_texture));
 
-        let bytes_per_texel = conv::map_texture_format(dst_texture.format, cmb.features)
+        let bytes_per_texel = conv::map_texture_format(dst_texture.format, cmb.private_features)
             .surface_desc()
             .bits as u32
             / BITS_PER_BYTE;
@@ -217,7 +217,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         assert!(dst_buffer.usage.contains(BufferUsage::COPY_DST));
         let dst_barrier = dst_barriers.map(|pending| pending.into_hal(dst_buffer));
 
-        let bytes_per_texel = conv::map_texture_format(src_texture.format, cmb.features)
+        let bytes_per_texel = conv::map_texture_format(src_texture.format, cmb.private_features)
             .surface_desc()
             .bits as u32
             / BITS_PER_BYTE;
diff --git a/wgpu-core/src/conv.rs b/wgpu-core/src/conv.rs
index 510ec6c568..5f239c933b 100644
--- a/wgpu-core/src/conv.rs
+++ b/wgpu-core/src/conv.rs
@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use crate::{binding_model, resource, Features};
+use crate::{binding_model, resource, PrivateFeatures};
 
 pub fn map_buffer_usage(usage: wgt::BufferUsage) -> (hal::buffer::Usage, hal::memory::Properties) {
     use hal::buffer::Usage as U;
@@ -321,7 +321,7 @@ fn map_stencil_operation(stencil_operation: wgt::StencilOperation) -> hal::pso::
 
 pub(crate) fn map_texture_format(
     texture_format: wgt::TextureFormat,
-    features: Features,
+    private_features: PrivateFeatures,
 ) -> hal::format::Format {
     use hal::format::Format as H;
     use wgt::TextureFormat as Tf;
@@ -376,14 +376,14 @@ pub(crate) fn map_texture_format(
         // Depth and stencil formats
         Tf::Depth32Float => H::D32Sfloat,
         Tf::Depth24Plus => {
-            if features.supports_texture_d24_s8 {
+            if private_features.supports_texture_d24_s8 {
                 H::D24UnormS8Uint
             } else {
                 H::D32Sfloat
             }
         }
         Tf::Depth24PlusStencil8 => {
-            if features.supports_texture_d24_s8 {
+            if private_features.supports_texture_d24_s8 {
                 H::D24UnormS8Uint
             } else {
                 H::D32SfloatS8Uint
diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs
index 999dbd7279..99beca510a 100644
--- a/wgpu-core/src/device/mod.rs
+++ b/wgpu-core/src/device/mod.rs
@@ -7,7 +7,7 @@ use crate::{
     hub::{GfxBackend, Global, GlobalIdentityHandlerFactory, Input, Token},
     id, pipeline, resource, swap_chain,
     track::{BufferState, TextureState, TrackerSet},
-    FastHashMap, Features, LifeGuard, Stored,
+    FastHashMap, LifeGuard, PrivateFeatures, Stored,
 };
 
 use arrayvec::ArrayVec;
@@ -31,6 +31,8 @@ use std::{
 };
 
 mod life;
+#[cfg(feature = "trace")]
+mod trace;
 
 pub const MAX_COLOR_TARGETS: usize = 4;
 pub const MAX_MIP_LEVELS: usize = 16;
@@ -193,7 +195,10 @@ pub struct Device<B: hal::Backend> {
     // Life tracker should be locked right after the device and before anything else.
     life_tracker: Mutex<life::LifetimeTracker<B>>,
     temp_suspected: life::SuspectedResources,
-    pub(crate) features: Features,
+    pub(crate) private_features: PrivateFeatures,
+    limits: wgt::Limits,
+    #[cfg(feature = "trace")]
+    trace: Option<Mutex<trace::Trace>>,
 }
 
 impl<B: GfxBackend> Device<B> {
@@ -204,7 +209,8 @@ impl<B: GfxBackend> Device<B> {
         mem_props: hal::adapter::MemoryProperties,
         non_coherent_atom_size: u64,
         supports_texture_d24_s8: bool,
-        max_bind_groups: u32,
+        limits: wgt::Limits,
+        #[cfg(feature = "trace")] trace_path: Option<&std::path::Path>,
     ) -> Self {
         // don't start submission index at zero
         let life_guard = LifeGuard::new();
@@ -238,10 +244,18 @@ impl<B: GfxBackend> Device<B> {
             framebuffers: Mutex::new(FastHashMap::default()),
             life_tracker: Mutex::new(life::LifetimeTracker::new()),
             temp_suspected: life::SuspectedResources::default(),
-            features: Features {
-                max_bind_groups,
+            private_features: PrivateFeatures {
                 supports_texture_d24_s8,
             },
+            limits,
+            #[cfg(feature = "trace")]
+            trace: trace_path.and_then(|path| match trace::Trace::new(path) {
+                Ok(trace) => Some(Mutex::new(trace)),
+                Err(e) => {
+                    log::warn!("Unable to start a trace in '{:?}': {:?}", path, e);
+                    None
+                }
+            }),
         }
     }
 
@@ -359,7 +373,7 @@ impl<B: GfxBackend> Device<B> {
         }
 
         let kind = conv::map_texture_dimension_size(desc.dimension, desc.size, desc.sample_count);
-        let format = conv::map_texture_format(desc.format, self.features);
+        let format = conv::map_texture_format(desc.format, self.private_features);
         let aspects = format.surface_desc().aspects;
         let usage = conv::map_texture_usage(desc.usage, aspects);
 
@@ -747,7 +761,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                 .create_image_view(
                     &texture.raw,
                     view_kind,
-                    conv::map_texture_format(format, device.features),
+                    conv::map_texture_format(format, device.private_features),
                     hal::format::Swizzle::NO,
                     range.clone(),
                 )
@@ -975,7 +989,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             slice::from_raw_parts(desc.bind_group_layouts, desc.bind_group_layouts_length)
         };
 
-        assert!(desc.bind_group_layouts_length <= (device.features.max_bind_groups as usize),
+        assert!(desc.bind_group_layouts_length <= (device.limits.max_bind_groups as usize),
             "Cannot set a bind group which is beyond the `max_bind_groups` limit requested on device creation");
 
         // TODO: push constants
@@ -1329,7 +1343,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let mut command_buffer = device.com_allocator.allocate(
             dev_stored,
             &device.raw,
-            device.features,
+            device.limits.clone(),
+            device.private_features,
             lowest_active_index,
         );
         unsafe {
@@ -1697,7 +1712,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                 colors: color_states
                     .iter()
                     .map(|at| hal::pass::Attachment {
-                        format: Some(conv::map_texture_format(at.format, device.features)),
+                        format: Some(conv::map_texture_format(at.format, device.private_features)),
                         samples: sc,
                         ops: hal::pass::AttachmentOps::PRESERVE,
                         stencil_ops: hal::pass::AttachmentOps::DONT_CARE,
@@ -1710,7 +1725,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                 // or depth/stencil resolve modes but satisfy the other compatibility conditions.
                 resolves: ArrayVec::new(),
                 depth_stencil: depth_stencil_state.map(|at| hal::pass::Attachment {
-                    format: Some(conv::map_texture_format(at.format, device.features)),
+                    format: Some(conv::map_texture_format(at.format, device.private_features)),
                     samples: sc,
                     ops: hal::pass::AttachmentOps::PRESERVE,
                     stencil_ops: hal::pass::AttachmentOps::PRESERVE,
@@ -2023,7 +2038,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             .max(*caps.image_count.start())
             .min(*caps.image_count.end());
         let mut config =
-            swap_chain::swap_chain_descriptor_to_hal(&desc, num_frames, device.features);
+            swap_chain::swap_chain_descriptor_to_hal(&desc, num_frames, device.private_features);
         if let Some(formats) = formats {
             assert!(
                 formats.contains(&config.format),
diff --git a/wgpu-core/src/device/trace.rs b/wgpu-core/src/device/trace.rs
new file mode 100644
index 0000000000..3365cf3c7b
--- /dev/null
+++ b/wgpu-core/src/device/trace.rs
@@ -0,0 +1,26 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#[derive(Debug)]
+pub struct Trace {
+    path: std::path::PathBuf,
+    file: std::fs::File,
+}
+
+impl Trace {
+    pub fn new(path: &std::path::Path) -> Result<Self, std::io::Error> {
+        let mut file = std::fs::File::create(path.join("trace.ron"))?;
+        std::io::Write::write(&mut file, b"[\n")?;
+        Ok(Trace {
+            path: path.to_path_buf(),
+            file,
+        })
+    }
+}
+
+impl Drop for Trace {
+    fn drop(&mut self) {
+        let _ = std::io::Write::write(&mut self.file, b"]");
+    }
+}
diff --git a/wgpu-core/src/instance.rs b/wgpu-core/src/instance.rs
index edab05ea19..8346472ce1 100644
--- a/wgpu-core/src/instance.rs
+++ b/wgpu-core/src/instance.rs
@@ -502,6 +502,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         &self,
         adapter_id: AdapterId,
         desc: &DeviceDescriptor,
+        #[cfg(feature = "trace")] trace_path: Option<&std::path::Path>,
         id_in: Input<G, DeviceId>,
     ) -> DeviceId {
         let hub = B::hub(self);
@@ -567,7 +568,9 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                 mem_props,
                 limits.non_coherent_atom_size as u64,
                 supports_texture_d24_s8,
-                desc.limits.max_bind_groups,
+                desc.limits.clone(),
+                #[cfg(feature = "trace")]
+                trace_path,
             )
         };
 
diff --git a/wgpu-core/src/lib.rs b/wgpu-core/src/lib.rs
index 99d7892df8..f6c3373780 100644
--- a/wgpu-core/src/lib.rs
+++ b/wgpu-core/src/lib.rs
@@ -122,8 +122,7 @@ pub struct U32Array {
 }
 
 #[derive(Clone, Copy, Debug)]
-pub(crate) struct Features {
-    pub max_bind_groups: u32,
+struct PrivateFeatures {
     pub supports_texture_d24_s8: bool,
 }
 
diff --git a/wgpu-core/src/swap_chain.rs b/wgpu-core/src/swap_chain.rs
index c7ae49a949..19e2c7dca3 100644
--- a/wgpu-core/src/swap_chain.rs
+++ b/wgpu-core/src/swap_chain.rs
@@ -36,7 +36,7 @@ use crate::{
     conv,
     hub::{GfxBackend, Global, GlobalIdentityHandlerFactory, Input, Token},
     id::{DeviceId, SwapChainId, TextureViewId},
-    resource, Features, LifeGuard, Stored,
+    resource, LifeGuard, PrivateFeatures, Stored,
 };
 
 use hal::{self, device::Device as _, queue::CommandQueue as _, window::PresentationSurface as _};
@@ -59,12 +59,12 @@ pub struct SwapChain<B: hal::Backend> {
 pub(crate) fn swap_chain_descriptor_to_hal(
     desc: &SwapChainDescriptor,
     num_frames: u32,
-    features: Features,
+    private_features: PrivateFeatures,
 ) -> hal::window::SwapchainConfig {
     let mut config = hal::window::SwapchainConfig::new(
         desc.width,
         desc.height,
-        conv::map_texture_format(desc.format, features),
+        conv::map_texture_format(desc.format, private_features),
         num_frames,
     );
     //TODO: check for supported
@@ -114,8 +114,11 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                 }
                 Err(e) => {
                     log::warn!("acquire_image() failed ({:?}), reconfiguring swapchain", e);
-                    let desc =
-                        swap_chain_descriptor_to_hal(&sc.desc, sc.num_frames, device.features);
+                    let desc = swap_chain_descriptor_to_hal(
+                        &sc.desc,
+                        sc.num_frames,
+                        device.private_features,
+                    );
                     unsafe {
                         suf.configure_swapchain(&device.raw, desc).unwrap();
                         suf.acquire_image(FRAME_TIMEOUT_MS * 1_000_000).unwrap()

From 00751ab017eca01763dab067447a121418a2bb1b Mon Sep 17 00:00:00 2001
From: Dzmitry Malyshau <kvarkus@gmail.com>
Date: Mon, 27 Apr 2020 22:41:43 -0400
Subject: [PATCH 03/12] trace: hook up RON output

---
 wgpu-core/Cargo.toml          |  3 ++-
 wgpu-core/src/device/mod.rs   | 21 ++++++++++++++-------
 wgpu-core/src/device/trace.rs | 25 +++++++++++++++++++++++--
 wgpu-core/src/hub.rs          | 14 +++++---------
 4 files changed, 44 insertions(+), 19 deletions(-)

diff --git a/wgpu-core/Cargo.toml b/wgpu-core/Cargo.toml
index 494c80ae30..c6ad0c8321 100644
--- a/wgpu-core/Cargo.toml
+++ b/wgpu-core/Cargo.toml
@@ -16,7 +16,7 @@ license = "MPL-2.0"
 
 [features]
 default = []
-trace = ["serde", "wgt/trace"]
+trace = ["ron", "serde", "wgt/trace"]
 replay = ["serde", "wgt/replay"]
 metal-auto-capture = ["gfx-backend-metal/auto-capture"]
 #NOTE: glutin feature is not stable, use at your own risk
@@ -34,6 +34,7 @@ gfx-descriptor = "0.1"
 gfx-memory = "0.1"
 parking_lot = "0.10"
 peek-poke = "0.2"
+ron = { version = "0.5", optional = true }
 serde = { version = "1.0", features = ["serde_derive"], optional = true }
 smallvec = "1"
 vec_map = "0.8"
diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs
index 99beca510a..f220877ac5 100644
--- a/wgpu-core/src/device/mod.rs
+++ b/wgpu-core/src/device/mod.rs
@@ -33,6 +33,8 @@ use std::{
 mod life;
 #[cfg(feature = "trace")]
 mod trace;
+#[cfg(feature = "trace")]
+use trace::{Action, Trace};
 
 pub const MAX_COLOR_TARGETS: usize = 4;
 pub const MAX_MIP_LEVELS: usize = 16;
@@ -198,7 +200,7 @@ pub struct Device<B: hal::Backend> {
     pub(crate) private_features: PrivateFeatures,
     limits: wgt::Limits,
     #[cfg(feature = "trace")]
-    trace: Option<Mutex<trace::Trace>>,
+    trace: Option<Mutex<Trace>>,
 }
 
 impl<B: GfxBackend> Device<B> {
@@ -244,18 +246,23 @@ impl<B: GfxBackend> Device<B> {
             framebuffers: Mutex::new(FastHashMap::default()),
             life_tracker: Mutex::new(life::LifetimeTracker::new()),
             temp_suspected: life::SuspectedResources::default(),
-            private_features: PrivateFeatures {
-                supports_texture_d24_s8,
-            },
-            limits,
             #[cfg(feature = "trace")]
-            trace: trace_path.and_then(|path| match trace::Trace::new(path) {
-                Ok(trace) => Some(Mutex::new(trace)),
+            trace: trace_path.and_then(|path| match Trace::new(path) {
+                Ok(mut trace) => {
+                    trace.add(Action::Init {
+                        limits: limits.clone(),
+                    });
+                    Some(Mutex::new(trace))
+                }
                 Err(e) => {
                     log::warn!("Unable to start a trace in '{:?}': {:?}", path, e);
                     None
                 }
             }),
+            private_features: PrivateFeatures {
+                supports_texture_d24_s8,
+            },
+            limits,
         }
     }
 
diff --git a/wgpu-core/src/device/trace.rs b/wgpu-core/src/device/trace.rs
index 3365cf3c7b..1a8ad07663 100644
--- a/wgpu-core/src/device/trace.rs
+++ b/wgpu-core/src/device/trace.rs
@@ -2,25 +2,46 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use std::io::Write as _;
+
+#[derive(serde::Serialize)]
+pub enum Action {
+    Init { limits: wgt::Limits },
+}
+
 #[derive(Debug)]
 pub struct Trace {
     path: std::path::PathBuf,
     file: std::fs::File,
+    config: ron::ser::PrettyConfig,
 }
 
 impl Trace {
     pub fn new(path: &std::path::Path) -> Result<Self, std::io::Error> {
+        log::info!("Tracing into '{:?}'", path);
         let mut file = std::fs::File::create(path.join("trace.ron"))?;
-        std::io::Write::write(&mut file, b"[\n")?;
+        file.write(b"[\n")?;
         Ok(Trace {
             path: path.to_path_buf(),
             file,
+            config: ron::ser::PrettyConfig::default(),
         })
     }
+
+    pub fn add(&mut self, action: Action) {
+        match ron::ser::to_string_pretty(&action, self.config.clone()) {
+            Ok(string) => {
+                let _ = write!(self.file, "{},\n", string);
+            }
+            Err(e) => {
+                log::warn!("RON serialization failure: {:?}", e);
+            }
+        }
+    }
 }
 
 impl Drop for Trace {
     fn drop(&mut self) {
-        let _ = std::io::Write::write(&mut self.file, b"]");
+        let _ = self.file.write(b"]");
     }
 }
diff --git a/wgpu-core/src/hub.rs b/wgpu-core/src/hub.rs
index 3e0f759cb8..2d1ef24a59 100644
--- a/wgpu-core/src/hub.rs
+++ b/wgpu-core/src/hub.rs
@@ -545,17 +545,13 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             hubs: Hubs::new(&factory),
         }
     }
+}
 
-    pub fn delete(self) {
-        let Global {
-            mut instance,
-            surfaces,
-            hubs,
-        } = self;
-        drop(hubs);
+impl<G: GlobalIdentityHandlerFactory> Drop for Global<G> {
+    fn drop(&mut self) {
         // destroy surfaces
-        for (_, (surface, _)) in surfaces.data.write().map.drain() {
-            instance.destroy_surface(surface);
+        for (_, (surface, _)) in self.surfaces.data.write().map.drain() {
+            self.instance.destroy_surface(surface);
         }
     }
 }

From 6ade9fed83682656af5c3c64809d3b1075af3086 Mon Sep 17 00:00:00 2001
From: Dzmitry Malyshau <kvarkus@gmail.com>
Date: Tue, 28 Apr 2020 13:54:57 -0400
Subject: [PATCH 04/12] Make descriptors generic over Label

---
 wgpu-core/src/device/mod.rs   | 66 +++++++++++++++++++++++++-----
 wgpu-core/src/device/trace.rs | 30 +++++++++++++-
 wgpu-core/src/swap_chain.rs   | 19 +++++++++
 wgpu-types/src/lib.rs         | 76 +++++++++++++++++++++++++++++++----
 4 files changed, 174 insertions(+), 17 deletions(-)

diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs
index f220877ac5..5b24a82a84 100644
--- a/wgpu-core/src/device/mod.rs
+++ b/wgpu-core/src/device/mod.rs
@@ -32,10 +32,22 @@ use std::{
 
 mod life;
 #[cfg(feature = "trace")]
-mod trace;
+pub(crate) mod trace;
 #[cfg(feature = "trace")]
 use trace::{Action, Trace};
 
+pub type Label = *const std::os::raw::c_char;
+#[cfg(feature = "trace")]
+fn own_label(label: &Label) -> String {
+    if label.is_null() {
+        String::new()
+    } else {
+        unsafe { ffi::CStr::from_ptr(*label) }
+            .to_string_lossy()
+            .to_string()
+    }
+}
+
 pub const MAX_COLOR_TARGETS: usize = 4;
 pub const MAX_MIP_LEVELS: usize = 16;
 pub const MAX_VERTEX_BUFFERS: usize = 16;
@@ -200,7 +212,7 @@ pub struct Device<B: hal::Backend> {
     pub(crate) private_features: PrivateFeatures,
     limits: wgt::Limits,
     #[cfg(feature = "trace")]
-    trace: Option<Mutex<Trace>>,
+    pub(crate) trace: Option<Mutex<Trace>>,
 }
 
 impl<B: GfxBackend> Device<B> {
@@ -293,7 +305,7 @@ impl<B: GfxBackend> Device<B> {
     fn create_buffer(
         &self,
         self_id: id::DeviceId,
-        desc: &wgt::BufferDescriptor,
+        desc: &wgt::BufferDescriptor<Label>,
     ) -> resource::Buffer<B> {
         use gfx_memory::{Kind, MemoryUsage};
 
@@ -365,7 +377,7 @@ impl<B: GfxBackend> Device<B> {
     fn create_texture(
         &self,
         self_id: id::DeviceId,
-        desc: &wgt::TextureDescriptor,
+        desc: &wgt::TextureDescriptor<Label>,
     ) -> resource::Texture<B> {
         debug_assert_eq!(self_id.backend(), B::VARIANT);
 
@@ -500,7 +512,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
     pub fn device_create_buffer<B: GfxBackend>(
         &self,
         device_id: id::DeviceId,
-        desc: &wgt::BufferDescriptor,
+        desc: &wgt::BufferDescriptor<Label>,
         id_in: Input<G, id::BufferId>,
     ) -> id::BufferId {
         let hub = B::hub(self);
@@ -515,6 +527,15 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
 
         let id = hub.buffers.register_identity(id_in, buffer, &mut token);
         log::info!("Created buffer {:?} with {:?}", id, desc);
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace.lock().add(trace::Action::CreateBuffer {
+                id,
+                desc: desc.map_label(own_label),
+            }),
+            None => (),
+        };
+
         device
             .trackers
             .lock()
@@ -531,7 +552,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
     pub fn device_create_buffer_mapped<B: GfxBackend>(
         &self,
         device_id: id::DeviceId,
-        desc: &wgt::BufferDescriptor,
+        desc: &wgt::BufferDescriptor<Label>,
         id_in: Input<G, id::BufferId>,
     ) -> (id::BufferId, *mut u8) {
         let hub = B::hub(self);
@@ -675,7 +696,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
     pub fn device_create_texture<B: GfxBackend>(
         &self,
         device_id: id::DeviceId,
-        desc: &wgt::TextureDescriptor,
+        desc: &wgt::TextureDescriptor<Label>,
         id_in: Input<G, id::TextureId>,
     ) -> id::TextureId {
         let hub = B::hub(self);
@@ -688,6 +709,15 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let ref_count = texture.life_guard.add_ref();
 
         let id = hub.textures.register_identity(id_in, texture, &mut token);
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace.lock().add(trace::Action::CreateTexture {
+                id,
+                desc: desc.map_label(own_label),
+            }),
+            None => (),
+        };
+
         device
             .trackers
             .lock()
@@ -719,7 +749,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
     pub fn texture_create_view<B: GfxBackend>(
         &self,
         texture_id: id::TextureId,
-        desc: Option<&wgt::TextureViewDescriptor>,
+        desc: Option<&wgt::TextureViewDescriptor<Label>>,
         id_in: Input<G, id::TextureViewId>,
     ) -> id::TextureViewId {
         let hub = B::hub(self);
@@ -832,7 +862,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
     pub fn device_create_sampler<B: GfxBackend>(
         &self,
         device_id: id::DeviceId,
-        desc: &wgt::SamplerDescriptor,
+        desc: &wgt::SamplerDescriptor<Label>,
         id_in: Input<G, id::SamplerId>,
     ) -> id::SamplerId {
         let hub = B::hub(self);
@@ -868,6 +898,15 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let ref_count = sampler.life_guard.add_ref();
 
         let id = hub.samplers.register_identity(id_in, sampler, &mut token);
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace.lock().add(trace::Action::CreateSampler {
+                id,
+                desc: desc.map_label(own_label),
+            }),
+            None => (),
+        };
+
         device
             .trackers
             .lock()
@@ -2068,6 +2107,15 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                 device.raw.destroy_semaphore(sc.semaphore);
             }
         }
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace.lock().add(Action::CreateSwapChain {
+                id: sc_id,
+                desc: desc.clone(),
+            }),
+            None => (),
+        };
+
         let swap_chain = swap_chain::SwapChain {
             life_guard: LifeGuard::new(),
             device_id: Stored {
diff --git a/wgpu-core/src/device/trace.rs b/wgpu-core/src/device/trace.rs
index 1a8ad07663..4ee0665f2e 100644
--- a/wgpu-core/src/device/trace.rs
+++ b/wgpu-core/src/device/trace.rs
@@ -2,11 +2,39 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use crate::id;
 use std::io::Write as _;
 
+//TODO: consider a readable Id that doesn't include the backend
+
 #[derive(serde::Serialize)]
 pub enum Action {
-    Init { limits: wgt::Limits },
+    Init {
+        limits: wgt::Limits,
+    },
+    CreateBuffer {
+        id: id::BufferId,
+        desc: wgt::BufferDescriptor<String>,
+    },
+    CreateTexture {
+        id: id::TextureId,
+        desc: wgt::TextureDescriptor<String>,
+    },
+    CreateSampler {
+        id: id::SamplerId,
+        desc: wgt::SamplerDescriptor<String>,
+    },
+    CreateSwapChain {
+        id: id::SwapChainId,
+        desc: wgt::SwapChainDescriptor,
+    },
+    GetSwapChainTexture {
+        object_id: id::SwapChainId,
+        view_id: id::TextureViewId,
+    },
+    PresentSwapChain {
+        object_id: id::SwapChainId,
+    },
 }
 
 #[derive(Debug)]
diff --git a/wgpu-core/src/swap_chain.rs b/wgpu-core/src/swap_chain.rs
index 19e2c7dca3..2d0aabc27d 100644
--- a/wgpu-core/src/swap_chain.rs
+++ b/wgpu-core/src/swap_chain.rs
@@ -32,6 +32,8 @@
     In `present()` we return the swap chain image back and wait on the semaphore.
 !*/
 
+#[cfg(feature = "trace")]
+use crate::device::trace::Action;
 use crate::{
     conv,
     hub::{GfxBackend, Global, GlobalIdentityHandlerFactory, Input, Token},
@@ -154,6 +156,15 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             .texture_views
             .register_identity(view_id_in, view, &mut token);
 
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace.lock().add(Action::GetSwapChainTexture {
+                object_id: swap_chain_id,
+                view_id: id,
+            }),
+            None => (),
+        };
+
         assert!(
             sc.acquired_view_id.is_none(),
             "Swap chain image is already acquired"
@@ -177,6 +188,14 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let sc = &mut swap_chain_guard[swap_chain_id];
         let device = &mut device_guard[sc.device_id.value];
 
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace.lock().add(Action::PresentSwapChain {
+                object_id: swap_chain_id,
+            }),
+            None => (),
+        };
+
         let view_id = sc
             .acquired_view_id
             .take()
diff --git a/wgpu-types/src/lib.rs b/wgpu-types/src/lib.rs
index afb44f6553..5394aa473e 100644
--- a/wgpu-types/src/lib.rs
+++ b/wgpu-types/src/lib.rs
@@ -541,7 +541,7 @@ pub enum VertexFormat {
 bitflags::bitflags! {
     #[repr(transparent)]
     #[cfg_attr(feature = "trace", derive(Serialize))]
-#[cfg_attr(feature = "replay", derive(Deserialize))]
+    #[cfg_attr(feature = "replay", derive(Deserialize))]
     pub struct BufferUsage: u32 {
         const MAP_READ = 1;
         const MAP_WRITE = 2;
@@ -557,12 +557,24 @@ bitflags::bitflags! {
 
 #[repr(C)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct BufferDescriptor {
-    pub label: *const std::os::raw::c_char,
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+pub struct BufferDescriptor<L> {
+    pub label: L,
     pub size: BufferAddress,
     pub usage: BufferUsage,
 }
 
+impl<L> BufferDescriptor<L> {
+    pub fn map_label<K>(&self, fun: impl FnOnce(&L) -> K) -> BufferDescriptor<K> {
+        BufferDescriptor {
+            label: fun(&self.label),
+            size: self.size,
+            usage: self.usage,
+        }
+    }
+}
+
 #[repr(C)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct CommandEncoderDescriptor {
@@ -767,8 +779,10 @@ pub struct Extent3d {
 
 #[repr(C)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct TextureDescriptor {
-    pub label: *const std::os::raw::c_char,
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+pub struct TextureDescriptor<L> {
+    pub label: L,
     pub size: Extent3d,
     pub mip_level_count: u32,
     pub sample_count: u32,
@@ -777,6 +791,20 @@ pub struct TextureDescriptor {
     pub usage: TextureUsage,
 }
 
+impl<L> TextureDescriptor<L> {
+    pub fn map_label<K>(&self, fun: impl FnOnce(&L) -> K) -> TextureDescriptor<K> {
+        TextureDescriptor {
+            label: fun(&self.label),
+            size: self.size,
+            mip_level_count: self.mip_level_count,
+            sample_count: self.sample_count,
+            dimension: self.dimension,
+            format: self.format,
+            usage: self.usage,
+        }
+    }
+}
+
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "trace", derive(Serialize))]
@@ -797,7 +825,8 @@ impl Default for TextureAspect {
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "trace", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
-pub struct TextureViewDescriptor {
+pub struct TextureViewDescriptor<L> {
+    pub label: L,
     pub format: TextureFormat,
     pub dimension: TextureViewDimension,
     pub aspect: TextureAspect,
@@ -807,6 +836,21 @@ pub struct TextureViewDescriptor {
     pub array_layer_count: u32,
 }
 
+impl<L> TextureViewDescriptor<L> {
+    pub fn map_label<K>(&self, fun: impl FnOnce(&L) -> K) -> TextureViewDescriptor<K> {
+        TextureViewDescriptor {
+            label: fun(&self.label),
+            format: self.format,
+            dimension: self.dimension,
+            aspect: self.aspect,
+            base_mip_level: self.base_mip_level,
+            level_count: self.level_count,
+            base_array_layer: self.base_array_layer,
+            array_layer_count: self.array_layer_count,
+        }
+    }
+}
+
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "trace", derive(Serialize))]
@@ -842,7 +886,8 @@ impl Default for FilterMode {
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "trace", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
-pub struct SamplerDescriptor {
+pub struct SamplerDescriptor<L> {
+    pub label: L,
     pub address_mode_u: AddressMode,
     pub address_mode_v: AddressMode,
     pub address_mode_w: AddressMode,
@@ -854,6 +899,23 @@ pub struct SamplerDescriptor {
     pub compare: CompareFunction,
 }
 
+impl<L> SamplerDescriptor<L> {
+    pub fn map_label<K>(&self, fun: impl FnOnce(&L) -> K) -> SamplerDescriptor<K> {
+        SamplerDescriptor {
+            label: fun(&self.label),
+            address_mode_u: self.address_mode_u,
+            address_mode_v: self.address_mode_v,
+            address_mode_w: self.address_mode_w,
+            mag_filter: self.mag_filter,
+            min_filter: self.min_filter,
+            mipmap_filter: self.mipmap_filter,
+            lod_min_clamp: self.lod_min_clamp,
+            lod_max_clamp: self.lod_max_clamp,
+            compare: self.compare,
+        }
+    }
+}
+
 #[repr(C)]
 #[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "trace", derive(Serialize))]

From db1807dfb9173362ece6fbaa845b82ab8ba0c172 Mon Sep 17 00:00:00 2001
From: Dzmitry Malyshau <kvarkus@gmail.com>
Date: Tue, 28 Apr 2020 18:23:21 -0400
Subject: [PATCH 05/12] trace: bind groups, shaders, and buffer contents

---
 wgpu-core/src/device/life.rs  |  20 ++-
 wgpu-core/src/device/mod.rs   | 280 +++++++++++++++++++++++++++-------
 wgpu-core/src/device/trace.rs |  66 +++++++-
 wgpu-core/src/resource.rs     |   8 +-
 wgpu-core/src/swap_chain.rs   |   8 +-
 5 files changed, 307 insertions(+), 75 deletions(-)

diff --git a/wgpu-core/src/device/life.rs b/wgpu-core/src/device/life.rs
index 765193adba..31a4eca3e0 100644
--- a/wgpu-core/src/device/life.rs
+++ b/wgpu-core/src/device/life.rs
@@ -598,20 +598,24 @@ impl<B: GfxBackend> LifetimeTracker<B> {
             } else {
                 let mapping = match std::mem::replace(
                     &mut buffer.map_state,
-                    resource::BufferMapState::Active,
+                    resource::BufferMapState::Idle,
                 ) {
                     resource::BufferMapState::Waiting(pending_mapping) => pending_mapping,
                     _ => panic!("No pending mapping."),
                 };
                 log::debug!("Buffer {:?} map state -> Active", buffer_id);
-                let result = match mapping.op {
-                    resource::BufferMapOperation::Read { .. } => {
-                        super::map_buffer(raw, buffer, mapping.sub_range, super::HostMap::Read)
-                    }
-                    resource::BufferMapOperation::Write { .. } => {
-                        super::map_buffer(raw, buffer, mapping.sub_range, super::HostMap::Write)
-                    }
+                let host = match mapping.op {
+                    resource::BufferMapOperation::Read { .. } => super::HostMap::Read,
+                    resource::BufferMapOperation::Write { .. } => super::HostMap::Write,
                 };
+                let result = super::map_buffer(raw, buffer, mapping.sub_range.clone(), host);
+                if let Ok(ptr) = result {
+                    buffer.map_state = resource::BufferMapState::Active {
+                        ptr,
+                        sub_range: mapping.sub_range,
+                        host,
+                    };
+                }
                 pending_callbacks.push((mapping.op, result));
             }
         }
diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs
index 5b24a82a84..22ed28c639 100644
--- a/wgpu-core/src/device/mod.rs
+++ b/wgpu-core/src/device/mod.rs
@@ -125,50 +125,38 @@ fn map_buffer<B: hal::Backend>(
     sub_range: hal::buffer::SubRange,
     kind: HostMap,
 ) -> BufferMapResult {
-    let (ptr, sync_range) = {
+    let (ptr, segment, needs_sync) = {
         let segment = hal::memory::Segment {
             offset: sub_range.offset,
             size: sub_range.size,
         };
         let mapped = buffer.memory.map(raw, segment)?;
-        let sync_range = if mapped.is_coherent() {
-            None
-        } else {
-            Some(mapped.range())
+        let mr = mapped.range();
+        let segment = hal::memory::Segment {
+            offset: mr.start,
+            size: Some(mr.end - mr.start),
         };
-        (mapped.ptr(), sync_range)
+        (mapped.ptr(), segment, !mapped.is_coherent())
     };
 
-    if let Some(range) = sync_range {
-        let segment = hal::memory::Segment {
-            offset: range.start,
-            size: Some(range.end - range.start),
-        };
-        match kind {
-            HostMap::Read => unsafe {
-                raw.invalidate_mapped_memory_ranges(iter::once((buffer.memory.memory(), segment)))
-                    .unwrap();
-            },
-            HostMap::Write => {
-                buffer.mapped_write_segments.push(segment);
-            }
-        }
-    }
+    buffer.sync_mapped_writes = match kind {
+        HostMap::Read if needs_sync => unsafe {
+            raw.invalidate_mapped_memory_ranges(iter::once((buffer.memory.memory(), segment)))
+                .unwrap();
+            None
+        },
+        HostMap::Write if needs_sync => Some(segment),
+        _ => None,
+    };
     Ok(ptr.as_ptr())
 }
 
 fn unmap_buffer<B: hal::Backend>(raw: &B::Device, buffer: &mut resource::Buffer<B>) {
-    if !buffer.mapped_write_segments.is_empty() {
+    if let Some(segment) = buffer.sync_mapped_writes.take() {
         unsafe {
-            raw.flush_mapped_memory_ranges(
-                buffer
-                    .mapped_write_segments
-                    .iter()
-                    .map(|r| (buffer.memory.memory(), r.clone())),
-            )
-            .unwrap()
+            raw.flush_mapped_memory_ranges(iter::once((buffer.memory.memory(), segment)))
+                .unwrap()
         };
-        buffer.mapped_write_segments.clear();
     }
 }
 
@@ -368,7 +356,7 @@ impl<B: GfxBackend> Device<B> {
             memory,
             size: desc.size,
             full_range: (),
-            mapped_write_segments: Vec::new(),
+            sync_mapped_writes: None,
             map_state: resource::BufferMapState::Idle,
             life_guard: LifeGuard::new(),
         }
@@ -572,7 +560,11 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             HostMap::Write,
         ) {
             Ok(ptr) => {
-                buffer.map_state = resource::BufferMapState::Active;
+                buffer.map_state = resource::BufferMapState::Active {
+                    ptr,
+                    sub_range: hal::buffer::SubRange::WHOLE,
+                    host: HostMap::Write,
+                };
                 ptr
             }
             Err(e) => {
@@ -614,6 +606,20 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         assert!(buffer.usage.contains(wgt::BufferUsage::MAP_WRITE));
         //assert!(buffer isn't used by the GPU);
 
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => {
+                let mut trace = trace.lock();
+                let data_path = trace.make_binary("buffer", data);
+                trace.add(trace::Action::WriteBuffer {
+                    id: buffer_id,
+                    data: data_path,
+                    range: offset..offset + data.len() as BufferAddress,
+                });
+            }
+            None => (),
+        };
+
         match map_buffer(
             &device.raw,
             &mut buffer,
@@ -686,7 +692,14 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         };
 
         let (device_guard, mut token) = hub.devices.read(&mut token);
-        device_guard[device_id]
+        let device = &device_guard[device_id];
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace.lock().add(trace::Action::DestroyBuffer(buffer_id)),
+            None => (),
+        };
+
+        device
             .lock_life(&mut token)
             .suspected_resources
             .buffers
@@ -739,7 +752,14 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         };
 
         let (device_guard, mut token) = hub.devices.read(&mut token);
-        device_guard[device_id]
+        let device = &device_guard[device_id];
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace.lock().add(trace::Action::DestroyTexture(texture_id)),
+            None => (),
+        };
+
+        device
             .lock_life(&mut token)
             .suspected_resources
             .textures
@@ -822,6 +842,16 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let ref_count = view.life_guard.add_ref();
 
         let id = hub.texture_views.register_identity(id_in, view, &mut token);
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace.lock().add(trace::Action::CreateTextureView {
+                id,
+                parent_id: texture_id,
+                desc: desc.map(|d| d.map_label(own_label)),
+            }),
+            None => (),
+        };
+
         device
             .trackers
             .lock()
@@ -852,7 +882,16 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         };
 
         let (device_guard, mut token) = hub.devices.read(&mut token);
-        device_guard[device_id]
+        let device = &device_guard[device_id];
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace
+                .lock()
+                .add(trace::Action::DestroyTextureView(texture_view_id)),
+            None => (),
+        };
+
+        device
             .lock_life(&mut token)
             .suspected_resources
             .texture_views
@@ -928,7 +967,14 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         };
 
         let (device_guard, mut token) = hub.devices.read(&mut token);
-        device_guard[device_id]
+        let device = &device_guard[device_id];
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace.lock().add(trace::Action::DestroySampler(sampler_id)),
+            None => (),
+        };
+
+        device
             .lock_life(&mut token)
             .suspected_resources
             .samplers
@@ -999,8 +1045,19 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             dynamic_count: entries.iter().filter(|b| b.has_dynamic_offset).count(),
         };
 
-        hub.bind_group_layouts
-            .register_identity(id_in, layout, &mut token)
+        let id = hub
+            .bind_group_layouts
+            .register_identity(id_in, layout, &mut token);
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace.lock().add(trace::Action::CreateBindGroupLayout {
+                id,
+                label: own_label(&desc.label),
+                entries: entries.to_owned(),
+            }),
+            None => (),
+        };
+        id
     }
 
     pub fn bind_group_layout_destroy<B: GfxBackend>(
@@ -1013,10 +1070,17 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let (bgl, _) = hub
             .bind_group_layouts
             .unregister(bind_group_layout_id, &mut token);
+
+        let device = &device_guard[bgl.device_id.value];
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace
+                .lock()
+                .add(trace::Action::DestroyBindGroupLayout(bind_group_layout_id)),
+            None => (),
+        };
         unsafe {
-            device_guard[bgl.device_id.value]
-                .raw
-                .destroy_descriptor_set_layout(bgl.raw);
+            device.raw.destroy_descriptor_set_layout(bgl.raw);
         }
     }
 
@@ -1061,8 +1125,19 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             life_guard: LifeGuard::new(),
             bind_group_layout_ids: bind_group_layout_ids.iter().cloned().collect(),
         };
-        hub.pipeline_layouts
-            .register_identity(id_in, layout, &mut token)
+
+        let id = hub
+            .pipeline_layouts
+            .register_identity(id_in, layout, &mut token);
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace.lock().add(trace::Action::CreatePipelineLayout {
+                id,
+                bind_group_layouts: bind_group_layout_ids.to_owned(),
+            }),
+            None => (),
+        };
+        id
     }
 
     pub fn pipeline_layout_destroy<B: GfxBackend>(&self, pipeline_layout_id: id::PipelineLayoutId) {
@@ -1078,7 +1153,16 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         };
 
         let (device_guard, mut token) = hub.devices.read(&mut token);
-        device_guard[device_id]
+        let device = &device_guard[device_id];
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace
+                .lock()
+                .add(trace::Action::DestroyPipelineLayout(pipeline_layout_id)),
+            None => (),
+        };
+
+        device
             .lock_life(&mut token)
             .suspected_resources
             .pipeline_layouts
@@ -1301,6 +1385,36 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             id,
             hub.bind_groups.read(&mut token).0[id].used
         );
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace.lock().add(trace::Action::CreateBindGroup {
+                id,
+                label: own_label(&desc.label),
+                layout_id: desc.layout,
+                entries: entries
+                    .iter()
+                    .map(|entry| {
+                        let res = match entry.resource {
+                            binding_model::BindingResource::Buffer(ref b) => {
+                                trace::BindingResource::Buffer {
+                                    id: b.buffer,
+                                    offset: b.offset,
+                                    size: b.size,
+                                }
+                            }
+                            binding_model::BindingResource::TextureView(id) => {
+                                trace::BindingResource::TextureView(id)
+                            }
+                            binding_model::BindingResource::Sampler(id) => {
+                                trace::BindingResource::Sampler(id)
+                            }
+                        };
+                        (entry.binding, res)
+                    })
+                    .collect(),
+            }),
+            None => (),
+        };
 
         device
             .trackers
@@ -1323,7 +1437,16 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         };
 
         let (device_guard, mut token) = hub.devices.read(&mut token);
-        device_guard[device_id]
+        let device = &device_guard[device_id];
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace
+                .lock()
+                .add(trace::Action::DestroyBindGroup(bind_group_id)),
+            None => (),
+        };
+
+        device
             .lock_life(&mut token)
             .suspected_resources
             .bind_groups
@@ -1351,8 +1474,21 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             },
         };
 
-        hub.shader_modules
-            .register_identity(id_in, shader, &mut token)
+        let id = hub
+            .shader_modules
+            .register_identity(id_in, shader, &mut token);
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => {
+                let mut trace = trace.lock();
+                let data = trace.make_binary("shader", unsafe {
+                    slice::from_raw_parts(desc.code.bytes as *const u8, desc.code.length * 4)
+                });
+                trace.add(trace::Action::CreateShaderModule { id, data });
+            }
+            None => {}
+        };
+        id
     }
 
     pub fn shader_module_destroy<B: GfxBackend>(&self, shader_module_id: id::ShaderModuleId) {
@@ -1360,10 +1496,18 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let mut token = Token::root();
         let (device_guard, mut token) = hub.devices.read(&mut token);
         let (module, _) = hub.shader_modules.unregister(shader_module_id, &mut token);
+
+        let device = &device_guard[module.device_id.value];
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace
+                .lock()
+                .add(trace::Action::DestroyShaderModule(shader_module_id)),
+            None => (),
+        };
+
         unsafe {
-            device_guard[module.device_id.value]
-                .raw
-                .destroy_shader_module(module.raw);
+            device.raw.destroy_shader_module(module.raw);
         }
     }
 
@@ -1539,7 +1683,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                         panic!("Buffer has a pending mapping.");
                     }
                     if !buffer_guard[id].life_guard.use_at(submit_index) {
-                        if let resource::BufferMapState::Active = buffer_guard[id].map_state {
+                        if let resource::BufferMapState::Active { .. } = buffer_guard[id].map_state
+                        {
                             log::warn!("Dropped buffer has a pending mapping.");
                             unmap_buffer(&device.raw, &mut buffer_guard[id]);
                         }
@@ -2208,7 +2353,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
 
             assert!(buffer.usage.contains(pub_usage));
             buffer.map_state = match buffer.map_state {
-                resource::BufferMapState::Active => panic!("Buffer already mapped"),
+                resource::BufferMapState::Active { .. } => panic!("Buffer already mapped"),
                 resource::BufferMapState::Waiting(_) => {
                     operation.call_error();
                     return;
@@ -2253,10 +2398,35 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             resource::BufferMapState::Idle => {
                 log::error!("Buffer already unmapped");
             }
-            _ => {
-                buffer.map_state = resource::BufferMapState::Idle;
-                unmap_buffer(&device_guard[buffer.device_id.value].raw, buffer);
+            resource::BufferMapState::Waiting(_) => {}
+            resource::BufferMapState::Active {
+                ptr,
+                ref sub_range,
+                host,
+            } => {
+                let device = &device_guard[buffer.device_id.value];
+                if host == HostMap::Write {
+                    #[cfg(feature = "trace")]
+                    match device.trace {
+                        Some(ref trace) => {
+                            let mut trace = trace.lock();
+                            let size = sub_range.size_to(buffer.size);
+                            let data = trace.make_binary("buffer", unsafe {
+                                slice::from_raw_parts(ptr, size as usize)
+                            });
+                            trace.add(trace::Action::WriteBuffer {
+                                id: buffer_id,
+                                data,
+                                range: sub_range.offset..sub_range.offset + size,
+                            });
+                        }
+                        None => (),
+                    };
+                    let _ = (ptr, sub_range);
+                }
+                unmap_buffer(&device.raw, buffer);
             }
         }
+        buffer.map_state = resource::BufferMapState::Idle;
     }
 }
diff --git a/wgpu-core/src/device/trace.rs b/wgpu-core/src/device/trace.rs
index 4ee0665f2e..48c6d9c88a 100644
--- a/wgpu-core/src/device/trace.rs
+++ b/wgpu-core/src/device/trace.rs
@@ -3,9 +3,21 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use crate::id;
-use std::io::Write as _;
+use std::{io::Write as _, ops::Range};
 
 //TODO: consider a readable Id that doesn't include the backend
+type FileName = String;
+
+#[derive(serde::Serialize)]
+pub enum BindingResource {
+    Buffer {
+        id: id::BufferId,
+        offset: wgt::BufferAddress,
+        size: wgt::BufferAddress,
+    },
+    Sampler(id::SamplerId),
+    TextureView(id::TextureViewId),
+}
 
 #[derive(serde::Serialize)]
 pub enum Action {
@@ -16,24 +28,59 @@ pub enum Action {
         id: id::BufferId,
         desc: wgt::BufferDescriptor<String>,
     },
+    DestroyBuffer(id::BufferId),
     CreateTexture {
         id: id::TextureId,
         desc: wgt::TextureDescriptor<String>,
     },
+    DestroyTexture(id::TextureId),
+    CreateTextureView {
+        id: id::TextureViewId,
+        parent_id: id::TextureId,
+        desc: Option<wgt::TextureViewDescriptor<String>>,
+    },
+    DestroyTextureView(id::TextureViewId),
     CreateSampler {
         id: id::SamplerId,
         desc: wgt::SamplerDescriptor<String>,
     },
+    DestroySampler(id::SamplerId),
     CreateSwapChain {
         id: id::SwapChainId,
         desc: wgt::SwapChainDescriptor,
     },
     GetSwapChainTexture {
-        object_id: id::SwapChainId,
-        view_id: id::TextureViewId,
+        id: id::TextureViewId,
+        parent_id: id::SwapChainId,
+    },
+    PresentSwapChain(id::SwapChainId),
+    CreateBindGroupLayout {
+        id: id::BindGroupLayoutId,
+        label: String,
+        entries: Vec<crate::binding_model::BindGroupLayoutEntry>,
     },
-    PresentSwapChain {
-        object_id: id::SwapChainId,
+    DestroyBindGroupLayout(id::BindGroupLayoutId),
+    CreatePipelineLayout {
+        id: id::PipelineLayoutId,
+        bind_group_layouts: Vec<id::BindGroupLayoutId>,
+    },
+    DestroyPipelineLayout(id::PipelineLayoutId),
+    CreateBindGroup {
+        id: id::BindGroupId,
+        label: String,
+        layout_id: id::BindGroupLayoutId,
+        entries: std::collections::BTreeMap<u32, BindingResource>,
+    },
+    DestroyBindGroup(id::BindGroupId),
+    CreateShaderModule {
+        id: id::ShaderModuleId,
+        data: FileName,
+    },
+    DestroyShaderModule(id::ShaderModuleId),
+    WriteBuffer {
+        id: id::BufferId,
+        data: FileName,
+        range: Range<wgt::BufferAddress>,
     },
 }
 
@@ -42,6 +89,7 @@ pub struct Trace {
     path: std::path::PathBuf,
     file: std::fs::File,
     config: ron::ser::PrettyConfig,
+    binary_id: usize,
 }
 
 impl Trace {
@@ -53,9 +101,17 @@ impl Trace {
             path: path.to_path_buf(),
             file,
             config: ron::ser::PrettyConfig::default(),
+            binary_id: 0,
         })
     }
 
+    pub fn make_binary(&mut self, kind: &str, data: &[u8]) -> String {
+        self.binary_id += 1;
+        let name = format!("{}{}.bin", kind, self.binary_id);
+        let _ = std::fs::write(self.path.join(&name), data);
+        name
+    }
+
     pub fn add(&mut self, action: Action) {
         match ron::ser::to_string_pretty(&action, self.config.clone()) {
             Ok(string) => {
diff --git a/wgpu-core/src/resource.rs b/wgpu-core/src/resource.rs
index de7bf80c45..917b4b16a2 100644
--- a/wgpu-core/src/resource.rs
+++ b/wgpu-core/src/resource.rs
@@ -76,7 +76,11 @@ pub enum BufferMapState {
     /// Waiting for GPU to be done before mapping
     Waiting(BufferPendingMapping),
     /// Mapped
-    Active,
+    Active {
+        ptr: *mut u8,
+        sub_range: hal::buffer::SubRange,
+        host: crate::device::HostMap,
+    },
     /// Not mapped
     Idle,
 }
@@ -141,7 +145,7 @@ pub struct Buffer<B: hal::Backend> {
     pub(crate) memory: MemoryBlock<B>,
     pub(crate) size: BufferAddress,
     pub(crate) full_range: (),
-    pub(crate) mapped_write_segments: Vec<hal::memory::Segment>,
+    pub(crate) sync_mapped_writes: Option<hal::memory::Segment>,
     pub(crate) life_guard: LifeGuard,
     pub(crate) map_state: BufferMapState,
 }
diff --git a/wgpu-core/src/swap_chain.rs b/wgpu-core/src/swap_chain.rs
index 2d0aabc27d..b3da413299 100644
--- a/wgpu-core/src/swap_chain.rs
+++ b/wgpu-core/src/swap_chain.rs
@@ -159,8 +159,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         #[cfg(feature = "trace")]
         match device.trace {
             Some(ref trace) => trace.lock().add(Action::GetSwapChainTexture {
-                object_id: swap_chain_id,
-                view_id: id,
+                id,
+                parent_id: swap_chain_id,
             }),
             None => (),
         };
@@ -190,9 +190,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
 
         #[cfg(feature = "trace")]
         match device.trace {
-            Some(ref trace) => trace.lock().add(Action::PresentSwapChain {
-                object_id: swap_chain_id,
-            }),
+            Some(ref trace) => trace.lock().add(Action::PresentSwapChain(swap_chain_id)),
             None => (),
         };
 

From 6768f188658284d8efcd836d2f6c33297bcf2780 Mon Sep 17 00:00:00 2001
From: Dzmitry Malyshau <kvarkus@gmail.com>
Date: Tue, 28 Apr 2020 19:16:22 -0400
Subject: [PATCH 06/12] trace: all the commands

---
 wgpu-core/src/command/allocator.rs |  7 ++++
 wgpu-core/src/command/compute.rs   | 42 +++++++++++++++++++++++-
 wgpu-core/src/command/mod.rs       |  4 ++-
 wgpu-core/src/command/render.rs    | 48 ++++++++++++++++++++++++++-
 wgpu-core/src/command/transfer.rs  | 52 ++++++++++++++++++++++++++++--
 wgpu-core/src/device/mod.rs        |  9 ++++++
 wgpu-core/src/device/trace.rs      | 46 ++++++++++++++++++++++++--
 7 files changed, 200 insertions(+), 8 deletions(-)

diff --git a/wgpu-core/src/command/allocator.rs b/wgpu-core/src/command/allocator.rs
index 6eb18b1853..1d89b38623 100644
--- a/wgpu-core/src/command/allocator.rs
+++ b/wgpu-core/src/command/allocator.rs
@@ -80,6 +80,7 @@ impl<B: GfxBackend> CommandAllocator<B> {
         limits: wgt::Limits,
         private_features: PrivateFeatures,
         lowest_active_index: SubmissionIndex,
+        #[cfg(feature = "trace")] enable_tracing: bool,
     ) -> CommandBuffer<B> {
         //debug_assert_eq!(device_id.backend(), B::VARIANT);
         let thread_id = thread::current().id();
@@ -112,6 +113,12 @@ impl<B: GfxBackend> CommandAllocator<B> {
             used_swap_chain: None,
             limits,
             private_features,
+            #[cfg(feature = "trace")]
+            commands: if enable_tracing {
+                Some(Vec::new())
+            } else {
+                None
+            },
         }
     }
 }
diff --git a/wgpu-core/src/command/compute.rs b/wgpu-core/src/command/compute.rs
index 179190d4c1..ea6e87d784 100644
--- a/wgpu-core/src/command/compute.rs
+++ b/wgpu-core/src/command/compute.rs
@@ -26,11 +26,14 @@ enum PipelineState {
 }
 
 #[derive(Clone, Copy, Debug, PeekPoke)]
-enum ComputeCommand {
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub(crate) enum ComputeCommand {
     SetBindGroup {
         index: u8,
         num_dynamic_offsets: u8,
         bind_group_id: id::BindGroupId,
+        #[cfg_attr(feature = "serde", serde(skip))]
         phantom_offsets: PhantomSlice<DynamicOffset>,
     },
     SetPipeline(id::ComputePipelineId),
@@ -247,6 +250,43 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                 ComputeCommand::End => break,
             }
         }
+
+        #[cfg(feature = "trace")]
+        match cmb.commands {
+            Some(ref mut list) => {
+                let mut pass_commands = Vec::new();
+                let mut pass_dynamic_offsets = Vec::new();
+                peeker = raw_data.as_ptr();
+                loop {
+                    peeker = unsafe { ComputeCommand::peek_from(peeker, &mut command) };
+                    match command {
+                        ComputeCommand::SetBindGroup {
+                            num_dynamic_offsets,
+                            phantom_offsets,
+                            ..
+                        } => {
+                            let (new_peeker, offsets) = unsafe {
+                                phantom_offsets.decode_unaligned(
+                                    peeker,
+                                    num_dynamic_offsets as usize,
+                                    raw_data_end,
+                                )
+                            };
+                            peeker = new_peeker;
+                            pass_dynamic_offsets.extend_from_slice(offsets);
+                        }
+                        ComputeCommand::End => break,
+                        _ => {}
+                    }
+                    pass_commands.push(command);
+                }
+                list.push(crate::device::trace::Command::RunComputePass {
+                    commands: pass_commands,
+                    dynamic_offsets: pass_dynamic_offsets,
+                });
+            }
+            None => {}
+        }
     }
 }
 
diff --git a/wgpu-core/src/command/mod.rs b/wgpu-core/src/command/mod.rs
index 8a57b2cf4c..cf82f972aa 100644
--- a/wgpu-core/src/command/mod.rs
+++ b/wgpu-core/src/command/mod.rs
@@ -27,7 +27,7 @@ use peek_poke::PeekPoke;
 use std::{marker::PhantomData, mem, ptr, slice, thread::ThreadId};
 
 #[derive(Clone, Copy, Debug, PeekPoke)]
-struct PhantomSlice<T>(PhantomData<T>);
+pub(crate) struct PhantomSlice<T>(PhantomData<T>);
 
 impl<T> Default for PhantomSlice<T> {
     fn default() -> Self {
@@ -140,6 +140,8 @@ pub struct CommandBuffer<B: hal::Backend> {
     pub(crate) used_swap_chain: Option<(Stored<id::SwapChainId>, B::Framebuffer)>,
     limits: wgt::Limits,
     private_features: PrivateFeatures,
+    #[cfg(feature = "trace")]
+    pub(crate) commands: Option<Vec<crate::device::trace::Command>>,
 }
 
 impl<B: GfxBackend> CommandBuffer<B> {
diff --git a/wgpu-core/src/command/render.rs b/wgpu-core/src/command/render.rs
index 97520ca968..e74138f53e 100644
--- a/wgpu-core/src/command/render.rs
+++ b/wgpu-core/src/command/render.rs
@@ -46,6 +46,8 @@ pub struct RenderPassDescriptor<'a> {
 }
 
 #[derive(Clone, Copy, Debug, Default, PeekPoke)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
 pub struct Rect<T> {
     pub x: T,
     pub y: T,
@@ -54,11 +56,14 @@ pub struct Rect<T> {
 }
 
 #[derive(Clone, Copy, Debug, PeekPoke)]
-enum RenderCommand {
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub(crate) enum RenderCommand {
     SetBindGroup {
         index: u8,
         num_dynamic_offsets: u8,
         bind_group_id: id::BindGroupId,
+        #[cfg_attr(feature = "serde", serde(skip))]
         phantom_offsets: PhantomSlice<DynamicOffset>,
     },
     SetPipeline(id::RenderPipelineId),
@@ -329,6 +334,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let mut targets: RawRenderTargets = unsafe { mem::zeroed() };
         assert!(unsafe { peeker.add(RawRenderTargets::max_size()) <= raw_data_end });
         peeker = unsafe { RawRenderTargets::peek_from(peeker, &mut targets) };
+        #[cfg(feature = "trace")]
+        let command_peeker_base = peeker;
 
         let color_attachments = targets
             .colors
@@ -1173,6 +1180,45 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             }
         }
 
+        #[cfg(feature = "trace")]
+        match cmb.commands {
+            Some(ref mut list) => {
+                let mut pass_commands = Vec::new();
+                let mut pass_dynamic_offsets = Vec::new();
+                peeker = command_peeker_base;
+                loop {
+                    peeker = unsafe { RenderCommand::peek_from(peeker, &mut command) };
+                    match command {
+                        RenderCommand::SetBindGroup {
+                            num_dynamic_offsets,
+                            phantom_offsets,
+                            ..
+                        } => {
+                            let (new_peeker, offsets) = unsafe {
+                                phantom_offsets.decode_unaligned(
+                                    peeker,
+                                    num_dynamic_offsets as usize,
+                                    raw_data_end,
+                                )
+                            };
+                            peeker = new_peeker;
+                            pass_dynamic_offsets.extend_from_slice(offsets);
+                        }
+                        RenderCommand::End => break,
+                        _ => {}
+                    }
+                    pass_commands.push(command);
+                }
+                list.push(crate::device::trace::Command::RunRenderPass {
+                    target_colors: color_attachments.into_iter().collect(),
+                    target_depth_stencil: depth_stencil_attachment.cloned(),
+                    commands: pass_commands,
+                    dynamic_offsets: pass_dynamic_offsets,
+                });
+            }
+            None => {}
+        }
+
         log::trace!("Merging {:?} with the render pass", encoder_id);
         unsafe {
             raw.end_render_pass();
diff --git a/wgpu-core/src/command/transfer.rs b/wgpu-core/src/command/transfer.rs
index e26d5a1865..f3c8adc47f 100644
--- a/wgpu-core/src/command/transfer.rs
+++ b/wgpu-core/src/command/transfer.rs
@@ -2,6 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+#[cfg(feature = "trace")]
+use crate::device::trace::Command as TraceCommand;
 use crate::{
     conv,
     device::{all_buffer_stages, all_image_stages},
@@ -18,7 +20,9 @@ use std::iter;
 const BITS_PER_BYTE: u32 = 8;
 
 #[repr(C)]
-#[derive(Debug)]
+#[derive(Clone, Debug)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
 pub struct BufferCopyView {
     pub buffer: BufferId,
     pub offset: BufferAddress,
@@ -27,7 +31,9 @@ pub struct BufferCopyView {
 }
 
 #[repr(C)]
-#[derive(Debug)]
+#[derive(Clone, Debug)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
 pub struct TextureCopyView {
     pub texture: TextureId,
     pub mip_level: u32,
@@ -90,6 +96,18 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         // borrow the buffer tracker mutably...
         let mut barriers = Vec::new();
 
+        #[cfg(feature = "trace")]
+        match cmb.commands {
+            Some(ref mut list) => list.push(TraceCommand::CopyBufferToBuffer {
+                src: source,
+                src_offset: source_offset,
+                dst: destination,
+                dst_offset: destination_offset,
+                size,
+            }),
+            None => (),
+        }
+
         let (src_buffer, src_pending) =
             cmb.trackers
                 .buffers
@@ -135,6 +153,16 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let (texture_guard, _) = hub.textures.read(&mut token);
         let aspects = texture_guard[destination.texture].full_range.aspects;
 
+        #[cfg(feature = "trace")]
+        match cmb.commands {
+            Some(ref mut list) => list.push(TraceCommand::CopyBufferToTexture {
+                src: source.clone(),
+                dst: destination.clone(),
+                size: copy_size,
+            }),
+            None => (),
+        }
+
         let (src_buffer, src_pending) = cmb.trackers.buffers.use_replace(
             &*buffer_guard,
             source.buffer,
@@ -199,6 +227,16 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let (texture_guard, _) = hub.textures.read(&mut token);
         let aspects = texture_guard[source.texture].full_range.aspects;
 
+        #[cfg(feature = "trace")]
+        match cmb.commands {
+            Some(ref mut list) => list.push(TraceCommand::CopyTextureToBuffer {
+                src: source.clone(),
+                dst: destination.clone(),
+                size: copy_size,
+            }),
+            None => (),
+        }
+
         let (src_texture, src_pending) = cmb.trackers.textures.use_replace(
             &*texture_guard,
             source.texture,
@@ -268,6 +306,16 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let aspects = texture_guard[source.texture].full_range.aspects
             & texture_guard[destination.texture].full_range.aspects;
 
+        #[cfg(feature = "trace")]
+        match cmb.commands {
+            Some(ref mut list) => list.push(TraceCommand::CopyTextureToTexture {
+                src: source.clone(),
+                dst: destination.clone(),
+                size: copy_size,
+            }),
+            None => (),
+        }
+
         let (src_texture, src_pending) = cmb.trackers.textures.use_replace(
             &*texture_guard,
             source.texture,
diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs
index 22ed28c639..981988c603 100644
--- a/wgpu-core/src/device/mod.rs
+++ b/wgpu-core/src/device/mod.rs
@@ -1536,6 +1536,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             device.limits.clone(),
             device.private_features,
             lowest_active_index,
+            #[cfg(feature = "trace")]
+            device.trace.is_some(),
         );
         unsafe {
             let raw_command_buffer = command_buffer.raw.last_mut().unwrap();
@@ -1662,6 +1664,13 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             // finish all the command buffers first
             for &cmb_id in command_buffer_ids {
                 let comb = &mut command_buffer_guard[cmb_id];
+                #[cfg(feature = "trace")]
+                match device.trace {
+                    Some(ref trace) => trace
+                        .lock()
+                        .add(Action::Submit(comb.commands.take().unwrap())),
+                    None => (),
+                };
 
                 if let Some((sc_id, fbo)) = comb.used_swap_chain.take() {
                     let sc = &mut swap_chain_guard[sc_id.value];
diff --git a/wgpu-core/src/device/trace.rs b/wgpu-core/src/device/trace.rs
index 48c6d9c88a..d0a594b17e 100644
--- a/wgpu-core/src/device/trace.rs
+++ b/wgpu-core/src/device/trace.rs
@@ -2,7 +2,10 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use crate::id;
+use crate::{
+    command::{BufferCopyView, TextureCopyView},
+    id,
+};
 use std::{io::Write as _, ops::Range};
 
 //TODO: consider a readable Id that doesn't include the backend
@@ -20,7 +23,7 @@ pub enum BindingResource {
 }
 
 #[derive(serde::Serialize)]
-pub enum Action {
+pub(crate) enum Action {
     Init {
         limits: wgt::Limits,
     },
@@ -82,6 +85,43 @@ pub enum Action {
         data: FileName,
         range: Range<wgt::BufferAddress>,
     },
+    Submit(Vec<Command>),
+}
+
+#[derive(Debug, serde::Serialize)]
+pub(crate) enum Command {
+    CopyBufferToBuffer {
+        src: id::BufferId,
+        src_offset: wgt::BufferAddress,
+        dst: id::BufferId,
+        dst_offset: wgt::BufferAddress,
+        size: wgt::BufferAddress,
+    },
+    CopyBufferToTexture {
+        src: BufferCopyView,
+        dst: TextureCopyView,
+        size: wgt::Extent3d,
+    },
+    CopyTextureToBuffer {
+        src: TextureCopyView,
+        dst: BufferCopyView,
+        size: wgt::Extent3d,
+    },
+    CopyTextureToTexture {
+        src: TextureCopyView,
+        dst: TextureCopyView,
+        size: wgt::Extent3d,
+    },
+    RunComputePass {
+        commands: Vec<crate::command::ComputeCommand>,
+        dynamic_offsets: Vec<wgt::DynamicOffset>,
+    },
+    RunRenderPass {
+        target_colors: Vec<crate::command::RenderPassColorAttachmentDescriptor>,
+        target_depth_stencil: Option<crate::command::RenderPassDepthStencilAttachmentDescriptor>,
+        commands: Vec<crate::command::RenderCommand>,
+        dynamic_offsets: Vec<wgt::DynamicOffset>,
+    },
 }
 
 #[derive(Debug)]
@@ -112,7 +152,7 @@ impl Trace {
         name
     }
 
-    pub fn add(&mut self, action: Action) {
+    pub(crate) fn add(&mut self, action: Action) {
         match ron::ser::to_string_pretty(&action, self.config.clone()) {
             Ok(string) => {
                 let _ = write!(self.file, "{},\n", string);

From f8871c9d2bbbb7c7f03dbad60528b40f1f674e5d Mon Sep 17 00:00:00 2001
From: Dzmitry Malyshau <kvarkus@gmail.com>
Date: Wed, 29 Apr 2020 00:42:35 -0400
Subject: [PATCH 07/12] trace: player skeleton

---
 Cargo.toml                       |   1 +
 player/Cargo.toml                |  32 ++++++++
 player/src/main.rs               | 121 +++++++++++++++++++++++++++++++
 wgpu-core/Cargo.toml             |   1 +
 wgpu-core/src/command/compute.rs |   2 +-
 wgpu-core/src/command/mod.rs     |   2 +-
 wgpu-core/src/command/render.rs  |   2 +-
 wgpu-core/src/device/mod.rs      |   4 +-
 wgpu-core/src/device/trace.rs    |  28 +++++--
 wgpu-core/src/hub.rs             |  15 ++--
 wgpu-core/src/instance.rs        |  83 ++++++++++++++++++++-
 11 files changed, 272 insertions(+), 19 deletions(-)
 create mode 100644 player/Cargo.toml
 create mode 100644 player/src/main.rs

diff --git a/Cargo.toml b/Cargo.toml
index 7958bd98a1..b9d820c1ea 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,6 @@
 [workspace]
 members = [
+	"player",
 	"wgpu-core",
     "wgpu-types",
 ]
diff --git a/player/Cargo.toml b/player/Cargo.toml
new file mode 100644
index 0000000000..aa51b5652a
--- /dev/null
+++ b/player/Cargo.toml
@@ -0,0 +1,32 @@
+[package]
+name = "player"
+version = "0.1.0"
+authors = [
+	"Dzmitry Malyshau <kvark@mozilla.com>",
+]
+edition = "2018"
+description = "WebGPU trace player"
+homepage = "https://github.com/gfx-rs/wgpu"
+repository = "https://github.com/gfx-rs/wgpu"
+keywords = ["graphics"]
+license = "MPL-2.0"
+publish = false
+
+[features]
+
+[dependencies]
+env_logger = "0.7"
+ron = { version = "0.5" }
+winit = { version = "0.22" }
+
+[dependencies.wgt]
+path = "../wgpu-types"
+package = "wgpu-types"
+version = "0.5"
+features = ["replay"]
+
+[dependencies.wgc]
+path = "../wgpu-core"
+package = "wgpu-core"
+version = "0.5"
+features = ["replay", "raw-window-handle"]
diff --git a/player/src/main.rs b/player/src/main.rs
new file mode 100644
index 0000000000..65329259dc
--- /dev/null
+++ b/player/src/main.rs
@@ -0,0 +1,121 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use wgc::device::trace;
+
+use std::{
+    fmt::Debug,
+    fs::File,
+    marker::PhantomData,
+    path::{Path, PathBuf},
+};
+use winit::{event_loop::EventLoop, window::WindowBuilder};
+
+macro_rules! gfx_select {
+    ($id:expr => $global:ident.$method:ident( $($param:expr),+ )) => {
+        match $id.backend() {
+            #[cfg(not(any(target_os = "ios", target_os = "macos")))]
+            wgt::Backend::Vulkan => $global.$method::<wgc::backend::Vulkan>( $($param),+ ),
+            #[cfg(any(target_os = "ios", target_os = "macos"))]
+            wgt::Backend::Metal => $global.$method::<wgc::backend::Metal>( $($param),+ ),
+            #[cfg(windows)]
+            wgt::Backend::Dx12 => $global.$method::<wgc::backend::Dx12>( $($param),+ ),
+            #[cfg(windows)]
+            wgt::Backend::Dx11 => $global.$method::<wgc::backend::Dx11>( $($param),+ ),
+            _ => unreachable!()
+        }
+    };
+}
+
+#[derive(Debug)]
+struct IdentityPassThrough<I>(PhantomData<I>);
+
+impl<I: Clone + Debug + wgc::id::TypedId> wgc::hub::IdentityHandler<I> for IdentityPassThrough<I> {
+    type Input = I;
+    fn process(&self, id: I, backend: wgt::Backend) -> I {
+        let (index, epoch, _backend) = id.unzip();
+        I::zip(index, epoch, backend)
+    }
+    fn free(&self, _id: I) {}
+}
+
+struct IdentityPassThroughFactory;
+
+impl<I: Clone + Debug + wgc::id::TypedId> wgc::hub::IdentityHandlerFactory<I>
+    for IdentityPassThroughFactory
+{
+    type Filter = IdentityPassThrough<I>;
+    fn spawn(&self, _min_index: u32) -> Self::Filter {
+        IdentityPassThrough(PhantomData)
+    }
+}
+impl wgc::hub::GlobalIdentityHandlerFactory for IdentityPassThroughFactory {}
+
+fn main() {
+    env_logger::init();
+
+    let folder = match std::env::args().nth(1) {
+        Some(arg) if Path::new(&arg).is_dir() => PathBuf::from(arg),
+        _ => panic!("Provide the folder path as the parameter"),
+    };
+
+    let file = File::open(folder.join(trace::FILE_NAME)).unwrap();
+    let actions: Vec<trace::Action> = ron::de::from_reader(file).unwrap();
+
+    let event_loop = EventLoop::new();
+    let mut builder = WindowBuilder::new();
+    builder = builder.with_title("wgpu player");
+    let window = builder.build(&event_loop).unwrap();
+
+    let global = wgc::hub::Global::new("player", IdentityPassThroughFactory);
+    let mut surface_id_manager = wgc::hub::IdentityManager::from_index(1);
+    let mut adapter_id_manager = wgc::hub::IdentityManager::default();
+    let mut device_id_manager = wgc::hub::IdentityManager::default();
+
+    let (_size, surface) = {
+        let size = window.inner_size();
+        let id = surface_id_manager.alloc(wgt::Backend::Empty);
+        let surface = global.instance_create_surface(&window, id);
+        (size, surface)
+    };
+
+    let adapter = global
+        .pick_adapter(
+            &wgc::instance::RequestAdapterOptions {
+                power_preference: wgt::PowerPreference::Default,
+                compatible_surface: Some(surface),
+            },
+            wgc::instance::AdapterInputs::IdSet(
+                &vec![
+                    adapter_id_manager.alloc(wgt::Backend::Vulkan),
+                    adapter_id_manager.alloc(wgt::Backend::Dx12),
+                    adapter_id_manager.alloc(wgt::Backend::Metal),
+                ],
+                |id| wgc::id::TypedId::unzip(*id).2,
+            ),
+        )
+        .unwrap();
+
+    let limits = match actions.first() {
+        Some(&trace::Action::Init { ref limits }) => limits.clone(),
+        other => panic!("Unsupported first action: {:?}", other),
+    };
+
+    let device = gfx_select!(adapter => global.adapter_request_device(
+        adapter,
+        &wgt::DeviceDescriptor {
+            extensions: wgt::Extensions {
+                anisotropic_filtering: false,
+            },
+            limits,
+        },
+        device_id_manager.alloc(wgt::Backend::Vulkan)
+    ));
+
+    for action in actions.into_iter().skip(1) {
+        match action {
+            _ => {}
+        }
+    }
+}
diff --git a/wgpu-core/Cargo.toml b/wgpu-core/Cargo.toml
index c6ad0c8321..49e0497ec0 100644
--- a/wgpu-core/Cargo.toml
+++ b/wgpu-core/Cargo.toml
@@ -34,6 +34,7 @@ gfx-descriptor = "0.1"
 gfx-memory = "0.1"
 parking_lot = "0.10"
 peek-poke = "0.2"
+raw-window-handle = { version = "0.3", optional = true }
 ron = { version = "0.5", optional = true }
 serde = { version = "1.0", features = ["serde_derive"], optional = true }
 smallvec = "1"
diff --git a/wgpu-core/src/command/compute.rs b/wgpu-core/src/command/compute.rs
index ea6e87d784..8d35b94934 100644
--- a/wgpu-core/src/command/compute.rs
+++ b/wgpu-core/src/command/compute.rs
@@ -28,7 +28,7 @@ enum PipelineState {
 #[derive(Clone, Copy, Debug, PeekPoke)]
 #[cfg_attr(feature = "trace", derive(serde::Serialize))]
 #[cfg_attr(feature = "replay", derive(serde::Deserialize))]
-pub(crate) enum ComputeCommand {
+pub enum ComputeCommand {
     SetBindGroup {
         index: u8,
         num_dynamic_offsets: u8,
diff --git a/wgpu-core/src/command/mod.rs b/wgpu-core/src/command/mod.rs
index cf82f972aa..1716bf69b0 100644
--- a/wgpu-core/src/command/mod.rs
+++ b/wgpu-core/src/command/mod.rs
@@ -27,7 +27,7 @@ use peek_poke::PeekPoke;
 use std::{marker::PhantomData, mem, ptr, slice, thread::ThreadId};
 
 #[derive(Clone, Copy, Debug, PeekPoke)]
-pub(crate) struct PhantomSlice<T>(PhantomData<T>);
+pub struct PhantomSlice<T>(PhantomData<T>);
 
 impl<T> Default for PhantomSlice<T> {
     fn default() -> Self {
diff --git a/wgpu-core/src/command/render.rs b/wgpu-core/src/command/render.rs
index e74138f53e..6c8b0222de 100644
--- a/wgpu-core/src/command/render.rs
+++ b/wgpu-core/src/command/render.rs
@@ -58,7 +58,7 @@ pub struct Rect<T> {
 #[derive(Clone, Copy, Debug, PeekPoke)]
 #[cfg_attr(feature = "trace", derive(serde::Serialize))]
 #[cfg_attr(feature = "replay", derive(serde::Deserialize))]
-pub(crate) enum RenderCommand {
+pub enum RenderCommand {
     SetBindGroup {
         index: u8,
         num_dynamic_offsets: u8,
diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs
index 981988c603..5bd78afbe3 100644
--- a/wgpu-core/src/device/mod.rs
+++ b/wgpu-core/src/device/mod.rs
@@ -31,8 +31,8 @@ use std::{
 };
 
 mod life;
-#[cfg(feature = "trace")]
-pub(crate) mod trace;
+#[cfg(any(feature = "trace", feature = "replay"))]
+pub mod trace;
 #[cfg(feature = "trace")]
 use trace::{Action, Trace};
 
diff --git a/wgpu-core/src/device/trace.rs b/wgpu-core/src/device/trace.rs
index d0a594b17e..c8a82f9568 100644
--- a/wgpu-core/src/device/trace.rs
+++ b/wgpu-core/src/device/trace.rs
@@ -6,12 +6,19 @@ use crate::{
     command::{BufferCopyView, TextureCopyView},
     id,
 };
-use std::{io::Write as _, ops::Range};
+use std::ops::Range;
+#[cfg(feature = "trace")]
+use std::io::Write as _;
 
 //TODO: consider a readable Id that doesn't include the backend
+
 type FileName = String;
 
-#[derive(serde::Serialize)]
+pub const FILE_NAME: &str = "trace.ron";
+
+#[derive(Debug)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
 pub enum BindingResource {
     Buffer {
         id: id::BufferId,
@@ -22,8 +29,10 @@ pub enum BindingResource {
     TextureView(id::TextureViewId),
 }
 
-#[derive(serde::Serialize)]
-pub(crate) enum Action {
+#[derive(Debug)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub enum Action {
     Init {
         limits: wgt::Limits,
     },
@@ -88,8 +97,10 @@ pub(crate) enum Action {
     Submit(Vec<Command>),
 }
 
-#[derive(Debug, serde::Serialize)]
-pub(crate) enum Command {
+#[derive(Debug)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub enum Command {
     CopyBufferToBuffer {
         src: id::BufferId,
         src_offset: wgt::BufferAddress,
@@ -124,6 +135,7 @@ pub(crate) enum Command {
     },
 }
 
+#[cfg(feature = "trace")]
 #[derive(Debug)]
 pub struct Trace {
     path: std::path::PathBuf,
@@ -132,10 +144,11 @@ pub struct Trace {
     binary_id: usize,
 }
 
+#[cfg(feature = "trace")]
 impl Trace {
     pub fn new(path: &std::path::Path) -> Result<Self, std::io::Error> {
         log::info!("Tracing into '{:?}'", path);
-        let mut file = std::fs::File::create(path.join("trace.ron"))?;
+        let mut file = std::fs::File::create(path.join(FILE_NAME))?;
         file.write(b"[\n")?;
         Ok(Trace {
             path: path.to_path_buf(),
@@ -164,6 +177,7 @@ impl Trace {
     }
 }
 
+#[cfg(feature = "trace")]
 impl Drop for Trace {
     fn drop(&mut self) {
         let _ = self.file.write(b"]");
diff --git a/wgpu-core/src/hub.rs b/wgpu-core/src/hub.rs
index 2d1ef24a59..5b806558f4 100644
--- a/wgpu-core/src/hub.rs
+++ b/wgpu-core/src/hub.rs
@@ -25,7 +25,7 @@ use wgt::Backend;
 
 #[cfg(debug_assertions)]
 use std::cell::Cell;
-use std::{fmt::Debug, iter, marker::PhantomData, ops};
+use std::{fmt::Debug, marker::PhantomData, ops};
 
 /// A simple structure to manage identities of objects.
 #[derive(Debug)]
@@ -44,6 +44,13 @@ impl Default for IdentityManager {
 }
 
 impl IdentityManager {
+    pub fn from_index(min_index: u32) -> Self {
+        IdentityManager {
+            free: (0 .. min_index).collect(),
+            epochs: vec![1; min_index as usize],
+        }
+    }
+
     pub fn alloc<I: TypedId>(&mut self, backend: Backend) -> I {
         match self.free.pop() {
             Some(index) => I::zip(index, self.epochs[index as usize], backend),
@@ -262,10 +269,7 @@ pub struct IdentityManagerFactory;
 impl<I: TypedId + Debug> IdentityHandlerFactory<I> for IdentityManagerFactory {
     type Filter = Mutex<IdentityManager>;
     fn spawn(&self, min_index: Index) -> Self::Filter {
-        let mut man = IdentityManager::default();
-        man.free.extend(0..min_index);
-        man.epochs.extend(iter::repeat(1).take(min_index as usize));
-        Mutex::new(man)
+        Mutex::new(IdentityManager::from_index(min_index))
     }
 }
 
@@ -549,6 +553,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
 
 impl<G: GlobalIdentityHandlerFactory> Drop for Global<G> {
     fn drop(&mut self) {
+        log::info!("Dropping Global");
         // destroy surfaces
         for (_, (surface, _)) in self.surfaces.data.write().map.drain() {
             self.instance.destroy_surface(surface);
diff --git a/wgpu-core/src/instance.rs b/wgpu-core/src/instance.rs
index 8346472ce1..0995ef65e4 100644
--- a/wgpu-core/src/instance.rs
+++ b/wgpu-core/src/instance.rs
@@ -188,7 +188,7 @@ impl From<HalDeviceType> for DeviceType {
 
 pub enum AdapterInputs<'a, I> {
     IdSet(&'a [I], fn(&I) -> Backend),
-    Mask(BackendBit, fn() -> I),
+    Mask(BackendBit, fn(Backend) -> I),
 }
 
 impl<I: Clone> AdapterInputs<'_, I> {
@@ -197,7 +197,7 @@ impl<I: Clone> AdapterInputs<'_, I> {
             AdapterInputs::IdSet(ids, ref fun) => ids.iter().find(|id| fun(id) == b).cloned(),
             AdapterInputs::Mask(bits, ref fun) => {
                 if bits.contains(b.into()) {
-                    Some(fun())
+                    Some(fun(b))
                 } else {
                     None
                 }
@@ -207,6 +207,85 @@ impl<I: Clone> AdapterInputs<'_, I> {
 }
 
 impl<G: GlobalIdentityHandlerFactory> Global<G> {
+    #[cfg(feature = "raw-window-handle")]
+    pub fn instance_create_surface<W: raw_window_handle::HasRawWindowHandle>(
+        &self,
+        window: &W,
+        id_in: Input<G, SurfaceId>,
+    ) -> SurfaceId {
+        use raw_window_handle::RawWindowHandle as Rwh;
+
+        let surface = match window.raw_window_handle() {
+            #[cfg(target_os = "ios")]
+            Rwh::IOS(h) => Surface {
+                #[cfg(feature = "gfx-backend-vulkan")]
+                vulkan: None,
+                metal: self
+                    .instance
+                    .metal
+                    .create_surface_from_uiview(h.ui_view, cfg!(debug_assertions)),
+            },
+            #[cfg(target_os = "macos")]
+            Rwh::MacOS(h) => {
+                //TODO: figure out when this is needed, and how to get that without `objc`
+                //use objc::{msg_send, runtime::Object, sel, sel_impl};
+                //let ns_view = if h.ns_view.is_null() {
+                //    let ns_window = h.ns_window as *mut Object;
+                //    unsafe { msg_send![ns_window, contentView] }
+                //} else {
+                //    h.ns_view
+                //};
+                Surface {
+                    #[cfg(feature = "gfx-backend-vulkan")]
+                    vulkan: self
+                        .instance
+                        .vulkan
+                        .as_ref()
+                        .map(|inst| inst.create_surface_from_ns_view(h.ns_view)),
+                    metal: self
+                        .instance
+                        .metal
+                        .create_surface_from_nsview(h.ns_view, cfg!(debug_assertions)),
+                }
+            }
+            #[cfg(all(unix, not(target_os = "ios"), not(target_os = "macos")))]
+            Rwh::Xlib(h) => Surface {
+                vulkan: self
+                    .instance
+                    .vulkan
+                    .as_ref()
+                    .map(|inst| inst.create_surface_from_xlib(h.display as _, h.window as _)),
+            },
+            #[cfg(all(unix, not(target_os = "ios"), not(target_os = "macos")))]
+            Rwh::Wayland(h) => Surface {
+                vulkan: self
+                    .instance
+                    .vulkan
+                    .as_ref()
+                    .map(|inst| inst.create_surface_from_wayland(h.display, h.surface)),
+            },
+            #[cfg(windows)]
+            Rwh::Windows(h) => Surface {
+                vulkan: self
+                    .instance
+                    .vulkan
+                    .as_ref()
+                    .map(|inst| inst.create_surface_from_hwnd(std::ptr::null_mut(), h.hwnd)),
+                dx12: self
+                    .instance
+                    .dx12
+                    .as_ref()
+                    .map(|inst| inst.create_surface_from_hwnd(h.hwnd)),
+                dx11: self.instance.dx11.create_surface_from_hwnd(h.hwnd),
+            },
+            _ => panic!("Unsupported window handle"),
+        };
+
+        let mut token = Token::root();
+        self.surfaces
+            .register_identity(id_in, surface, &mut token)
+    }
+
     pub fn enumerate_adapters(&self, inputs: AdapterInputs<Input<G, AdapterId>>) -> Vec<AdapterId> {
         let instance = &self.instance;
         let mut token = Token::root();

From 0e4e7b9888c39dbde45b29e3043bdde03f868ff1 Mon Sep 17 00:00:00 2001
From: Dzmitry Malyshau <kvarkus@gmail.com>
Date: Wed, 29 Apr 2020 12:37:55 -0400
Subject: [PATCH 08/12] trace: replaying all the commands

---
 .gitignore                    |    1 -
 Cargo.lock                    | 1419 +++++++++++++++++++++++++++++++++
 player/Cargo.toml             |    5 +-
 player/src/main.rs            |  334 +++++++-
 wgpu-core/src/command/mod.rs  |    4 +-
 wgpu-core/src/device/mod.rs   |    6 +-
 wgpu-core/src/device/trace.rs |    2 +-
 wgpu-core/src/instance.rs     |    6 +-
 wgpu-core/src/resource.rs     |    3 +
 9 files changed, 1738 insertions(+), 42 deletions(-)
 create mode 100644 Cargo.lock

diff --git a/.gitignore b/.gitignore
index 70f37a548c..0dd6fef443 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,3 @@
-Cargo.lock
 /target
 **/*.rs.bk
 #Cargo.lock
diff --git a/Cargo.lock b/Cargo.lock
new file mode 100644
index 0000000000..a3f743c9ea
--- /dev/null
+++ b/Cargo.lock
@@ -0,0 +1,1419 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "aho-corasick"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8716408b8bc624ed7f65d223ddb9ac2d044c0547b6fa4b0d554f3a9540496ada"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "andrew"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b7f09f89872c2b6b29e319377b1fbe91c6f5947df19a25596e121cf19a7b35e"
+dependencies = [
+ "bitflags",
+ "line_drawing",
+ "rusttype 0.7.9",
+ "walkdir",
+ "xdg",
+ "xml-rs",
+]
+
+[[package]]
+name = "android_glue"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "000444226fcff248f2bc4c7625be32c63caccfecc2723a2b9f78a7487a49c407"
+
+[[package]]
+name = "approx"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0e60b75072ecd4168020818c0107f2857bb6c4e64252d8d3983f6263b40a5c3"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "arrayvec"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cff77d8686867eceff3105329d4698d96c2391c176d5d03adc90c7389162b5b8"
+
+[[package]]
+name = "ash"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69daec0742947f33a85931fa3cb0ce5f07929159dcbd1f0cbb5b2912e2978509"
+dependencies = [
+ "libloading",
+]
+
+[[package]]
+name = "atom"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c86699c3f02778ec07158376991c8f783dd1f2f95c579ffaf0738dc984b2fe2"
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi 0.3.8",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d"
+
+[[package]]
+name = "base64"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b25d992356d2eb0ed82172f5248873db5560c4721f564b13cb5193bda5e668e"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "battery"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36a698e449024a5d18994a815998bf5e2e4bc1883e35a7d7ba95b6b69ee45907"
+dependencies = [
+ "cfg-if",
+ "core-foundation 0.6.4",
+ "lazycell",
+ "libc",
+ "mach",
+ "nix 0.15.0",
+ "num-traits",
+ "uom",
+ "winapi 0.3.8",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
+
+[[package]]
+name = "block"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a"
+
+[[package]]
+name = "bumpalo"
+version = "3.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12ae9db68ad7fac5fe51304d20f016c911539251075a214f8e663babefa35187"
+
+[[package]]
+name = "byteorder"
+version = "1.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
+
+[[package]]
+name = "calloop"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7aa2097be53a00de9e8fc349fea6d76221f398f5c4fa550d420669906962d160"
+dependencies = [
+ "mio",
+ "mio-extras",
+ "nix 0.14.1",
+]
+
+[[package]]
+name = "cc"
+version = "1.0.52"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d87b23d6a92cd03af510a5ade527033f6aa6fa92161e2d5863a907d4c5e31d"
+
+[[package]]
+name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+
+[[package]]
+name = "cloudabi"
+version = "0.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "cocoa"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f29f7768b2d1be17b96158e3285951d366b40211320fb30826a76cb7a0da6400"
+dependencies = [
+ "bitflags",
+ "block",
+ "core-foundation 0.6.4",
+ "core-graphics 0.17.3",
+ "foreign-types",
+ "libc",
+ "objc",
+]
+
+[[package]]
+name = "cocoa"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a4736c86d51bd878b474400d9ec888156f4037015f5d09794fab9f26eab1ad4"
+dependencies = [
+ "bitflags",
+ "block",
+ "core-foundation 0.7.0",
+ "core-graphics 0.19.0",
+ "foreign-types",
+ "libc",
+ "objc",
+]
+
+[[package]]
+name = "copyless"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ff9c56c9fb2a49c05ef0e431485a22400af20d33226dc0764d891d09e724127"
+
+[[package]]
+name = "core-foundation"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25b9e03f145fd4f2bf705e07b900cd41fc636598fe5dc452fd0db1441c3f496d"
+dependencies = [
+ "core-foundation-sys 0.6.2",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57d24c7a13c43e870e37c1556b74555437870a04514f7685f5b354e090567171"
+dependencies = [
+ "core-foundation-sys 0.7.0",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7ca8a5221364ef15ce201e8ed2f609fc312682a8f4e0e3d4aa5879764e0fa3b"
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3a71ab494c0b5b860bdc8407ae08978052417070c2ced38573a9157ad75b8ac"
+
+[[package]]
+name = "core-graphics"
+version = "0.17.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56790968ab1c8a1202a102e6de05fc6e1ec87da99e4e93e9a7d13efbfc1e95a9"
+dependencies = [
+ "bitflags",
+ "core-foundation 0.6.4",
+ "foreign-types",
+ "libc",
+]
+
+[[package]]
+name = "core-graphics"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59e78b2e0aaf43f08e7ae0d6bc96895ef72ff0921c7d4ff4762201b2dba376dd"
+dependencies = [
+ "bitflags",
+ "core-foundation 0.7.0",
+ "foreign-types",
+ "libc",
+]
+
+[[package]]
+name = "core-video-sys"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8dc065219542086f72d1e9f7aadbbab0989e980263695d129d502082d063a9d0"
+dependencies = [
+ "cfg-if",
+ "core-foundation-sys 0.6.2",
+ "core-graphics 0.17.3",
+ "libc",
+ "objc",
+]
+
+[[package]]
+name = "d3d12"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc7ed48e89905e5e146bcc1951cc3facb9e44aea9adf5dc01078cda1bd24b662"
+dependencies = [
+ "bitflags",
+ "libloading",
+ "winapi 0.3.8",
+]
+
+[[package]]
+name = "dispatch"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b"
+
+[[package]]
+name = "dlib"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77e51249a9d823a4cb79e3eca6dcd756153e8ed0157b6c04775d04bf1b13b76a"
+dependencies = [
+ "libloading",
+]
+
+[[package]]
+name = "downcast-rs"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ba6eb47c2131e784a38b726eb54c1e1484904f013e576a25354d0124161af6"
+
+[[package]]
+name = "env_logger"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36"
+dependencies = [
+ "atty",
+ "humantime",
+ "log",
+ "regex",
+ "termcolor",
+]
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "fuchsia-zircon"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
+dependencies = [
+ "bitflags",
+ "fuchsia-zircon-sys",
+]
+
+[[package]]
+name = "fuchsia-zircon-sys"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
+
+[[package]]
+name = "fxhash"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "gfx-auxil"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b46e6f0031330a0be08d17820f2dcaaa91cb36710a97a9500cb4f1c36e785c8"
+dependencies = [
+ "fxhash",
+ "gfx-hal",
+ "spirv_cross",
+]
+
+[[package]]
+name = "gfx-backend-dx11"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b148219292624126f78245e50a9720d95ea149a415ce8ce73ab7014205301b88"
+dependencies = [
+ "bitflags",
+ "gfx-auxil",
+ "gfx-hal",
+ "libloading",
+ "log",
+ "parking_lot",
+ "range-alloc",
+ "raw-window-handle",
+ "smallvec",
+ "spirv_cross",
+ "winapi 0.3.8",
+ "wio",
+]
+
+[[package]]
+name = "gfx-backend-dx12"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0e526746379e974501551b08958947e67a81b5ea8cdc717a000cdd72577da05"
+dependencies = [
+ "bitflags",
+ "d3d12",
+ "gfx-auxil",
+ "gfx-hal",
+ "log",
+ "range-alloc",
+ "raw-window-handle",
+ "smallvec",
+ "spirv_cross",
+ "winapi 0.3.8",
+]
+
+[[package]]
+name = "gfx-backend-empty"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67bd2d7bc022b257ddbdabc5fa3b10c29c292372c3409f2b6a6e3f4e11cdb85"
+dependencies = [
+ "gfx-hal",
+ "raw-window-handle",
+]
+
+[[package]]
+name = "gfx-backend-metal"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfe128c29675b5afc8acdda1dfe096d6abd5e3528059ab0b98bda8215d8beed9"
+dependencies = [
+ "arrayvec",
+ "bitflags",
+ "block",
+ "cocoa 0.20.0",
+ "copyless",
+ "core-graphics 0.19.0",
+ "foreign-types",
+ "gfx-auxil",
+ "gfx-hal",
+ "lazy_static",
+ "log",
+ "metal",
+ "objc",
+ "parking_lot",
+ "range-alloc",
+ "raw-window-handle",
+ "smallvec",
+ "spirv_cross",
+ "storage-map",
+]
+
+[[package]]
+name = "gfx-backend-vulkan"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45ff36feae801fa23d29acd74082603a0145a697a23595757dd4e78828ab33da"
+dependencies = [
+ "arrayvec",
+ "ash",
+ "byteorder",
+ "core-graphics 0.19.0",
+ "gfx-hal",
+ "lazy_static",
+ "log",
+ "objc",
+ "raw-window-handle",
+ "smallvec",
+ "winapi 0.3.8",
+ "x11",
+]
+
+[[package]]
+name = "gfx-descriptor"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bf35f5d66d1bc56e63e68d7528441453f25992bd954b84309d23c659df2c5da"
+dependencies = [
+ "fxhash",
+ "gfx-hal",
+ "log",
+]
+
+[[package]]
+name = "gfx-hal"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc96180204064c9493e0fe4a9efeb721e0ac59fe8e1906d0c659142a93114fb1"
+dependencies = [
+ "bitflags",
+ "raw-window-handle",
+]
+
+[[package]]
+name = "gfx-memory"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2eed6cda674d9cd4d92229102dbd544292124533d236904f987e9afab456137"
+dependencies = [
+ "fxhash",
+ "gfx-hal",
+ "hibitset",
+ "log",
+ "slab",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61565ff7aaace3525556587bd2dc31d4a07071957be715e63ce7b1eccf51a8f4"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "hibitset"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93a1bb8316a44459a7d14253c4d28dd7395cbd23cc04a68c46e851b8e46d64b1"
+dependencies = [
+ "atom",
+]
+
+[[package]]
+name = "humantime"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df004cfca50ef23c36850aaaa59ad52cc70d0e90243c3c7737a4dd32dc7a3c4f"
+dependencies = [
+ "quick-error",
+]
+
+[[package]]
+name = "instant"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7152d2aed88aa566e7a342250f21ba2222c1ae230ad577499dbfa3c18475b80"
+
+[[package]]
+name = "iovec"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a27d435371a2fa5b6d2b028a74bbdb1234f308da363226a2854ca3ff8ba7055"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "kernel32-sys"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
+dependencies = [
+ "winapi 0.2.8",
+ "winapi-build",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "lazycell"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b294d6fa9ee409a054354afc4352b0b9ef7ca222c69b8812cbea9e7d2bf3783f"
+
+[[package]]
+name = "libc"
+version = "0.2.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99e85c08494b21a9054e7fe1374a732aeadaff3980b6990b94bfd3a70f690005"
+
+[[package]]
+name = "libloading"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2b111a074963af1d37a139918ac6d49ad1d0d5e47f72fd55388619691a7d753"
+dependencies = [
+ "cc",
+ "winapi 0.3.8",
+]
+
+[[package]]
+name = "line_drawing"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cc7ad3d82c845bdb5dde34ffdcc7a5fb4d2996e1e1ee0f19c33bc80e15196b9"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "lock_api"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4da24a77a3d8a6d4862d95f72e6fdb9c09a643ecdb402d754004a557f2bec75"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "mach"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86dd2487cdfea56def77b88438a2c915fb45113c5319bfe7e14306ca4cd0b0e1"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "malloc_buf"
+version = "0.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "maybe-uninit"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00"
+
+[[package]]
+name = "memchr"
+version = "2.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400"
+
+[[package]]
+name = "memmap"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6585fd95e7bb50d6cc31e20d4cf9afb4e2ba16c5846fc76793f11218da9c475b"
+dependencies = [
+ "libc",
+ "winapi 0.3.8",
+]
+
+[[package]]
+name = "metal"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e198a0ee42bdbe9ef2c09d0b9426f3b2b47d90d93a4a9b0395c4cea605e92dc0"
+dependencies = [
+ "bitflags",
+ "block",
+ "cocoa 0.20.0",
+ "core-graphics 0.19.0",
+ "foreign-types",
+ "log",
+ "objc",
+]
+
+[[package]]
+name = "mio"
+version = "0.6.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "302dec22bcf6bae6dfb69c647187f4b4d0fb6f535521f7bc022430ce8e12008f"
+dependencies = [
+ "cfg-if",
+ "fuchsia-zircon",
+ "fuchsia-zircon-sys",
+ "iovec",
+ "kernel32-sys",
+ "libc",
+ "log",
+ "miow",
+ "net2",
+ "slab",
+ "winapi 0.2.8",
+]
+
+[[package]]
+name = "mio-extras"
+version = "2.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52403fe290012ce777c4626790c8951324a2b9e3316b3143779c72b029742f19"
+dependencies = [
+ "lazycell",
+ "log",
+ "mio",
+ "slab",
+]
+
+[[package]]
+name = "miow"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c1f2f3b1cf331de6896aabf6e9d55dca90356cc9960cca7eaaf408a355ae919"
+dependencies = [
+ "kernel32-sys",
+ "net2",
+ "winapi 0.2.8",
+ "ws2_32-sys",
+]
+
+[[package]]
+name = "net2"
+version = "0.2.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42550d9fb7b6684a6d404d9fa7250c2eb2646df731d1c06afc06dcee9e1bcf88"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "winapi 0.3.8",
+]
+
+[[package]]
+name = "nix"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c722bee1037d430d0f8e687bbdbf222f27cc6e4e68d5caf630857bb2b6dbdce"
+dependencies = [
+ "bitflags",
+ "cc",
+ "cfg-if",
+ "libc",
+ "void",
+]
+
+[[package]]
+name = "nix"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b2e0b4f3320ed72aaedb9a5ac838690a8047c7b275da22711fddff4f8a14229"
+dependencies = [
+ "bitflags",
+ "cc",
+ "cfg-if",
+ "libc",
+ "void",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c62be47e61d1842b9170f0fdeec8eba98e60e90e5446449a0545e5152acd7096"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "objc"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1"
+dependencies = [
+ "malloc_buf",
+ "objc_exception",
+]
+
+[[package]]
+name = "objc_exception"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad970fb455818ad6cba4c122ad012fae53ae8b4795f86378bce65e4f6bab2ca4"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "ordered-float"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18869315e81473c951eb56ad5558bbc56978562d3ecfb87abb7a1e944cea4518"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "parking_lot"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3a704eb390aafdc107b0e392f56a82b668e3a71366993b5340f5833fd62505e"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d58c7c768d4ba344e3e8d72518ac13e259d7c7ade24167003b8488e10b6740a3"
+dependencies = [
+ "cfg-if",
+ "cloudabi",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "winapi 0.3.8",
+]
+
+[[package]]
+name = "peek-poke"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d93fd6a575ebf1ac2668d08443c97a22872cfb463fd8b7ddd141e9f6be59af2f"
+dependencies = [
+ "peek-poke-derive",
+]
+
+[[package]]
+name = "peek-poke-derive"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fb44a25c5bba983be0fc8592dfaf3e6d0935ce8be0c6b15b2a39507af34a926"
+dependencies = [
+ "proc-macro2 1.0.10",
+ "quote 1.0.3",
+ "syn",
+ "synstructure",
+ "unicode-xid 0.2.0",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05da548ad6865900e60eaba7f589cc0783590a92e940c26953ff81ddbab2d677"
+
+[[package]]
+name = "player"
+version = "0.1.0"
+dependencies = [
+ "env_logger",
+ "log",
+ "ron",
+ "wgpu-core",
+ "wgpu-types",
+ "winit",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "0.4.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf3d2011ab5c909338f7887f4fc896d35932e29146c12c8d01da6b22a80ba759"
+dependencies = [
+ "unicode-xid 0.1.0",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df246d292ff63439fea9bc8c0a270bed0e390d5ebd4db4ba15aba81111b5abe3"
+dependencies = [
+ "unicode-xid 0.2.0",
+]
+
+[[package]]
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
+[[package]]
+name = "quote"
+version = "0.6.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce23b6b870e8f94f81fb0a363d65d86675884b34a09043c81e5562f11c1f8e1"
+dependencies = [
+ "proc-macro2 0.4.30",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bdc6c187c65bca4260c9011c9e3132efe4909da44726bad24cf7572ae338d7f"
+dependencies = [
+ "proc-macro2 1.0.10",
+]
+
+[[package]]
+name = "range-alloc"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd5927936723a9e8b715d37d7e4b390455087c4bdf25b9f702309460577b14f9"
+
+[[package]]
+name = "raw-window-handle"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a441a7a6c80ad6473bd4b74ec1c9a4c951794285bf941c2126f607c72e48211"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.1.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2439c63f3f6139d1b57529d16bc3b8bb855230c8efcc5d3a896c8bea7c3b1e84"
+
+[[package]]
+name = "regex"
+version = "1.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6020f034922e3194c711b82a627453881bc4682166cabb07134a10c26ba7692"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+ "thread_local",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fe5bd57d1d7414c6b5ed48563a2c855d995ff777729dcd91c369ec7fea395ae"
+
+[[package]]
+name = "ron"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ece421e0c4129b90e4a35b6f625e472e96c552136f5093a2f4fa2bbb75a62d5"
+dependencies = [
+ "base64",
+ "bitflags",
+ "serde",
+]
+
+[[package]]
+name = "rusttype"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "310942406a39981bed7e12b09182a221a29e0990f3e7e0c971f131922ed135d5"
+dependencies = [
+ "rusttype 0.8.3",
+]
+
+[[package]]
+name = "rusttype"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f61411055101f7b60ecf1041d87fb74205fb20b0c7a723f07ef39174cf6b4c0"
+dependencies = [
+ "approx",
+ "ordered-float",
+ "stb_truetype",
+]
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+
+[[package]]
+name = "serde"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36df6ac6412072f67cf767ebbde4133a5b2e88e76dc6187fa7104cd16f783399"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e549e3abf4fb8621bd1609f11dfc9f5e50320802273b12f3811a67e6716ea6c"
+dependencies = [
+ "proc-macro2 1.0.10",
+ "quote 1.0.3",
+ "syn",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
+
+[[package]]
+name = "smallvec"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7cb5678e1615754284ec264d9bb5b4c27d2018577fd90ac0ceb578591ed5ee4"
+
+[[package]]
+name = "smithay-client-toolkit"
+version = "0.6.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "421c8dc7acf5cb205b88160f8b4cc2c5cfabe210e43b2f80f009f4c1ef910f1d"
+dependencies = [
+ "andrew",
+ "bitflags",
+ "dlib",
+ "lazy_static",
+ "memmap",
+ "nix 0.14.1",
+ "wayland-client",
+ "wayland-protocols",
+]
+
+[[package]]
+name = "spirv_cross"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "946216f8793f7199e3ea5b995ee8dc20a0ace1fcf46293a0ef4c17e1d046dbde"
+dependencies = [
+ "cc",
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "stb_truetype"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f77b6b07e862c66a9f3e62a07588fee67cd90a9135a2b942409f195507b4fb51"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "storage-map"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd0a4829a5c591dc24a944a736d6b1e4053e51339a79fd5d4702c4c999a9c45e"
+dependencies = [
+ "lock_api",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "410a7488c0a728c7ceb4ad59b9567eb4053d02e8cc7f5c0e0eeeb39518369213"
+dependencies = [
+ "proc-macro2 1.0.10",
+ "quote 1.0.3",
+ "unicode-xid 0.2.0",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67656ea1dc1b41b1451851562ea232ec2e5a80242139f7e679ceccfb5d61f545"
+dependencies = [
+ "proc-macro2 1.0.10",
+ "quote 1.0.3",
+ "syn",
+ "unicode-xid 0.2.0",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb6bfa289a4d7c5766392812c0a1f4c1ba45afa1ad47803c11e1f407d846d75f"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d40c6d1b69745a6ec6fb1ca717914848da4b44ae29d9b3080cbee91d72a69b14"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "typenum"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "373c8a200f9e67a0c95e62a4f52fbf80c23b4381c05a17845531982fa99e6b33"
+
+[[package]]
+name = "unicode-xid"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c"
+
+[[package]]
+name = "uom"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cec796ec5f7ac557631709079168286056205c51c60aac33f51764bdc7b8dc4"
+dependencies = [
+ "num-traits",
+ "typenum",
+]
+
+[[package]]
+name = "vec_map"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05c78687fb1a80548ae3250346c3db86a80a7cdd77bda190189f2d0a0987c81a"
+
+[[package]]
+name = "void"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
+
+[[package]]
+name = "walkdir"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "777182bc735b6424e1a57516d35ed72cb8019d85c8c9bf536dccb3445c1a2f7d"
+dependencies = [
+ "same-file",
+ "winapi 0.3.8",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2cc57ce05287f8376e998cbddfb4c8cb43b84a7ec55cf4551d7c00eef317a47f"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d967d37bf6c16cca2973ca3af071d0a2523392e4a594548155d89a678f4237cd"
+dependencies = [
+ "bumpalo",
+ "lazy_static",
+ "log",
+ "proc-macro2 1.0.10",
+ "quote 1.0.3",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8bd151b63e1ea881bb742cd20e1d6127cef28399558f3b5d415289bc41eee3a4"
+dependencies = [
+ "quote 1.0.3",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d68a5b36eef1be7868f668632863292e37739656a80fc4b9acec7b0bd35a4931"
+dependencies = [
+ "proc-macro2 1.0.10",
+ "quote 1.0.3",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf76fe7d25ac79748a37538b7daeed1c7a6867c92d3245c12c6222e4a20d639"
+
+[[package]]
+name = "wayland-client"
+version = "0.23.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af1080ebe0efabcf12aef2132152f616038f2d7dcbbccf7b2d8c5270fe14bcda"
+dependencies = [
+ "bitflags",
+ "calloop",
+ "downcast-rs",
+ "libc",
+ "mio",
+ "nix 0.14.1",
+ "wayland-commons",
+ "wayland-scanner",
+ "wayland-sys",
+]
+
+[[package]]
+name = "wayland-commons"
+version = "0.23.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb66b0d1a27c39bbce712b6372131c6e25149f03ffb0cd017cf8f7de8d66dbdb"
+dependencies = [
+ "nix 0.14.1",
+ "wayland-sys",
+]
+
+[[package]]
+name = "wayland-protocols"
+version = "0.23.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6cc286643656742777d55dc8e70d144fa4699e426ca8e9d4ef454f4bf15ffcf9"
+dependencies = [
+ "bitflags",
+ "wayland-client",
+ "wayland-commons",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-scanner"
+version = "0.23.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93b02247366f395b9258054f964fe293ddd019c3237afba9be2ccbe9e1651c3d"
+dependencies = [
+ "proc-macro2 0.4.30",
+ "quote 0.6.13",
+ "xml-rs",
+]
+
+[[package]]
+name = "wayland-sys"
+version = "0.23.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d94e89a86e6d6d7c7c9b19ebf48a03afaac4af6bc22ae570e9a24124b75358f4"
+dependencies = [
+ "dlib",
+ "lazy_static",
+]
+
+[[package]]
+name = "wgpu-core"
+version = "0.5.0"
+dependencies = [
+ "arrayvec",
+ "battery",
+ "bitflags",
+ "copyless",
+ "fxhash",
+ "gfx-backend-dx11",
+ "gfx-backend-dx12",
+ "gfx-backend-empty",
+ "gfx-backend-metal",
+ "gfx-backend-vulkan",
+ "gfx-descriptor",
+ "gfx-hal",
+ "gfx-memory",
+ "log",
+ "parking_lot",
+ "peek-poke",
+ "raw-window-handle",
+ "ron",
+ "serde",
+ "smallvec",
+ "vec_map",
+ "wgpu-types",
+]
+
+[[package]]
+name = "wgpu-types"
+version = "0.5.0"
+dependencies = [
+ "bitflags",
+ "peek-poke",
+ "serde",
+]
+
+[[package]]
+name = "winapi"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
+
+[[package]]
+name = "winapi"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8093091eeb260906a183e6ae1abdba2ef5ef2257a21801128899c3fc699229c6"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-build"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi 0.3.8",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "winit"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc53342d3d1a3d57f3949e0692d93d5a8adb7814d8683cef4a09c2b550e94246"
+dependencies = [
+ "android_glue",
+ "bitflags",
+ "cocoa 0.19.1",
+ "core-foundation 0.6.4",
+ "core-graphics 0.17.3",
+ "core-video-sys",
+ "dispatch",
+ "instant",
+ "lazy_static",
+ "libc",
+ "log",
+ "mio",
+ "mio-extras",
+ "objc",
+ "parking_lot",
+ "percent-encoding",
+ "raw-window-handle",
+ "smithay-client-toolkit",
+ "wayland-client",
+ "winapi 0.3.8",
+ "x11-dl",
+]
+
+[[package]]
+name = "wio"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d129932f4644ac2396cb456385cbf9e63b5b30c6e8dc4820bdca4eb082037a5"
+dependencies = [
+ "winapi 0.3.8",
+]
+
+[[package]]
+name = "ws2_32-sys"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"
+dependencies = [
+ "winapi 0.2.8",
+ "winapi-build",
+]
+
+[[package]]
+name = "x11"
+version = "2.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ecd092546cb16f25783a5451538e73afc8d32e242648d54f4ae5459ba1e773"
+dependencies = [
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "x11-dl"
+version = "2.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bf981e3a5b3301209754218f962052d4d9ee97e478f4d26d4a6eced34c1fef8"
+dependencies = [
+ "lazy_static",
+ "libc",
+ "maybe-uninit",
+ "pkg-config",
+]
+
+[[package]]
+name = "xdg"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d089681aa106a86fade1b0128fb5daf07d5867a509ab036d99988dec80429a57"
+
+[[package]]
+name = "xml-rs"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b07db065a5cf61a7e4ba64f29e67db906fb1787316516c4e6e5ff0fea1efcd8a"
diff --git a/player/Cargo.toml b/player/Cargo.toml
index aa51b5652a..87787438bb 100644
--- a/player/Cargo.toml
+++ b/player/Cargo.toml
@@ -16,8 +16,9 @@ publish = false
 
 [dependencies]
 env_logger = "0.7"
-ron = { version = "0.5" }
-winit = { version = "0.22" }
+log = "0.4"
+ron = "0.5"
+winit = { version = "0.22", optional = true }
 
 [dependencies.wgt]
 path = "../wgpu-types"
diff --git a/player/src/main.rs b/player/src/main.rs
index 65329259dc..ca02ad0981 100644
--- a/player/src/main.rs
+++ b/player/src/main.rs
@@ -5,12 +5,12 @@
 use wgc::device::trace;
 
 use std::{
+    ffi::CString,
     fmt::Debug,
     fs::File,
     marker::PhantomData,
     path::{Path, PathBuf},
 };
-use winit::{event_loop::EventLoop, window::WindowBuilder};
 
 macro_rules! gfx_select {
     ($id:expr => $global:ident.$method:ident( $($param:expr),+ )) => {
@@ -28,6 +28,24 @@ macro_rules! gfx_select {
     };
 }
 
+struct Label(Option<CString>);
+impl Label {
+    fn new(text: &str) -> Self {
+        Self(if text.is_empty() {
+            None
+        } else {
+            Some(CString::new(text).expect("invalid label"))
+        })
+    }
+
+    fn as_ptr(&self) -> *const std::os::raw::c_char {
+        match self.0 {
+            Some(ref c_string) => c_string.as_ptr(),
+            None => std::ptr::null(),
+        }
+    }
+}
+
 #[derive(Debug)]
 struct IdentityPassThrough<I>(PhantomData<I>);
 
@@ -52,31 +70,134 @@ impl<I: Clone + Debug + wgc::id::TypedId> wgc::hub::IdentityHandlerFactory<I>
 }
 impl wgc::hub::GlobalIdentityHandlerFactory for IdentityPassThroughFactory {}
 
+trait GlobalExt {
+    fn encode_commands<B: wgc::hub::GfxBackend>(
+        &self,
+        encoder: wgc::id::CommandEncoderId,
+        commands: Vec<trace::Command>,
+    ) -> wgc::id::CommandBufferId;
+}
+
+impl GlobalExt for wgc::hub::Global<IdentityPassThroughFactory> {
+    fn encode_commands<B: wgc::hub::GfxBackend>(
+        &self,
+        encoder: wgc::id::CommandEncoderId,
+        commands: Vec<trace::Command>,
+    ) -> wgc::id::CommandBufferId {
+        for command in commands {
+            match command {
+                trace::Command::CopyBufferToBuffer {
+                    src,
+                    src_offset,
+                    dst,
+                    dst_offset,
+                    size,
+                } => self.command_encoder_copy_buffer_to_buffer::<B>(
+                    encoder, src, src_offset, dst, dst_offset, size,
+                ),
+                trace::Command::CopyBufferToTexture { src, dst, size } => {
+                    self.command_encoder_copy_buffer_to_texture::<B>(encoder, &src, &dst, size)
+                }
+                trace::Command::CopyTextureToBuffer { src, dst, size } => {
+                    self.command_encoder_copy_texture_to_buffer::<B>(encoder, &src, &dst, size)
+                }
+                trace::Command::CopyTextureToTexture { src, dst, size } => {
+                    self.command_encoder_copy_texture_to_texture::<B>(encoder, &src, &dst, size)
+                }
+                trace::Command::RunComputePass {
+                    commands,
+                    dynamic_offsets,
+                } => unsafe {
+                    let mut offsets = &dynamic_offsets[..];
+                    let mut pass = wgc::command::RawPass::new_compute(encoder);
+                    for com in commands {
+                        pass.encode(&com);
+                        if let wgc::command::ComputeCommand::SetBindGroup {
+                            num_dynamic_offsets,
+                            ..
+                        } = com
+                        {
+                            pass.encode_slice(&offsets[..num_dynamic_offsets as usize]);
+                            offsets = &offsets[num_dynamic_offsets as usize..];
+                        }
+                    }
+                    let (data, _) = pass.finish_compute();
+                    self.command_encoder_run_compute_pass::<B>(encoder, &data);
+                },
+                trace::Command::RunRenderPass {
+                    target_colors,
+                    target_depth_stencil,
+                    commands,
+                    dynamic_offsets,
+                } => unsafe {
+                    let mut offsets = &dynamic_offsets[..];
+                    let mut pass = wgc::command::RawPass::new_render(
+                        encoder,
+                        &wgc::command::RenderPassDescriptor {
+                            color_attachments: target_colors.as_ptr(),
+                            color_attachments_length: target_colors.len(),
+                            depth_stencil_attachment: target_depth_stencil.as_ref(),
+                        },
+                    );
+                    for com in commands {
+                        pass.encode(&com);
+                        if let wgc::command::RenderCommand::SetBindGroup {
+                            num_dynamic_offsets,
+                            ..
+                        } = com
+                        {
+                            pass.encode_slice(&offsets[..num_dynamic_offsets as usize]);
+                            offsets = &offsets[num_dynamic_offsets as usize..];
+                        }
+                    }
+                    let (data, _) = pass.finish_render();
+                    self.command_encoder_run_render_pass::<B>(encoder, &data);
+                },
+            }
+        }
+        self.command_encoder_finish::<B>(encoder, &wgt::CommandBufferDescriptor { todo: 0 })
+    }
+}
+
 fn main() {
+    #[cfg(feature = "winit")]
+    use winit::{event_loop::EventLoop, window::WindowBuilder};
+
     env_logger::init();
 
-    let folder = match std::env::args().nth(1) {
+    //TODO: setting for the backend bits
+
+    let dir = match std::env::args().nth(1) {
         Some(arg) if Path::new(&arg).is_dir() => PathBuf::from(arg),
-        _ => panic!("Provide the folder path as the parameter"),
+        _ => panic!("Provide the dir path as the parameter"),
     };
 
-    let file = File::open(folder.join(trace::FILE_NAME)).unwrap();
+    log::info!("Loading trace '{:?}'", dir);
+    let file = File::open(dir.join(trace::FILE_NAME)).unwrap();
     let actions: Vec<trace::Action> = ron::de::from_reader(file).unwrap();
+    log::info!("Found {} actions", actions.len());
 
-    let event_loop = EventLoop::new();
-    let mut builder = WindowBuilder::new();
-    builder = builder.with_title("wgpu player");
-    let window = builder.build(&event_loop).unwrap();
+    #[cfg(feature = "winit")]
+    let event_loop = {
+        log::info!("Creating a window");
+        EventLoop::new()
+    };
+    #[cfg(feature = "winit")]
+    let window = WindowBuilder::new()
+        .with_title("wgpu player")
+        .with_resizable(false)
+        .build(&event_loop)
+        .unwrap();
 
     let global = wgc::hub::Global::new("player", IdentityPassThroughFactory);
-    let mut surface_id_manager = wgc::hub::IdentityManager::from_index(1);
     let mut adapter_id_manager = wgc::hub::IdentityManager::default();
-    let mut device_id_manager = wgc::hub::IdentityManager::default();
+    let mut command_buffer_id_manager = wgc::hub::IdentityManager::default();
 
+    #[cfg(feature = "winit")]
     let (_size, surface) = {
         let size = window.inner_size();
-        let id = surface_id_manager.alloc(wgt::Backend::Empty);
-        let surface = global.instance_create_surface(&window, id);
+        let id = wgc::id::TypedId::zip(1, 0, wgt::Backend::Empty);
+        let surface = global.instance_create_surface(window.raw_window_handle(), id);
         (size, surface)
     };
 
@@ -84,7 +205,10 @@ fn main() {
         .pick_adapter(
             &wgc::instance::RequestAdapterOptions {
                 power_preference: wgt::PowerPreference::Default,
+                #[cfg(feature = "winit")]
                 compatible_surface: Some(surface),
+                #[cfg(not(feature = "winit"))]
+                compatible_surface: None,
             },
             wgc::instance::AdapterInputs::IdSet(
                 &vec![
@@ -92,30 +216,180 @@ fn main() {
                     adapter_id_manager.alloc(wgt::Backend::Dx12),
                     adapter_id_manager.alloc(wgt::Backend::Metal),
                 ],
-                |id| wgc::id::TypedId::unzip(*id).2,
+                |id| id.backend(),
             ),
         )
         .unwrap();
 
-    let limits = match actions.first() {
-        Some(&trace::Action::Init { ref limits }) => limits.clone(),
-        other => panic!("Unsupported first action: {:?}", other),
-    };
-
-    let device = gfx_select!(adapter => global.adapter_request_device(
-        adapter,
-        &wgt::DeviceDescriptor {
-            extensions: wgt::Extensions {
-                anisotropic_filtering: false,
-            },
-            limits,
-        },
-        device_id_manager.alloc(wgt::Backend::Vulkan)
-    ));
+    let mut device = wgc::id::DeviceId::default();
 
-    for action in actions.into_iter().skip(1) {
+    log::info!("Executing actions");
+    for action in actions {
+        use wgc::device::trace::Action as A;
         match action {
-            _ => {}
+            A::Init { limits } => {
+                log::info!("Initializing the device");
+                device = gfx_select!(adapter => global.adapter_request_device(
+                    adapter,
+                    &wgt::DeviceDescriptor {
+                        extensions: wgt::Extensions {
+                            anisotropic_filtering: false,
+                        },
+                        limits,
+                    },
+                    wgc::id::TypedId::zip(1, 0, wgt::Backend::Empty)
+                ));
+            }
+            A::CreateBuffer { id, desc } => {
+                let label = Label::new(&desc.label);
+                gfx_select!(device => global.device_create_buffer(device, &desc.map_label(|_| label.as_ptr()), id));
+            }
+            A::DestroyBuffer(id) => {
+                gfx_select!(device => global.buffer_destroy(id));
+            }
+            A::CreateTexture { id, desc } => {
+                let label = Label::new(&desc.label);
+                gfx_select!(device => global.device_create_texture(device, &desc.map_label(|_| label.as_ptr()), id));
+            }
+            A::DestroyTexture(id) => {
+                gfx_select!(device => global.texture_destroy(id));
+            }
+            A::CreateTextureView {
+                id,
+                parent_id,
+                desc,
+            } => {
+                let label = desc.as_ref().map_or(Label(None), |d| Label::new(&d.label));
+                gfx_select!(device => global.texture_create_view(parent_id, desc.map(|d| d.map_label(|_| label.as_ptr())).as_ref(), id));
+            }
+            A::DestroyTextureView(id) => {
+                gfx_select!(device => global.texture_view_destroy(id));
+            }
+            A::CreateSampler { id, desc } => {
+                let label = Label::new(&desc.label);
+                gfx_select!(device => global.device_create_sampler(device, &desc.map_label(|_| label.as_ptr()), id));
+            }
+            A::DestroySampler(id) => {
+                gfx_select!(device => global.sampler_destroy(id));
+            }
+            A::CreateSwapChain { id: _, desc } => {
+                #[cfg(feature = "winit")]
+                {
+                    log::info!("Initializing the swapchain");
+                    window.set_inner_size(winit::dpi::PhysicalSize::new(desc.width, desc.height));
+                    gfx_select!(device => global.device_create_swap_chain(device, surface, &desc));
+                }
+                #[cfg(not(feature = "winit"))]
+                let _ = desc;
+            }
+            A::GetSwapChainTexture { id, parent_id } => {
+                gfx_select!(device => global.swap_chain_get_next_texture(parent_id, id)).unwrap();
+            }
+            A::PresentSwapChain(id) => {
+                gfx_select!(device => global.swap_chain_present(id));
+            }
+            A::CreateBindGroupLayout { id, label, entries } => {
+                let label = Label::new(&label);
+                gfx_select!(device => global.device_create_bind_group_layout(
+                    device,
+                    &wgc::binding_model::BindGroupLayoutDescriptor {
+                        label: label.as_ptr(),
+                        entries: entries.as_ptr(),
+                        entries_length: entries.len(),
+                    },
+                    id));
+            }
+            A::DestroyBindGroupLayout(id) => {
+                gfx_select!(device => global.bind_group_layout_destroy(id));
+            }
+            A::CreatePipelineLayout {
+                id,
+                bind_group_layouts,
+            } => {
+                gfx_select!(device => global.device_create_pipeline_layout(
+                    device,
+                    &wgc::binding_model::PipelineLayoutDescriptor {
+                        bind_group_layouts: bind_group_layouts.as_ptr(),
+                        bind_group_layouts_length: bind_group_layouts.len(),
+                    },
+                    id));
+            }
+            A::DestroyPipelineLayout(id) => {
+                gfx_select!(device => global.pipeline_layout_destroy(id));
+            }
+            A::CreateBindGroup {
+                id,
+                label,
+                layout_id,
+                entries,
+            } => {
+                use wgc::binding_model as bm;
+                let label = Label::new(&label);
+                let entry_vec = entries
+                    .into_iter()
+                    .map(|(binding, res)| wgc::binding_model::BindGroupEntry {
+                        binding,
+                        resource: match res {
+                            trace::BindingResource::Buffer { id, offset, size } => {
+                                bm::BindingResource::Buffer(bm::BufferBinding {
+                                    buffer: id,
+                                    offset,
+                                    size,
+                                })
+                            }
+                            trace::BindingResource::Sampler(id) => bm::BindingResource::Sampler(id),
+                            trace::BindingResource::TextureView(id) => {
+                                bm::BindingResource::TextureView(id)
+                            }
+                        },
+                    })
+                    .collect::<Vec<_>>();
+                gfx_select!(device => global.device_create_bind_group(
+                    device,
+                    &wgc::binding_model::BindGroupDescriptor {
+                        label: label.as_ptr(),
+                        layout: layout_id,
+                        entries: entry_vec.as_ptr(),
+                        entries_length: entry_vec.len(),
+                    },
+                    id
+                ));
+            }
+            A::DestroyBindGroup(id) => {
+                gfx_select!(device => global.bind_group_destroy(id));
+            }
+            A::CreateShaderModule { id, data } => {
+                let spv = wgt::read_spirv(File::open(dir.join(data)).unwrap()).unwrap();
+                gfx_select!(device => global.device_create_shader_module(
+                    device,
+                    &wgc::pipeline::ShaderModuleDescriptor {
+                        code: wgc::U32Array {
+                            bytes: spv.as_ptr(),
+                            length: spv.len(),
+                        },
+                    },
+                    id
+                ));
+            }
+            A::DestroyShaderModule(id) => {
+                gfx_select!(device => global.shader_module_destroy(id));
+            }
+            A::WriteBuffer { id, data, range } => {
+                let bin = std::fs::read(dir.join(data)).unwrap();
+                let size = (range.end - range.start) as usize;
+                gfx_select!(device => global.device_set_buffer_sub_data(device, id, range.start, &bin[..size]));
+            }
+            A::Submit(commands) => {
+                let encoder = gfx_select!(device => global.device_create_command_encoder(
+                    device,
+                    &wgt::CommandEncoderDescriptor {
+                        label: std::ptr::null(),
+                    },
+                    command_buffer_id_manager.alloc(device.backend())
+                ));
+                let comb = gfx_select!(device => global.encode_commands(encoder, commands));
+                gfx_select!(device => global.queue_submit(device, &[comb]));
+            }
         }
     }
 }
diff --git a/wgpu-core/src/command/mod.rs b/wgpu-core/src/command/mod.rs
index 1716bf69b0..ac690bd5ad 100644
--- a/wgpu-core/src/command/mod.rs
+++ b/wgpu-core/src/command/mod.rs
@@ -109,13 +109,13 @@ impl RawPass {
     }
 
     #[inline]
-    unsafe fn encode<C: peek_poke::Poke>(&mut self, command: &C) {
+    pub unsafe fn encode<C: peek_poke::Poke>(&mut self, command: &C) {
         self.ensure_extra_size(C::max_size());
         self.data = command.poke_into(self.data);
     }
 
     #[inline]
-    unsafe fn encode_slice<T: Copy>(&mut self, data: &[T]) {
+    pub unsafe fn encode_slice<T: Copy>(&mut self, data: &[T]) {
         let align_offset = self.data.align_offset(mem::align_of::<T>());
         let extra = align_offset + mem::size_of::<T>() * data.len();
         self.ensure_extra_size(extra);
diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs
index 5bd78afbe3..5d2f4413ed 100644
--- a/wgpu-core/src/device/mod.rs
+++ b/wgpu-core/src/device/mod.rs
@@ -610,7 +610,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         match device.trace {
             Some(ref trace) => {
                 let mut trace = trace.lock();
-                let data_path = trace.make_binary("buffer", data);
+                let data_path = trace.make_binary("bin", data);
                 trace.add(trace::Action::WriteBuffer {
                     id: buffer_id,
                     data: data_path,
@@ -1481,7 +1481,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         match device.trace {
             Some(ref trace) => {
                 let mut trace = trace.lock();
-                let data = trace.make_binary("shader", unsafe {
+                let data = trace.make_binary("spv", unsafe {
                     slice::from_raw_parts(desc.code.bytes as *const u8, desc.code.length * 4)
                 });
                 trace.add(trace::Action::CreateShaderModule { id, data });
@@ -2420,7 +2420,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                         Some(ref trace) => {
                             let mut trace = trace.lock();
                             let size = sub_range.size_to(buffer.size);
-                            let data = trace.make_binary("buffer", unsafe {
+                            let data = trace.make_binary("bin", unsafe {
                                 slice::from_raw_parts(ptr, size as usize)
                             });
                             trace.add(trace::Action::WriteBuffer {
diff --git a/wgpu-core/src/device/trace.rs b/wgpu-core/src/device/trace.rs
index c8a82f9568..6400769f2c 100644
--- a/wgpu-core/src/device/trace.rs
+++ b/wgpu-core/src/device/trace.rs
@@ -160,7 +160,7 @@ impl Trace {
 
     pub fn make_binary(&mut self, kind: &str, data: &[u8]) -> String {
         self.binary_id += 1;
-        let name = format!("{}{}.bin", kind, self.binary_id);
+        let name = format!("data{}.{}", self.binary_id, kind);
         let _ = std::fs::write(self.path.join(&name), data);
         name
     }
diff --git a/wgpu-core/src/instance.rs b/wgpu-core/src/instance.rs
index 0995ef65e4..34137d02e3 100644
--- a/wgpu-core/src/instance.rs
+++ b/wgpu-core/src/instance.rs
@@ -208,14 +208,14 @@ impl<I: Clone> AdapterInputs<'_, I> {
 
 impl<G: GlobalIdentityHandlerFactory> Global<G> {
     #[cfg(feature = "raw-window-handle")]
-    pub fn instance_create_surface<W: raw_window_handle::HasRawWindowHandle>(
+    pub fn instance_create_surface(
         &self,
-        window: &W,
+        handle: raw_window_handle::RawWindowHandle,
         id_in: Input<G, SurfaceId>,
     ) -> SurfaceId {
         use raw_window_handle::RawWindowHandle as Rwh;
 
-        let surface = match window.raw_window_handle() {
+        let surface = match handle {
             #[cfg(target_os = "ios")]
             Rwh::IOS(h) => Surface {
                 #[cfg(feature = "gfx-backend-vulkan")]
diff --git a/wgpu-core/src/resource.rs b/wgpu-core/src/resource.rs
index 917b4b16a2..227cd1af5e 100644
--- a/wgpu-core/src/resource.rs
+++ b/wgpu-core/src/resource.rs
@@ -85,6 +85,9 @@ pub enum BufferMapState {
     Idle,
 }
 
+unsafe impl Send for BufferMapState {}
+unsafe impl Sync for BufferMapState {}
+
 pub enum BufferMapOperation {
     Read {
         callback: crate::device::BufferMapReadCallback,

From ddf96e29b90ca4ce3959c9723a54a08387245f9e Mon Sep 17 00:00:00 2001
From: Dzmitry Malyshau <kvarkus@gmail.com>
Date: Wed, 29 Apr 2020 15:36:50 -0400
Subject: [PATCH 09/12] trace: support pipelines, refactor destruction sequence

---
 Cargo.lock                    |   1 +
 player/Cargo.toml             |   1 +
 player/src/main.rs            | 125 +++++++++++++++++++++++++++++---
 wgpu-core/src/device/life.rs  |  20 ++++++
 wgpu-core/src/device/mod.rs   | 129 ++++++++++++++++++----------------
 wgpu-core/src/device/trace.rs |  72 +++++++++++++++++++
 wgpu-core/src/id.rs           |   2 +-
 7 files changed, 278 insertions(+), 72 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a3f743c9ea..68c68f58b9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -840,6 +840,7 @@ version = "0.1.0"
 dependencies = [
  "env_logger",
  "log",
+ "raw-window-handle",
  "ron",
  "wgpu-core",
  "wgpu-types",
diff --git a/player/Cargo.toml b/player/Cargo.toml
index 87787438bb..a7d377fd0c 100644
--- a/player/Cargo.toml
+++ b/player/Cargo.toml
@@ -17,6 +17,7 @@ publish = false
 [dependencies]
 env_logger = "0.7"
 log = "0.4"
+raw-window-handle = "0.3"
 ron = "0.5"
 winit = { version = "0.22", optional = true }
 
diff --git a/player/src/main.rs b/player/src/main.rs
index ca02ad0981..8fa7279070 100644
--- a/player/src/main.rs
+++ b/player/src/main.rs
@@ -10,6 +10,7 @@ use std::{
     fs::File,
     marker::PhantomData,
     path::{Path, PathBuf},
+    ptr,
 };
 
 macro_rules! gfx_select {
@@ -41,7 +42,26 @@ impl Label {
     fn as_ptr(&self) -> *const std::os::raw::c_char {
         match self.0 {
             Some(ref c_string) => c_string.as_ptr(),
-            None => std::ptr::null(),
+            None => ptr::null(),
+        }
+    }
+}
+
+struct OwnedProgrammableStage {
+    desc: wgc::pipeline::ProgrammableStageDescriptor,
+    #[allow(dead_code)]
+    entry_point: CString,
+}
+
+impl From<trace::ProgrammableStageDescriptor> for OwnedProgrammableStage {
+    fn from(stage: trace::ProgrammableStageDescriptor) -> Self {
+        let entry_point = CString::new(stage.entry_point.as_str()).unwrap();
+        OwnedProgrammableStage {
+            desc: wgc::pipeline::ProgrammableStageDescriptor {
+                module: stage.module,
+                entry_point: entry_point.as_ptr(),
+            },
+            entry_point,
         }
     }
 }
@@ -178,7 +198,7 @@ fn main() {
     log::info!("Found {} actions", actions.len());
 
     #[cfg(feature = "winit")]
-    let event_loop = {
+    let mut event_loop = {
         log::info!("Creating a window");
         EventLoop::new()
     };
@@ -194,12 +214,10 @@ fn main() {
     let mut command_buffer_id_manager = wgc::hub::IdentityManager::default();
 
     #[cfg(feature = "winit")]
-    let (_size, surface) = {
-        let size = window.inner_size();
-        let id = wgc::id::TypedId::zip(1, 0, wgt::Backend::Empty);
-        let surface = global.instance_create_surface(window.raw_window_handle(), id);
-        (size, surface)
-    };
+    let surface = global.instance_create_surface(
+        raw_window_handle::HasRawWindowHandle::raw_window_handle(&window),
+        wgc::id::TypedId::zip(0, 1, wgt::Backend::Empty),
+    );
 
     let adapter = global
         .pick_adapter(
@@ -272,15 +290,19 @@ fn main() {
             A::DestroySampler(id) => {
                 gfx_select!(device => global.sampler_destroy(id));
             }
-            A::CreateSwapChain { id: _, desc } => {
+            A::CreateSwapChain { id, desc } => {
                 #[cfg(feature = "winit")]
                 {
                     log::info!("Initializing the swapchain");
+                    assert_eq!(id.to_surface_id(), surface);
                     window.set_inner_size(winit::dpi::PhysicalSize::new(desc.width, desc.height));
                     gfx_select!(device => global.device_create_swap_chain(device, surface, &desc));
                 }
                 #[cfg(not(feature = "winit"))]
-                let _ = desc;
+                {
+                    let _ = (id, desc);
+                    panic!("Enable `winit` feature to work with swapchains");
+                }
             }
             A::GetSwapChainTexture { id, parent_id } => {
                 gfx_select!(device => global.swap_chain_get_next_texture(parent_id, id)).unwrap();
@@ -374,6 +396,58 @@ fn main() {
             A::DestroyShaderModule(id) => {
                 gfx_select!(device => global.shader_module_destroy(id));
             }
+            A::CreateComputePipeline { id, desc } => {
+                let cs_stage = OwnedProgrammableStage::from(desc.compute_stage);
+                gfx_select!(device => global.device_create_compute_pipeline(
+                    device,
+                    &wgc::pipeline::ComputePipelineDescriptor {
+                        layout: desc.layout,
+                        compute_stage: cs_stage.desc,
+                    },
+                    id));
+            }
+            A::DestroyComputePipeline(id) => {
+                gfx_select!(device => global.compute_pipeline_destroy(id));
+            }
+            A::CreateRenderPipeline { id, desc } => {
+                let vs_stage = OwnedProgrammableStage::from(desc.vertex_stage);
+                let fs_stage = desc.fragment_stage.map(OwnedProgrammableStage::from);
+                let vertex_buffers = desc
+                    .vertex_state
+                    .vertex_buffers
+                    .iter()
+                    .map(|vb| wgc::pipeline::VertexBufferLayoutDescriptor {
+                        array_stride: vb.array_stride,
+                        step_mode: vb.step_mode,
+                        attributes: vb.attributes.as_ptr(),
+                        attributes_length: vb.attributes.len(),
+                    })
+                    .collect::<Vec<_>>();
+                gfx_select!(device => global.device_create_render_pipeline(
+                    device,
+                    &wgc::pipeline::RenderPipelineDescriptor {
+                        layout: desc.layout,
+                        vertex_stage: vs_stage.desc,
+                        fragment_stage: fs_stage.as_ref().map_or(ptr::null(), |s| &s.desc),
+                        primitive_topology: desc.primitive_topology,
+                        rasterization_state: desc.rasterization_state.as_ref().map_or(ptr::null(), |rs| rs),
+                        color_states: desc.color_states.as_ptr(),
+                        color_states_length: desc.color_states.len(),
+                        depth_stencil_state: desc.depth_stencil_state.as_ref().map_or(ptr::null(), |ds| ds),
+                        vertex_state: wgc::pipeline::VertexStateDescriptor {
+                            index_format: desc.vertex_state.index_format,
+                            vertex_buffers: vertex_buffers.as_ptr(),
+                            vertex_buffers_length: vertex_buffers.len(),
+                        },
+                        sample_count: desc.sample_count,
+                        sample_mask: desc.sample_mask,
+                        alpha_to_coverage_enabled: desc.alpha_to_coverage_enabled,
+                    },
+                    id));
+            }
+            A::DestroyRenderPipeline(id) => {
+                gfx_select!(device => global.render_pipeline_destroy(id));
+            }
             A::WriteBuffer { id, data, range } => {
                 let bin = std::fs::read(dir.join(data)).unwrap();
                 let size = (range.end - range.start) as usize;
@@ -383,7 +457,7 @@ fn main() {
                 let encoder = gfx_select!(device => global.device_create_command_encoder(
                     device,
                     &wgt::CommandEncoderDescriptor {
-                        label: std::ptr::null(),
+                        label: ptr::null(),
                     },
                     command_buffer_id_manager.alloc(device.backend())
                 ));
@@ -392,4 +466,33 @@ fn main() {
             }
         }
     }
+
+    log::info!("Done replay");
+    #[cfg(feature = "winit")]
+    winit::platform::desktop::EventLoopExtDesktop::run_return(
+        &mut event_loop,
+        move |event, _, control_flow| {
+            use winit::{
+                event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+                event_loop::ControlFlow,
+            };
+
+            *control_flow = match event {
+                Event::WindowEvent { event, .. } => match event {
+                    WindowEvent::KeyboardInput {
+                        input:
+                            KeyboardInput {
+                                virtual_keycode: Some(VirtualKeyCode::Escape),
+                                state: ElementState::Pressed,
+                                ..
+                            },
+                        ..
+                    }
+                    | WindowEvent::CloseRequested => ControlFlow::Exit,
+                    _ => ControlFlow::Poll,
+                },
+                _ => ControlFlow::Poll,
+            }
+        },
+    );
 }
diff --git a/wgpu-core/src/device/life.rs b/wgpu-core/src/device/life.rs
index 31a4eca3e0..41546c3456 100644
--- a/wgpu-core/src/device/life.rs
+++ b/wgpu-core/src/device/life.rs
@@ -8,6 +8,8 @@ use crate::{
     track::TrackerSet,
     FastHashMap, RefCount, Stored, SubmissionIndex,
 };
+#[cfg(feature = "trace")]
+use crate::device::trace;
 
 use copyless::VecHelper as _;
 use gfx_descriptor::{DescriptorAllocator, DescriptorSet};
@@ -288,6 +290,8 @@ impl<B: GfxBackend> LifetimeTracker<B> {
         &mut self,
         global: &Global<G>,
         trackers: &Mutex<TrackerSet>,
+        #[cfg(feature = "trace")]
+        trace: Option<&Mutex<trace::Trace>>,
         token: &mut Token<super::Device<B>>,
     ) {
         let hub = B::hub(global);
@@ -298,6 +302,8 @@ impl<B: GfxBackend> LifetimeTracker<B> {
 
             for id in self.suspected_resources.bind_groups.drain(..) {
                 if trackers.bind_groups.remove_abandoned(id) {
+                    #[cfg(feature = "trace")]
+                    trace.map(|t| t.lock().add(trace::Action::DestroyBindGroup(id)));
                     hub.bind_groups.free_id(id);
                     let res = guard.remove(id).unwrap();
 
@@ -332,6 +338,8 @@ impl<B: GfxBackend> LifetimeTracker<B> {
 
             for id in self.suspected_resources.texture_views.drain(..) {
                 if trackers.views.remove_abandoned(id) {
+                    #[cfg(feature = "trace")]
+                    trace.map(|t| t.lock().add(trace::Action::DestroyTextureView(id)));
                     hub.texture_views.free_id(id);
                     let res = guard.remove(id).unwrap();
 
@@ -360,6 +368,8 @@ impl<B: GfxBackend> LifetimeTracker<B> {
 
             for id in self.suspected_resources.textures.drain(..) {
                 if trackers.textures.remove_abandoned(id) {
+                    #[cfg(feature = "trace")]
+                    trace.map(|t| t.lock().add(trace::Action::DestroyTexture(id)));
                     hub.textures.free_id(id);
                     let res = guard.remove(id).unwrap();
 
@@ -380,6 +390,8 @@ impl<B: GfxBackend> LifetimeTracker<B> {
 
             for id in self.suspected_resources.samplers.drain(..) {
                 if trackers.samplers.remove_abandoned(id) {
+                    #[cfg(feature = "trace")]
+                    trace.map(|t| t.lock().add(trace::Action::DestroySampler(id)));
                     hub.samplers.free_id(id);
                     let res = guard.remove(id).unwrap();
 
@@ -400,6 +412,8 @@ impl<B: GfxBackend> LifetimeTracker<B> {
 
             for id in self.suspected_resources.buffers.drain(..) {
                 if trackers.buffers.remove_abandoned(id) {
+                    #[cfg(feature = "trace")]
+                    trace.map(|t| t.lock().add(trace::Action::DestroyBuffer(id)));
                     hub.buffers.free_id(id);
                     let res = guard.remove(id).unwrap();
                     log::debug!("Buffer {:?} is detached", id);
@@ -421,6 +435,8 @@ impl<B: GfxBackend> LifetimeTracker<B> {
 
             for id in self.suspected_resources.compute_pipelines.drain(..) {
                 if trackers.compute_pipes.remove_abandoned(id) {
+                    #[cfg(feature = "trace")]
+                    trace.map(|t| t.lock().add(trace::Action::DestroyComputePipeline(id)));
                     hub.compute_pipelines.free_id(id);
                     let res = guard.remove(id).unwrap();
 
@@ -441,6 +457,8 @@ impl<B: GfxBackend> LifetimeTracker<B> {
 
             for id in self.suspected_resources.render_pipelines.drain(..) {
                 if trackers.render_pipes.remove_abandoned(id) {
+                    #[cfg(feature = "trace")]
+                    trace.map(|t| t.lock().add(trace::Action::DestroyRenderPipeline(id)));
                     hub.render_pipelines.free_id(id);
                     let res = guard.remove(id).unwrap();
 
@@ -465,6 +483,8 @@ impl<B: GfxBackend> LifetimeTracker<B> {
             {
                 //Note: this has to happen after all the suspected pipelines are destroyed
                 if ref_count.load() == 1 {
+                    #[cfg(feature = "trace")]
+                    trace.map(|t| t.lock().add(trace::Action::DestroyPipelineLayout(id)));
                     hub.pipeline_layouts.free_id(id);
                     let layout = guard.remove(id).unwrap();
                     self.free_resources.pipeline_layouts.push(layout.raw);
diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs
index 5d2f4413ed..3ba1c914cc 100644
--- a/wgpu-core/src/device/mod.rs
+++ b/wgpu-core/src/device/mod.rs
@@ -281,7 +281,13 @@ impl<B: GfxBackend> Device<B> {
     ) -> Vec<BufferMapPendingCallback> {
         let mut life_tracker = self.lock_life(token);
 
-        life_tracker.triage_suspected(global, &self.trackers, token);
+        life_tracker.triage_suspected(
+            global,
+            &self.trackers,
+            #[cfg(feature = "trace")]
+            self.trace.as_ref(),
+            token,
+        );
         life_tracker.triage_mapped(global, token);
         life_tracker.triage_framebuffers(global, &mut *self.framebuffers.lock(), token);
         let _last_done = life_tracker.triage_submissions(&self.raw, force_wait);
@@ -575,6 +581,15 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
 
         let id = hub.buffers.register_identity(id_in, buffer, &mut token);
         log::info!("Created mapped buffer {:?} with {:?}", id, desc);
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace.lock().add(trace::Action::CreateBuffer {
+                id,
+                desc: desc.map_label(own_label),
+            }),
+            None => (),
+        };
+
         device
             .trackers
             .lock()
@@ -692,14 +707,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         };
 
         let (device_guard, mut token) = hub.devices.read(&mut token);
-        let device = &device_guard[device_id];
-        #[cfg(feature = "trace")]
-        match device.trace {
-            Some(ref trace) => trace.lock().add(trace::Action::DestroyBuffer(buffer_id)),
-            None => (),
-        };
-
-        device
+        device_guard[device_id]
             .lock_life(&mut token)
             .suspected_resources
             .buffers
@@ -752,14 +760,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         };
 
         let (device_guard, mut token) = hub.devices.read(&mut token);
-        let device = &device_guard[device_id];
-        #[cfg(feature = "trace")]
-        match device.trace {
-            Some(ref trace) => trace.lock().add(trace::Action::DestroyTexture(texture_id)),
-            None => (),
-        };
-
-        device
+        device_guard[device_id]
             .lock_life(&mut token)
             .suspected_resources
             .textures
@@ -882,16 +883,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         };
 
         let (device_guard, mut token) = hub.devices.read(&mut token);
-        let device = &device_guard[device_id];
-        #[cfg(feature = "trace")]
-        match device.trace {
-            Some(ref trace) => trace
-                .lock()
-                .add(trace::Action::DestroyTextureView(texture_view_id)),
-            None => (),
-        };
-
-        device
+        device_guard[device_id]
             .lock_life(&mut token)
             .suspected_resources
             .texture_views
@@ -967,14 +959,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         };
 
         let (device_guard, mut token) = hub.devices.read(&mut token);
-        let device = &device_guard[device_id];
-        #[cfg(feature = "trace")]
-        match device.trace {
-            Some(ref trace) => trace.lock().add(trace::Action::DestroySampler(sampler_id)),
-            None => (),
-        };
-
-        device
+        device_guard[device_id]
             .lock_life(&mut token)
             .suspected_resources
             .samplers
@@ -1153,16 +1138,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         };
 
         let (device_guard, mut token) = hub.devices.read(&mut token);
-        let device = &device_guard[device_id];
-        #[cfg(feature = "trace")]
-        match device.trace {
-            Some(ref trace) => trace
-                .lock()
-                .add(trace::Action::DestroyPipelineLayout(pipeline_layout_id)),
-            None => (),
-        };
-
-        device
+        device_guard[device_id]
             .lock_life(&mut token)
             .suspected_resources
             .pipeline_layouts
@@ -1437,16 +1413,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         };
 
         let (device_guard, mut token) = hub.devices.read(&mut token);
-        let device = &device_guard[device_id];
-        #[cfg(feature = "trace")]
-        match device.trace {
-            Some(ref trace) => trace
-                .lock()
-                .add(trace::Action::DestroyBindGroup(bind_group_id)),
-            None => (),
-        };
-
-        device
+        device_guard[device_id]
             .lock_life(&mut token)
             .suspected_resources
             .bind_groups
@@ -1505,7 +1472,6 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                 .add(trace::Action::DestroyShaderModule(shader_module_id)),
             None => (),
         };
-
         unsafe {
             device.raw.destroy_shader_module(module.raw);
         }
@@ -2065,8 +2031,38 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             life_guard: LifeGuard::new(),
         };
 
-        hub.render_pipelines
-            .register_identity(id_in, pipeline, &mut token)
+        let id = hub.render_pipelines
+            .register_identity(id_in, pipeline, &mut token);
+
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace.lock().add(trace::Action::CreateRenderPipeline {
+                id,
+                desc: trace::RenderPipelineDescriptor {
+                    layout: desc.layout, 
+                    vertex_stage: trace::ProgrammableStageDescriptor::new(&desc.vertex_stage),
+                    fragment_stage: unsafe { desc.fragment_stage.as_ref() }.map(trace::ProgrammableStageDescriptor::new),
+                    primitive_topology: desc.primitive_topology,
+                    rasterization_state: unsafe { desc.rasterization_state.as_ref() }.cloned(),
+                    color_states: color_states.to_vec(),
+                    depth_stencil_state: depth_stencil_state.cloned(),
+                    vertex_state: trace::VertexStateDescriptor {
+                        index_format: desc.vertex_state.index_format,
+                        vertex_buffers: desc_vbs.iter().map(|vbl| trace::VertexBufferLayoutDescriptor {
+                            array_stride: vbl.array_stride,
+                            step_mode: vbl.step_mode,
+                            attributes: unsafe { slice::from_raw_parts(vbl.attributes, vbl.attributes_length) }
+                                .iter().cloned().collect(),
+                        }).collect(),
+                    },
+                    sample_count: desc.sample_count,
+                    sample_mask: desc.sample_mask,
+                    alpha_to_coverage_enabled: desc.alpha_to_coverage_enabled,
+                },
+            }),
+            None => (),
+        };
+        id
     }
 
     pub fn render_pipeline_destroy<B: GfxBackend>(&self, render_pipeline_id: id::RenderPipelineId) {
@@ -2151,8 +2147,21 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             },
             life_guard: LifeGuard::new(),
         };
-        hub.compute_pipelines
-            .register_identity(id_in, pipeline, &mut token)
+        let id = hub.compute_pipelines
+            .register_identity(id_in, pipeline, &mut token);
+
+        #[cfg(feature = "trace")]
+        match device.trace {
+            Some(ref trace) => trace.lock().add(trace::Action::CreateComputePipeline {
+                id,
+                desc: trace::ComputePipelineDescriptor {
+                    layout: desc.layout, 
+                    compute_stage: trace::ProgrammableStageDescriptor::new(&desc.compute_stage),
+                },
+            }),
+            None => (),
+        };
+        id
     }
 
     pub fn compute_pipeline_destroy<B: GfxBackend>(
diff --git a/wgpu-core/src/device/trace.rs b/wgpu-core/src/device/trace.rs
index 6400769f2c..0b42ba62c7 100644
--- a/wgpu-core/src/device/trace.rs
+++ b/wgpu-core/src/device/trace.rs
@@ -29,6 +29,68 @@ pub enum BindingResource {
     TextureView(id::TextureViewId),
 }
 
+#[derive(Debug)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub struct ProgrammableStageDescriptor {
+    pub module: id::ShaderModuleId,
+    pub entry_point: String,
+}
+
+#[cfg(feature = "trace")]
+impl ProgrammableStageDescriptor {
+    pub fn new(desc: &crate::pipeline::ProgrammableStageDescriptor) -> Self {
+        ProgrammableStageDescriptor {
+            module: desc.module,
+            entry_point: unsafe { std::ffi::CStr::from_ptr(desc.entry_point) }
+                .to_string_lossy()
+                .to_string(),
+        }
+    }
+}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub struct ComputePipelineDescriptor {
+    pub layout: id::PipelineLayoutId,
+    pub compute_stage: ProgrammableStageDescriptor,
+}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub struct VertexBufferLayoutDescriptor {
+    pub array_stride: wgt::BufferAddress,
+    pub step_mode: wgt::InputStepMode,
+    pub attributes: Vec<wgt::VertexAttributeDescriptor>,
+}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub struct VertexStateDescriptor {
+    pub index_format: wgt::IndexFormat,
+    pub vertex_buffers: Vec<VertexBufferLayoutDescriptor>,
+}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub struct RenderPipelineDescriptor {
+    pub layout: id::PipelineLayoutId,
+    pub vertex_stage: ProgrammableStageDescriptor,
+    pub fragment_stage: Option<ProgrammableStageDescriptor>,
+    pub primitive_topology: wgt::PrimitiveTopology,
+    pub rasterization_state: Option<wgt::RasterizationStateDescriptor>,
+    pub color_states: Vec<wgt::ColorStateDescriptor>,
+    pub depth_stencil_state: Option<wgt::DepthStencilStateDescriptor>,
+    pub vertex_state: VertexStateDescriptor,
+    pub sample_count: u32,
+    pub sample_mask: u32,
+    pub alpha_to_coverage_enabled: bool,
+}
+
 #[derive(Debug)]
 #[cfg_attr(feature = "trace", derive(serde::Serialize))]
 #[cfg_attr(feature = "replay", derive(serde::Deserialize))]
@@ -89,6 +151,16 @@ pub enum Action {
         data: FileName,
     },
     DestroyShaderModule(id::ShaderModuleId),
+    CreateComputePipeline {
+        id: id::ComputePipelineId,
+        desc: ComputePipelineDescriptor,
+    },
+    DestroyComputePipeline(id::ComputePipelineId),
+    CreateRenderPipeline {
+        id: id::RenderPipelineId,
+        desc: RenderPipelineDescriptor,
+    },
+    DestroyRenderPipeline(id::RenderPipelineId),
     WriteBuffer {
         id: id::BufferId,
         data: FileName,
diff --git a/wgpu-core/src/id.rs b/wgpu-core/src/id.rs
index e5bb1f1846..966d1eb6db 100644
--- a/wgpu-core/src/id.rs
+++ b/wgpu-core/src/id.rs
@@ -151,7 +151,7 @@ impl SurfaceId {
     }
 }
 impl SwapChainId {
-    pub(crate) fn to_surface_id(self) -> SurfaceId {
+    pub fn to_surface_id(self) -> SurfaceId {
         let (index, epoch, _) = self.unzip();
         Id::zip(index, epoch, Backend::Empty)
     }

From e0a24f96cc1f0ad146470dfc6096dbd17679ad32 Mon Sep 17 00:00:00 2001
From: Dzmitry Malyshau <kvarkus@gmail.com>
Date: Wed, 29 Apr 2020 16:45:28 -0400
Subject: [PATCH 10/12] trace: fix reusing object ids

---
 .github/workflows/ci.yml      | 11 ++++-
 player/src/main.rs            | 62 +++++++++++++++++++++-------
 wgpu-core/src/device/life.rs  |  7 ++--
 wgpu-core/src/device/mod.rs   | 78 ++++++++++++++++++++++++++++++-----
 wgpu-core/src/device/trace.rs |  2 +-
 wgpu-core/src/hub.rs          |  2 +-
 wgpu-core/src/instance.rs     |  3 +-
 7 files changed, 130 insertions(+), 35 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6ac9a72e12..cf93ffe92d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -28,36 +28,43 @@ jobs:
             channel: stable
             build_command: rustup target add aarch64-apple-ios; cargo clippy --target aarch64-apple-ios
             additional_core_features:
+            additional_player_features:
           - os: macos-10.15
             name: MacOS Stable
             channel: stable
             build_command: cargo clippy
             additional_core_features: trace
+            additional_player_features: winit
           - os: macos-10.15
             name: MacOS Nightly
             channel: nightly
             build_command: cargo test
             additional_core_features:
+            additional_player_features:
           - os: ubuntu-18.04
             name: Ubuntu Stable
             channel: stable
             build_command: cargo clippy
             additional_core_features: trace,replay
+            additional_player_features:
           - os: ubuntu-18.04
             name: Ubuntu Nightly
             channel: nightly
             build_command: cargo test
             additional_core_features:
+            additional_player_features: winit
           - os: windows-2019
             name: Windows Stable
             channel: stable
             build_command: rustup default stable-msvc; cargo clippy
-            additional_core_features: replay
+            additional_core_features: trace
+            additional_player_features:
           - os: windows-2019
             name: Windows Nightly
             channel: nightly
             build_command: rustup default nightly-msvc; cargo test
             additional_core_features:
+            additional_player_features:
     steps:
     - uses: actions/checkout@v2
     - if: matrix.channel == 'nightly'
@@ -72,3 +79,5 @@ jobs:
       run: ${{ matrix.build_command }}
     - if: matrix.additional_core_features != ''
       run: cargo check --manifest-path wgpu-core/Cargo.toml --features ${{ matrix.additional_core_features }}
+    - if: matrix.additional_player_features != ''
+      run: cargo check --manifest-path player/Cargo.toml --features ${{ matrix.additional_player_features }}
diff --git a/player/src/main.rs b/player/src/main.rs
index 8fa7279070..592563e362 100644
--- a/player/src/main.rs
+++ b/player/src/main.rs
@@ -2,6 +2,14 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+/*! This is a player for WebGPU traces.
+ *
+ * # Notes
+ * - we call device_maintain_ids() before creating any refcounted resource,
+ *   which is basically everything except for BGL and shader modules,
+ *   so that we don't accidentally try to use the same ID.
+!*/
+
 use wgc::device::trace;
 
 use std::{
@@ -96,6 +104,13 @@ trait GlobalExt {
         encoder: wgc::id::CommandEncoderId,
         commands: Vec<trace::Command>,
     ) -> wgc::id::CommandBufferId;
+    /*fn process<B: wgc::hub::GfxBackend>(
+        &self,
+        device: wgc::id::DeviceId,
+        action: trace::Action,
+    ) {
+
+    }*/
 }
 
 impl GlobalExt for wgc::hub::Global<IdentityPassThroughFactory> {
@@ -186,6 +201,7 @@ fn main() {
     env_logger::init();
 
     //TODO: setting for the backend bits
+    //TODO: setting for the target frame, or controls
 
     let dir = match std::env::args().nth(1) {
         Some(arg) if Path::new(&arg).is_dir() => PathBuf::from(arg),
@@ -194,7 +210,8 @@ fn main() {
 
     log::info!("Loading trace '{:?}'", dir);
     let file = File::open(dir.join(trace::FILE_NAME)).unwrap();
-    let actions: Vec<trace::Action> = ron::de::from_reader(file).unwrap();
+    let mut actions: Vec<trace::Action> = ron::de::from_reader(file).unwrap();
+    actions.reverse(); // allows us to pop from the top
     log::info!("Found {} actions", actions.len());
 
     #[cfg(feature = "winit")]
@@ -239,27 +256,32 @@ fn main() {
         )
         .unwrap();
 
-    let mut device = wgc::id::DeviceId::default();
+    log::info!("Initializing the device");
+    let device = match actions.pop() {
+        Some(trace::Action::Init { limits }) => {
+            gfx_select!(adapter => global.adapter_request_device(
+                adapter,
+                &wgt::DeviceDescriptor {
+                    extensions: wgt::Extensions {
+                        anisotropic_filtering: false,
+                    },
+                    limits,
+                },
+                wgc::id::TypedId::zip(1, 0, wgt::Backend::Empty)
+            ))
+        }
+        _ => panic!("Expected Action::Init"),
+    };
+    let mut frame_count = 0;
 
     log::info!("Executing actions");
     for action in actions {
         use wgc::device::trace::Action as A;
         match action {
-            A::Init { limits } => {
-                log::info!("Initializing the device");
-                device = gfx_select!(adapter => global.adapter_request_device(
-                    adapter,
-                    &wgt::DeviceDescriptor {
-                        extensions: wgt::Extensions {
-                            anisotropic_filtering: false,
-                        },
-                        limits,
-                    },
-                    wgc::id::TypedId::zip(1, 0, wgt::Backend::Empty)
-                ));
-            }
+            A::Init { .. } => panic!("Unexpected Action::Init"),
             A::CreateBuffer { id, desc } => {
                 let label = Label::new(&desc.label);
+                gfx_select!(device => global.device_maintain_ids(device));
                 gfx_select!(device => global.device_create_buffer(device, &desc.map_label(|_| label.as_ptr()), id));
             }
             A::DestroyBuffer(id) => {
@@ -267,6 +289,7 @@ fn main() {
             }
             A::CreateTexture { id, desc } => {
                 let label = Label::new(&desc.label);
+                gfx_select!(device => global.device_maintain_ids(device));
                 gfx_select!(device => global.device_create_texture(device, &desc.map_label(|_| label.as_ptr()), id));
             }
             A::DestroyTexture(id) => {
@@ -278,6 +301,7 @@ fn main() {
                 desc,
             } => {
                 let label = desc.as_ref().map_or(Label(None), |d| Label::new(&d.label));
+                gfx_select!(device => global.device_maintain_ids(device));
                 gfx_select!(device => global.texture_create_view(parent_id, desc.map(|d| d.map_label(|_| label.as_ptr())).as_ref(), id));
             }
             A::DestroyTextureView(id) => {
@@ -285,6 +309,7 @@ fn main() {
             }
             A::CreateSampler { id, desc } => {
                 let label = Label::new(&desc.label);
+                gfx_select!(device => global.device_maintain_ids(device));
                 gfx_select!(device => global.device_create_sampler(device, &desc.map_label(|_| label.as_ptr()), id));
             }
             A::DestroySampler(id) => {
@@ -308,6 +333,8 @@ fn main() {
                 gfx_select!(device => global.swap_chain_get_next_texture(parent_id, id)).unwrap();
             }
             A::PresentSwapChain(id) => {
+                frame_count += 1;
+                log::debug!("Presenting frame {}", frame_count);
                 gfx_select!(device => global.swap_chain_present(id));
             }
             A::CreateBindGroupLayout { id, label, entries } => {
@@ -328,6 +355,7 @@ fn main() {
                 id,
                 bind_group_layouts,
             } => {
+                gfx_select!(device => global.device_maintain_ids(device));
                 gfx_select!(device => global.device_create_pipeline_layout(
                     device,
                     &wgc::binding_model::PipelineLayoutDescriptor {
@@ -366,6 +394,7 @@ fn main() {
                         },
                     })
                     .collect::<Vec<_>>();
+                gfx_select!(device => global.device_maintain_ids(device));
                 gfx_select!(device => global.device_create_bind_group(
                     device,
                     &wgc::binding_model::BindGroupDescriptor {
@@ -398,6 +427,7 @@ fn main() {
             }
             A::CreateComputePipeline { id, desc } => {
                 let cs_stage = OwnedProgrammableStage::from(desc.compute_stage);
+                gfx_select!(device => global.device_maintain_ids(device));
                 gfx_select!(device => global.device_create_compute_pipeline(
                     device,
                     &wgc::pipeline::ComputePipelineDescriptor {
@@ -423,6 +453,7 @@ fn main() {
                         attributes_length: vb.attributes.len(),
                     })
                     .collect::<Vec<_>>();
+                gfx_select!(device => global.device_maintain_ids(device));
                 gfx_select!(device => global.device_create_render_pipeline(
                     device,
                     &wgc::pipeline::RenderPipelineDescriptor {
@@ -451,6 +482,7 @@ fn main() {
             A::WriteBuffer { id, data, range } => {
                 let bin = std::fs::read(dir.join(data)).unwrap();
                 let size = (range.end - range.start) as usize;
+                gfx_select!(device => global.device_wait_for_buffer(device, id));
                 gfx_select!(device => global.device_set_buffer_sub_data(device, id, range.start, &bin[..size]));
             }
             A::Submit(commands) => {
diff --git a/wgpu-core/src/device/life.rs b/wgpu-core/src/device/life.rs
index 41546c3456..9a1c6c8eab 100644
--- a/wgpu-core/src/device/life.rs
+++ b/wgpu-core/src/device/life.rs
@@ -2,14 +2,14 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+#[cfg(feature = "trace")]
+use crate::device::trace;
 use crate::{
     hub::{GfxBackend, Global, GlobalIdentityHandlerFactory, Token},
     id, resource,
     track::TrackerSet,
     FastHashMap, RefCount, Stored, SubmissionIndex,
 };
-#[cfg(feature = "trace")]
-use crate::device::trace;
 
 use copyless::VecHelper as _;
 use gfx_descriptor::{DescriptorAllocator, DescriptorSet};
@@ -290,8 +290,7 @@ impl<B: GfxBackend> LifetimeTracker<B> {
         &mut self,
         global: &Global<G>,
         trackers: &Mutex<TrackerSet>,
-        #[cfg(feature = "trace")]
-        trace: Option<&Mutex<trace::Trace>>,
+        #[cfg(feature = "trace")] trace: Option<&Mutex<trace::Trace>>,
         token: &mut Token<super::Device<B>>,
     ) {
         let hub = B::hub(global);
diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs
index 3ba1c914cc..3441f9f374 100644
--- a/wgpu-core/src/device/mod.rs
+++ b/wgpu-core/src/device/mod.rs
@@ -604,6 +604,35 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         (id, pointer)
     }
 
+    #[cfg(feature = "replay")]
+    pub fn device_wait_for_buffer<B: GfxBackend>(
+        &self,
+        device_id: id::DeviceId,
+        buffer_id: id::BufferId,
+    ) {
+        let hub = B::hub(self);
+        let mut token = Token::root();
+        let (device_guard, mut token) = hub.devices.read(&mut token);
+        let last_submission = {
+            let (buffer_guard, _) = hub.buffers.write(&mut token);
+            buffer_guard[buffer_id]
+                .life_guard
+                .submission_index
+                .load(Ordering::Acquire)
+        };
+
+        let device = &device_guard[device_id];
+        let mut life_lock = device.lock_life(&mut token);
+        if life_lock.lowest_active_submission() <= last_submission {
+            log::info!(
+                "Waiting for submission {:?} before accessing buffer {:?}",
+                last_submission,
+                buffer_id
+            );
+            life_lock.triage_submissions(&device.raw, true);
+        }
+    }
+
     pub fn device_set_buffer_sub_data<B: GfxBackend>(
         &self,
         device_id: id::DeviceId,
@@ -2031,7 +2060,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             life_guard: LifeGuard::new(),
         };
 
-        let id = hub.render_pipelines
+        let id = hub
+            .render_pipelines
             .register_identity(id_in, pipeline, &mut token);
 
         #[cfg(feature = "trace")]
@@ -2039,21 +2069,29 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             Some(ref trace) => trace.lock().add(trace::Action::CreateRenderPipeline {
                 id,
                 desc: trace::RenderPipelineDescriptor {
-                    layout: desc.layout, 
+                    layout: desc.layout,
                     vertex_stage: trace::ProgrammableStageDescriptor::new(&desc.vertex_stage),
-                    fragment_stage: unsafe { desc.fragment_stage.as_ref() }.map(trace::ProgrammableStageDescriptor::new),
+                    fragment_stage: unsafe { desc.fragment_stage.as_ref() }
+                        .map(trace::ProgrammableStageDescriptor::new),
                     primitive_topology: desc.primitive_topology,
                     rasterization_state: unsafe { desc.rasterization_state.as_ref() }.cloned(),
                     color_states: color_states.to_vec(),
                     depth_stencil_state: depth_stencil_state.cloned(),
                     vertex_state: trace::VertexStateDescriptor {
                         index_format: desc.vertex_state.index_format,
-                        vertex_buffers: desc_vbs.iter().map(|vbl| trace::VertexBufferLayoutDescriptor {
-                            array_stride: vbl.array_stride,
-                            step_mode: vbl.step_mode,
-                            attributes: unsafe { slice::from_raw_parts(vbl.attributes, vbl.attributes_length) }
-                                .iter().cloned().collect(),
-                        }).collect(),
+                        vertex_buffers: desc_vbs
+                            .iter()
+                            .map(|vbl| trace::VertexBufferLayoutDescriptor {
+                                array_stride: vbl.array_stride,
+                                step_mode: vbl.step_mode,
+                                attributes: unsafe {
+                                    slice::from_raw_parts(vbl.attributes, vbl.attributes_length)
+                                }
+                                .iter()
+                                .cloned()
+                                .collect(),
+                            })
+                            .collect(),
                     },
                     sample_count: desc.sample_count,
                     sample_mask: desc.sample_mask,
@@ -2147,7 +2185,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             },
             life_guard: LifeGuard::new(),
         };
-        let id = hub.compute_pipelines
+        let id = hub
+            .compute_pipelines
             .register_identity(id_in, pipeline, &mut token);
 
         #[cfg(feature = "trace")]
@@ -2155,7 +2194,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             Some(ref trace) => trace.lock().add(trace::Action::CreateComputePipeline {
                 id,
                 desc: trace::ComputePipelineDescriptor {
-                    layout: desc.layout, 
+                    layout: desc.layout,
                     compute_stage: trace::ProgrammableStageDescriptor::new(&desc.compute_stage),
                 },
             }),
@@ -2295,6 +2334,23 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         sc_id
     }
 
+    #[cfg(feature = "replay")]
+    /// Only triange suspected resource IDs. This helps us to avoid ID collisions
+    /// upon creating new resources when re-plaing a trace.
+    pub fn device_maintain_ids<B: GfxBackend>(&self, device_id: id::DeviceId) {
+        let hub = B::hub(self);
+        let mut token = Token::root();
+        let (device_guard, mut token) = hub.devices.read(&mut token);
+        let device = &device_guard[device_id];
+        device.lock_life(&mut token).triage_suspected(
+            self,
+            &device.trackers,
+            #[cfg(feature = "trace")]
+            None,
+            &mut token,
+        );
+    }
+
     pub fn device_poll<B: GfxBackend>(&self, device_id: id::DeviceId, force_wait: bool) {
         let hub = B::hub(self);
         let mut token = Token::root();
diff --git a/wgpu-core/src/device/trace.rs b/wgpu-core/src/device/trace.rs
index 0b42ba62c7..7c09c43ad3 100644
--- a/wgpu-core/src/device/trace.rs
+++ b/wgpu-core/src/device/trace.rs
@@ -6,9 +6,9 @@ use crate::{
     command::{BufferCopyView, TextureCopyView},
     id,
 };
-use std::ops::Range;
 #[cfg(feature = "trace")]
 use std::io::Write as _;
+use std::ops::Range;
 
 //TODO: consider a readable Id that doesn't include the backend
 
diff --git a/wgpu-core/src/hub.rs b/wgpu-core/src/hub.rs
index 5b806558f4..30d528c879 100644
--- a/wgpu-core/src/hub.rs
+++ b/wgpu-core/src/hub.rs
@@ -46,7 +46,7 @@ impl Default for IdentityManager {
 impl IdentityManager {
     pub fn from_index(min_index: u32) -> Self {
         IdentityManager {
-            free: (0 .. min_index).collect(),
+            free: (0..min_index).collect(),
             epochs: vec![1; min_index as usize],
         }
     }
diff --git a/wgpu-core/src/instance.rs b/wgpu-core/src/instance.rs
index 34137d02e3..c25258f6f7 100644
--- a/wgpu-core/src/instance.rs
+++ b/wgpu-core/src/instance.rs
@@ -282,8 +282,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         };
 
         let mut token = Token::root();
-        self.surfaces
-            .register_identity(id_in, surface, &mut token)
+        self.surfaces.register_identity(id_in, surface, &mut token)
     }
 
     pub fn enumerate_adapters(&self, inputs: AdapterInputs<Input<G, AdapterId>>) -> Vec<AdapterId> {

From 3dace1d5644587aabb5e0c2a24d4983d62e33757 Mon Sep 17 00:00:00 2001
From: Dzmitry Malyshau <kvarkus@gmail.com>
Date: Wed, 29 Apr 2020 17:26:40 -0400
Subject: [PATCH 11/12] player: full winit integration

---
 player/src/main.rs            | 406 +++++++++++++++++++---------------
 wgpu-core/src/device/mod.rs   |   2 +-
 wgpu-core/src/device/trace.rs |   2 +-
 3 files changed, 226 insertions(+), 184 deletions(-)

diff --git a/player/src/main.rs b/player/src/main.rs
index 592563e362..97a46dff1e 100644
--- a/player/src/main.rs
+++ b/player/src/main.rs
@@ -104,13 +104,13 @@ trait GlobalExt {
         encoder: wgc::id::CommandEncoderId,
         commands: Vec<trace::Command>,
     ) -> wgc::id::CommandBufferId;
-    /*fn process<B: wgc::hub::GfxBackend>(
+    fn process<B: wgc::hub::GfxBackend>(
         &self,
         device: wgc::id::DeviceId,
         action: trace::Action,
-    ) {
-
-    }*/
+        dir: &PathBuf,
+        comb_manager: &mut wgc::hub::IdentityManager,
+    );
 }
 
 impl GlobalExt for wgc::hub::Global<IdentityPassThroughFactory> {
@@ -192,108 +192,35 @@ impl GlobalExt for wgc::hub::Global<IdentityPassThroughFactory> {
         }
         self.command_encoder_finish::<B>(encoder, &wgt::CommandBufferDescriptor { todo: 0 })
     }
-}
-
-fn main() {
-    #[cfg(feature = "winit")]
-    use winit::{event_loop::EventLoop, window::WindowBuilder};
-
-    env_logger::init();
-
-    //TODO: setting for the backend bits
-    //TODO: setting for the target frame, or controls
-
-    let dir = match std::env::args().nth(1) {
-        Some(arg) if Path::new(&arg).is_dir() => PathBuf::from(arg),
-        _ => panic!("Provide the dir path as the parameter"),
-    };
-
-    log::info!("Loading trace '{:?}'", dir);
-    let file = File::open(dir.join(trace::FILE_NAME)).unwrap();
-    let mut actions: Vec<trace::Action> = ron::de::from_reader(file).unwrap();
-    actions.reverse(); // allows us to pop from the top
-    log::info!("Found {} actions", actions.len());
-
-    #[cfg(feature = "winit")]
-    let mut event_loop = {
-        log::info!("Creating a window");
-        EventLoop::new()
-    };
-    #[cfg(feature = "winit")]
-    let window = WindowBuilder::new()
-        .with_title("wgpu player")
-        .with_resizable(false)
-        .build(&event_loop)
-        .unwrap();
-
-    let global = wgc::hub::Global::new("player", IdentityPassThroughFactory);
-    let mut adapter_id_manager = wgc::hub::IdentityManager::default();
-    let mut command_buffer_id_manager = wgc::hub::IdentityManager::default();
-
-    #[cfg(feature = "winit")]
-    let surface = global.instance_create_surface(
-        raw_window_handle::HasRawWindowHandle::raw_window_handle(&window),
-        wgc::id::TypedId::zip(0, 1, wgt::Backend::Empty),
-    );
-
-    let adapter = global
-        .pick_adapter(
-            &wgc::instance::RequestAdapterOptions {
-                power_preference: wgt::PowerPreference::Default,
-                #[cfg(feature = "winit")]
-                compatible_surface: Some(surface),
-                #[cfg(not(feature = "winit"))]
-                compatible_surface: None,
-            },
-            wgc::instance::AdapterInputs::IdSet(
-                &vec![
-                    adapter_id_manager.alloc(wgt::Backend::Vulkan),
-                    adapter_id_manager.alloc(wgt::Backend::Dx12),
-                    adapter_id_manager.alloc(wgt::Backend::Metal),
-                ],
-                |id| id.backend(),
-            ),
-        )
-        .unwrap();
 
-    log::info!("Initializing the device");
-    let device = match actions.pop() {
-        Some(trace::Action::Init { limits }) => {
-            gfx_select!(adapter => global.adapter_request_device(
-                adapter,
-                &wgt::DeviceDescriptor {
-                    extensions: wgt::Extensions {
-                        anisotropic_filtering: false,
-                    },
-                    limits,
-                },
-                wgc::id::TypedId::zip(1, 0, wgt::Backend::Empty)
-            ))
-        }
-        _ => panic!("Expected Action::Init"),
-    };
-    let mut frame_count = 0;
-
-    log::info!("Executing actions");
-    for action in actions {
+    fn process<B: wgc::hub::GfxBackend>(
+        &self,
+        device: wgc::id::DeviceId,
+        action: trace::Action,
+        dir: &PathBuf,
+        comb_manager: &mut wgc::hub::IdentityManager,
+    ) {
         use wgc::device::trace::Action as A;
         match action {
-            A::Init { .. } => panic!("Unexpected Action::Init"),
+            A::Init { .. } => panic!("Unexpected Action::Init: has to be the first action only"),
+            A::CreateSwapChain { .. } | A::PresentSwapChain(_) => {
+                panic!("Unexpected SwapChain action: winit feature is not enabled")
+            }
             A::CreateBuffer { id, desc } => {
                 let label = Label::new(&desc.label);
-                gfx_select!(device => global.device_maintain_ids(device));
-                gfx_select!(device => global.device_create_buffer(device, &desc.map_label(|_| label.as_ptr()), id));
+                self.device_maintain_ids::<B>(device);
+                self.device_create_buffer::<B>(device, &desc.map_label(|_| label.as_ptr()), id);
             }
             A::DestroyBuffer(id) => {
-                gfx_select!(device => global.buffer_destroy(id));
+                self.buffer_destroy::<B>(id);
             }
             A::CreateTexture { id, desc } => {
                 let label = Label::new(&desc.label);
-                gfx_select!(device => global.device_maintain_ids(device));
-                gfx_select!(device => global.device_create_texture(device, &desc.map_label(|_| label.as_ptr()), id));
+                self.device_maintain_ids::<B>(device);
+                self.device_create_texture::<B>(device, &desc.map_label(|_| label.as_ptr()), id);
             }
             A::DestroyTexture(id) => {
-                gfx_select!(device => global.texture_destroy(id));
+                self.texture_destroy::<B>(id);
             }
             A::CreateTextureView {
                 id,
@@ -301,71 +228,59 @@ fn main() {
                 desc,
             } => {
                 let label = desc.as_ref().map_or(Label(None), |d| Label::new(&d.label));
-                gfx_select!(device => global.device_maintain_ids(device));
-                gfx_select!(device => global.texture_create_view(parent_id, desc.map(|d| d.map_label(|_| label.as_ptr())).as_ref(), id));
+                self.device_maintain_ids::<B>(device);
+                self.texture_create_view::<B>(
+                    parent_id,
+                    desc.map(|d| d.map_label(|_| label.as_ptr())).as_ref(),
+                    id,
+                );
             }
             A::DestroyTextureView(id) => {
-                gfx_select!(device => global.texture_view_destroy(id));
+                self.texture_view_destroy::<B>(id);
             }
             A::CreateSampler { id, desc } => {
                 let label = Label::new(&desc.label);
-                gfx_select!(device => global.device_maintain_ids(device));
-                gfx_select!(device => global.device_create_sampler(device, &desc.map_label(|_| label.as_ptr()), id));
+                self.device_maintain_ids::<B>(device);
+                self.device_create_sampler::<B>(device, &desc.map_label(|_| label.as_ptr()), id);
             }
             A::DestroySampler(id) => {
-                gfx_select!(device => global.sampler_destroy(id));
-            }
-            A::CreateSwapChain { id, desc } => {
-                #[cfg(feature = "winit")]
-                {
-                    log::info!("Initializing the swapchain");
-                    assert_eq!(id.to_surface_id(), surface);
-                    window.set_inner_size(winit::dpi::PhysicalSize::new(desc.width, desc.height));
-                    gfx_select!(device => global.device_create_swap_chain(device, surface, &desc));
-                }
-                #[cfg(not(feature = "winit"))]
-                {
-                    let _ = (id, desc);
-                    panic!("Enable `winit` feature to work with swapchains");
-                }
+                self.sampler_destroy::<B>(id);
             }
             A::GetSwapChainTexture { id, parent_id } => {
-                gfx_select!(device => global.swap_chain_get_next_texture(parent_id, id)).unwrap();
-            }
-            A::PresentSwapChain(id) => {
-                frame_count += 1;
-                log::debug!("Presenting frame {}", frame_count);
-                gfx_select!(device => global.swap_chain_present(id));
+                self.swap_chain_get_next_texture::<B>(parent_id, id)
+                    .unwrap();
             }
             A::CreateBindGroupLayout { id, label, entries } => {
                 let label = Label::new(&label);
-                gfx_select!(device => global.device_create_bind_group_layout(
+                self.device_create_bind_group_layout::<B>(
                     device,
                     &wgc::binding_model::BindGroupLayoutDescriptor {
                         label: label.as_ptr(),
                         entries: entries.as_ptr(),
                         entries_length: entries.len(),
                     },
-                    id));
+                    id,
+                );
             }
             A::DestroyBindGroupLayout(id) => {
-                gfx_select!(device => global.bind_group_layout_destroy(id));
+                self.bind_group_layout_destroy::<B>(id);
             }
             A::CreatePipelineLayout {
                 id,
                 bind_group_layouts,
             } => {
-                gfx_select!(device => global.device_maintain_ids(device));
-                gfx_select!(device => global.device_create_pipeline_layout(
+                self.device_maintain_ids::<B>(device);
+                self.device_create_pipeline_layout::<B>(
                     device,
                     &wgc::binding_model::PipelineLayoutDescriptor {
                         bind_group_layouts: bind_group_layouts.as_ptr(),
                         bind_group_layouts_length: bind_group_layouts.len(),
                     },
-                    id));
+                    id,
+                );
             }
             A::DestroyPipelineLayout(id) => {
-                gfx_select!(device => global.pipeline_layout_destroy(id));
+                self.pipeline_layout_destroy::<B>(id);
             }
             A::CreateBindGroup {
                 id,
@@ -394,8 +309,8 @@ fn main() {
                         },
                     })
                     .collect::<Vec<_>>();
-                gfx_select!(device => global.device_maintain_ids(device));
-                gfx_select!(device => global.device_create_bind_group(
+                self.device_maintain_ids::<B>(device);
+                self.device_create_bind_group::<B>(
                     device,
                     &wgc::binding_model::BindGroupDescriptor {
                         label: label.as_ptr(),
@@ -403,15 +318,15 @@ fn main() {
                         entries: entry_vec.as_ptr(),
                         entries_length: entry_vec.len(),
                     },
-                    id
-                ));
+                    id,
+                );
             }
             A::DestroyBindGroup(id) => {
-                gfx_select!(device => global.bind_group_destroy(id));
+                self.bind_group_destroy::<B>(id);
             }
             A::CreateShaderModule { id, data } => {
                 let spv = wgt::read_spirv(File::open(dir.join(data)).unwrap()).unwrap();
-                gfx_select!(device => global.device_create_shader_module(
+                self.device_create_shader_module::<B>(
                     device,
                     &wgc::pipeline::ShaderModuleDescriptor {
                         code: wgc::U32Array {
@@ -419,25 +334,26 @@ fn main() {
                             length: spv.len(),
                         },
                     },
-                    id
-                ));
+                    id,
+                );
             }
             A::DestroyShaderModule(id) => {
-                gfx_select!(device => global.shader_module_destroy(id));
+                self.shader_module_destroy::<B>(id);
             }
             A::CreateComputePipeline { id, desc } => {
                 let cs_stage = OwnedProgrammableStage::from(desc.compute_stage);
-                gfx_select!(device => global.device_maintain_ids(device));
-                gfx_select!(device => global.device_create_compute_pipeline(
+                self.device_maintain_ids::<B>(device);
+                self.device_create_compute_pipeline::<B>(
                     device,
                     &wgc::pipeline::ComputePipelineDescriptor {
                         layout: desc.layout,
                         compute_stage: cs_stage.desc,
                     },
-                    id));
+                    id,
+                );
             }
             A::DestroyComputePipeline(id) => {
-                gfx_select!(device => global.compute_pipeline_destroy(id));
+                self.compute_pipeline_destroy::<B>(id);
             }
             A::CreateRenderPipeline { id, desc } => {
                 let vs_stage = OwnedProgrammableStage::from(desc.vertex_stage);
@@ -453,18 +369,24 @@ fn main() {
                         attributes_length: vb.attributes.len(),
                     })
                     .collect::<Vec<_>>();
-                gfx_select!(device => global.device_maintain_ids(device));
-                gfx_select!(device => global.device_create_render_pipeline(
+                self.device_maintain_ids::<B>(device);
+                self.device_create_render_pipeline::<B>(
                     device,
                     &wgc::pipeline::RenderPipelineDescriptor {
                         layout: desc.layout,
                         vertex_stage: vs_stage.desc,
                         fragment_stage: fs_stage.as_ref().map_or(ptr::null(), |s| &s.desc),
                         primitive_topology: desc.primitive_topology,
-                        rasterization_state: desc.rasterization_state.as_ref().map_or(ptr::null(), |rs| rs),
+                        rasterization_state: desc
+                            .rasterization_state
+                            .as_ref()
+                            .map_or(ptr::null(), |rs| rs),
                         color_states: desc.color_states.as_ptr(),
                         color_states_length: desc.color_states.len(),
-                        depth_stencil_state: desc.depth_stencil_state.as_ref().map_or(ptr::null(), |ds| ds),
+                        depth_stencil_state: desc
+                            .depth_stencil_state
+                            .as_ref()
+                            .map_or(ptr::null(), |ds| ds),
                         vertex_state: wgc::pipeline::VertexStateDescriptor {
                             index_format: desc.vertex_state.index_format,
                             vertex_buffers: vertex_buffers.as_ptr(),
@@ -474,57 +396,177 @@ fn main() {
                         sample_mask: desc.sample_mask,
                         alpha_to_coverage_enabled: desc.alpha_to_coverage_enabled,
                     },
-                    id));
+                    id,
+                );
             }
             A::DestroyRenderPipeline(id) => {
-                gfx_select!(device => global.render_pipeline_destroy(id));
+                self.render_pipeline_destroy::<B>(id);
             }
             A::WriteBuffer { id, data, range } => {
                 let bin = std::fs::read(dir.join(data)).unwrap();
                 let size = (range.end - range.start) as usize;
-                gfx_select!(device => global.device_wait_for_buffer(device, id));
-                gfx_select!(device => global.device_set_buffer_sub_data(device, id, range.start, &bin[..size]));
+                self.device_wait_for_buffer::<B>(device, id);
+                self.device_set_buffer_sub_data::<B>(device, id, range.start, &bin[..size]);
             }
-            A::Submit(commands) => {
-                let encoder = gfx_select!(device => global.device_create_command_encoder(
+            A::Submit(_index, commands) => {
+                let encoder = self.device_create_command_encoder::<B>(
                     device,
-                    &wgt::CommandEncoderDescriptor {
-                        label: ptr::null(),
-                    },
-                    command_buffer_id_manager.alloc(device.backend())
-                ));
-                let comb = gfx_select!(device => global.encode_commands(encoder, commands));
-                gfx_select!(device => global.queue_submit(device, &[comb]));
+                    &wgt::CommandEncoderDescriptor { label: ptr::null() },
+                    comb_manager.alloc(device.backend()),
+                );
+                let comb = self.encode_commands::<B>(encoder, commands);
+                self.queue_submit::<B>(device, &[comb]);
             }
         }
     }
+}
 
-    log::info!("Done replay");
+fn main() {
     #[cfg(feature = "winit")]
-    winit::platform::desktop::EventLoopExtDesktop::run_return(
-        &mut event_loop,
-        move |event, _, control_flow| {
-            use winit::{
-                event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
-                event_loop::ControlFlow,
-            };
+    use winit::{event_loop::EventLoop, window::WindowBuilder};
 
-            *control_flow = match event {
-                Event::WindowEvent { event, .. } => match event {
-                    WindowEvent::KeyboardInput {
-                        input:
-                            KeyboardInput {
-                                virtual_keycode: Some(VirtualKeyCode::Escape),
-                                state: ElementState::Pressed,
-                                ..
-                            },
-                        ..
-                    }
-                    | WindowEvent::CloseRequested => ControlFlow::Exit,
-                    _ => ControlFlow::Poll,
-                },
-                _ => ControlFlow::Poll,
-            }
-        },
+    env_logger::init();
+
+    //TODO: setting for the backend bits
+    //TODO: setting for the target frame, or controls
+
+    let dir = match std::env::args().nth(1) {
+        Some(arg) if Path::new(&arg).is_dir() => PathBuf::from(arg),
+        _ => panic!("Provide the dir path as the parameter"),
+    };
+
+    log::info!("Loading trace '{:?}'", dir);
+    let file = File::open(dir.join(trace::FILE_NAME)).unwrap();
+    let mut actions: Vec<trace::Action> = ron::de::from_reader(file).unwrap();
+    actions.reverse(); // allows us to pop from the top
+    log::info!("Found {} actions", actions.len());
+
+    #[cfg(feature = "winit")]
+    let mut event_loop = {
+        log::info!("Creating a window");
+        EventLoop::new()
+    };
+    #[cfg(feature = "winit")]
+    let window = WindowBuilder::new()
+        .with_title("wgpu player")
+        .with_resizable(false)
+        .build(&event_loop)
+        .unwrap();
+
+    let global = wgc::hub::Global::new("player", IdentityPassThroughFactory);
+    let mut adapter_id_manager = wgc::hub::IdentityManager::default();
+    let mut command_buffer_id_manager = wgc::hub::IdentityManager::default();
+
+    #[cfg(feature = "winit")]
+    let surface = global.instance_create_surface(
+        raw_window_handle::HasRawWindowHandle::raw_window_handle(&window),
+        wgc::id::TypedId::zip(0, 1, wgt::Backend::Empty),
     );
+
+    let adapter = global
+        .pick_adapter(
+            &wgc::instance::RequestAdapterOptions {
+                power_preference: wgt::PowerPreference::Default,
+                #[cfg(feature = "winit")]
+                compatible_surface: Some(surface),
+                #[cfg(not(feature = "winit"))]
+                compatible_surface: None,
+            },
+            wgc::instance::AdapterInputs::IdSet(
+                &vec![
+                    adapter_id_manager.alloc(wgt::Backend::Vulkan),
+                    adapter_id_manager.alloc(wgt::Backend::Dx12),
+                    adapter_id_manager.alloc(wgt::Backend::Metal),
+                ],
+                |id| id.backend(),
+            ),
+        )
+        .unwrap();
+
+    log::info!("Initializing the device");
+    let device = match actions.pop() {
+        Some(trace::Action::Init { limits }) => {
+            gfx_select!(adapter => global.adapter_request_device(
+                adapter,
+                &wgt::DeviceDescriptor {
+                    extensions: wgt::Extensions {
+                        anisotropic_filtering: false,
+                    },
+                    limits,
+                },
+                wgc::id::TypedId::zip(1, 0, wgt::Backend::Empty)
+            ))
+        }
+        _ => panic!("Expected Action::Init"),
+    };
+
+    log::info!("Executing actions");
+    #[cfg(feature = "winit")]
+    {
+        let mut frame_count = 0;
+        winit::platform::desktop::EventLoopExtDesktop::run_return(
+            &mut event_loop,
+            move |event, _, control_flow| {
+                use winit::{
+                    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+                    event_loop::ControlFlow,
+                };
+
+                *control_flow = ControlFlow::Poll;
+                match event {
+                    Event::MainEventsCleared => {
+                        window.request_redraw();
+                    }
+                    Event::RedrawRequested(_) => loop {
+                        match actions.pop() {
+                            Some(trace::Action::CreateSwapChain { id, desc }) => {
+                                log::info!("Initializing the swapchain");
+                                assert_eq!(id.to_surface_id(), surface);
+                                window.set_inner_size(winit::dpi::PhysicalSize::new(
+                                    desc.width,
+                                    desc.height,
+                                ));
+                                gfx_select!(device => global.device_create_swap_chain(device, surface, &desc));
+                            }
+                            Some(trace::Action::PresentSwapChain(id)) => {
+                                frame_count += 1;
+                                log::debug!("Presenting frame {}", frame_count);
+                                gfx_select!(device => global.swap_chain_present(id));
+                                break;
+                            }
+                            Some(action) => {
+                                gfx_select!(device => global.process(device, action, &dir, &mut command_buffer_id_manager));
+                            }
+                            None => break,
+                        }
+                    },
+                    Event::WindowEvent { event, .. } => match event {
+                        WindowEvent::KeyboardInput {
+                            input:
+                                KeyboardInput {
+                                    virtual_keycode: Some(VirtualKeyCode::Escape),
+                                    state: ElementState::Pressed,
+                                    ..
+                                },
+                            ..
+                        }
+                        | WindowEvent::CloseRequested => {
+                            *control_flow = ControlFlow::Exit;
+                        }
+                        _ => {}
+                    },
+                    Event::LoopDestroyed => {
+                        log::info!("Closing");
+                        gfx_select!(device => global.device_poll(device, true));
+                    }
+                    _ => {}
+                }
+            },
+        );
+    }
+
+    #[cfg(not(feature = "winit"))]
+    while let Some(action) = actions.pop() {
+        gfx_select!(device => global.process(device, action, &dir, &mut command_buffer_id_manager));
+    }
 }
diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs
index 3441f9f374..f47b7a3af0 100644
--- a/wgpu-core/src/device/mod.rs
+++ b/wgpu-core/src/device/mod.rs
@@ -1663,7 +1663,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                 match device.trace {
                     Some(ref trace) => trace
                         .lock()
-                        .add(Action::Submit(comb.commands.take().unwrap())),
+                        .add(Action::Submit(submit_index, comb.commands.take().unwrap())),
                     None => (),
                 };
 
diff --git a/wgpu-core/src/device/trace.rs b/wgpu-core/src/device/trace.rs
index 7c09c43ad3..4301a5eeb0 100644
--- a/wgpu-core/src/device/trace.rs
+++ b/wgpu-core/src/device/trace.rs
@@ -166,7 +166,7 @@ pub enum Action {
         data: FileName,
         range: Range<wgt::BufferAddress>,
     },
-    Submit(Vec<Command>),
+    Submit(crate::SubmissionIndex, Vec<Command>),
 }
 
 #[derive(Debug)]

From d6cfe4b80f707adb304494f50c0d83bfdfb8bb06 Mon Sep 17 00:00:00 2001
From: Dzmitry Malyshau <kvarkus@gmail.com>
Date: Wed, 29 Apr 2020 20:17:28 -0400
Subject: [PATCH 12/12] trace: make Id serialization nicer

---
 README.md                        |   1 +
 player/README.md                 |  12 +++
 player/src/main.rs               | 161 ++++++++++++++-----------------
 wgpu-core/src/command/compute.rs |   2 +-
 wgpu-core/src/command/render.rs  |   2 +-
 wgpu-core/src/device/mod.rs      |  18 +++-
 wgpu-core/src/device/trace.rs    |   3 +-
 wgpu-core/src/id.rs              |  30 +++++-
 wgpu-core/src/instance.rs        |   5 +-
 wgpu-types/src/lib.rs            |   2 +-
 10 files changed, 136 insertions(+), 100 deletions(-)
 create mode 100644 player/README.md

diff --git a/README.md b/README.md
index c59a93a37c..a16a36f769 100644
--- a/README.md
+++ b/README.md
@@ -17,6 +17,7 @@ The implementation consists of the following parts:
 
   - `wgpu-core` - internal Rust API for WebGPU implementations to use
   - `wgpu-types` - Rust types shared between `wgpu-core`, `wgpu-native`, and `wgpu-rs`
+  - `player` - application for replaying the API traces, uses `winit`
 
 This repository is not meant for direct use by applications.
 If you are looking for the user-facing Rust API, you need [wgpu-rs](https://github.com/gfx-rs/wgpu-rs).
diff --git a/player/README.md b/player/README.md
new file mode 100644
index 0000000000..bd73b8b71f
--- /dev/null
+++ b/player/README.md
@@ -0,0 +1,12 @@
+# wgpu player
+
+This is application that allows replaying the `wgpu` workloads recorded elsewhere.
+
+Launch as:
+```rust
+player <trace-dir>
+```
+
+When built with "winit" feature, it's able to replay the workloads that operate on a swapchain. It renders each frame consequently, then waits for the user to close the window. When built without "winit", it launches in console mode and can replay any trace that doesn't use swapchains.
+
+Note: replaying is currently restricted to the same backend, as one used for recording a trace. It is straightforward, however, to just replace the backend in RON, since it's serialized as plain text. Valid values are: Vulkan, Metal, Dx12, and Dx11.
diff --git a/player/src/main.rs b/player/src/main.rs
index 97a46dff1e..96289d09e3 100644
--- a/player/src/main.rs
+++ b/player/src/main.rs
@@ -454,7 +454,6 @@ fn main() {
         .unwrap();
 
     let global = wgc::hub::Global::new("player", IdentityPassThroughFactory);
-    let mut adapter_id_manager = wgc::hub::IdentityManager::default();
     let mut command_buffer_id_manager = wgc::hub::IdentityManager::default();
 
     #[cfg(feature = "winit")]
@@ -463,37 +462,28 @@ fn main() {
         wgc::id::TypedId::zip(0, 1, wgt::Backend::Empty),
     );
 
-    let adapter = global
-        .pick_adapter(
-            &wgc::instance::RequestAdapterOptions {
-                power_preference: wgt::PowerPreference::Default,
-                #[cfg(feature = "winit")]
-                compatible_surface: Some(surface),
-                #[cfg(not(feature = "winit"))]
-                compatible_surface: None,
-            },
-            wgc::instance::AdapterInputs::IdSet(
-                &vec![
-                    adapter_id_manager.alloc(wgt::Backend::Vulkan),
-                    adapter_id_manager.alloc(wgt::Backend::Dx12),
-                    adapter_id_manager.alloc(wgt::Backend::Metal),
-                ],
-                |id| id.backend(),
-            ),
-        )
-        .unwrap();
-
-    log::info!("Initializing the device");
     let device = match actions.pop() {
-        Some(trace::Action::Init { limits }) => {
+        Some(trace::Action::Init { desc, backend }) => {
+            log::info!("Initializing the device for backend: {:?}", backend);
+            let adapter = global
+                .pick_adapter(
+                    &wgc::instance::RequestAdapterOptions {
+                        power_preference: wgt::PowerPreference::Default,
+                        #[cfg(feature = "winit")]
+                        compatible_surface: Some(surface),
+                        #[cfg(not(feature = "winit"))]
+                        compatible_surface: None,
+                    },
+                    wgc::instance::AdapterInputs::IdSet(
+                        &[wgc::id::TypedId::zip(0, 0, backend)],
+                        |id| id.backend(),
+                    ),
+                )
+                .expect("Unable to find an adapter for selected backend");
             gfx_select!(adapter => global.adapter_request_device(
                 adapter,
-                &wgt::DeviceDescriptor {
-                    extensions: wgt::Extensions {
-                        anisotropic_filtering: false,
-                    },
-                    limits,
-                },
+                &desc,
+                None,
                 wgc::id::TypedId::zip(1, 0, wgt::Backend::Empty)
             ))
         }
@@ -501,72 +491,69 @@ fn main() {
     };
 
     log::info!("Executing actions");
+    #[cfg(not(feature = "winit"))]
+    while let Some(action) = actions.pop() {
+        gfx_select!(device => global.process(device, action, &dir, &mut command_buffer_id_manager));
+    }
     #[cfg(feature = "winit")]
     {
-        let mut frame_count = 0;
-        winit::platform::desktop::EventLoopExtDesktop::run_return(
-            &mut event_loop,
-            move |event, _, control_flow| {
-                use winit::{
-                    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
-                    event_loop::ControlFlow,
-                };
+        use winit::{
+            event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+            event_loop::ControlFlow,
+            platform::desktop::EventLoopExtDesktop,
+        };
 
-                *control_flow = ControlFlow::Poll;
-                match event {
-                    Event::MainEventsCleared => {
-                        window.request_redraw();
-                    }
-                    Event::RedrawRequested(_) => loop {
-                        match actions.pop() {
-                            Some(trace::Action::CreateSwapChain { id, desc }) => {
-                                log::info!("Initializing the swapchain");
-                                assert_eq!(id.to_surface_id(), surface);
-                                window.set_inner_size(winit::dpi::PhysicalSize::new(
-                                    desc.width,
-                                    desc.height,
-                                ));
-                                gfx_select!(device => global.device_create_swap_chain(device, surface, &desc));
-                            }
-                            Some(trace::Action::PresentSwapChain(id)) => {
-                                frame_count += 1;
-                                log::debug!("Presenting frame {}", frame_count);
-                                gfx_select!(device => global.swap_chain_present(id));
-                                break;
-                            }
-                            Some(action) => {
-                                gfx_select!(device => global.process(device, action, &dir, &mut command_buffer_id_manager));
-                            }
-                            None => break,
+        let mut frame_count = 0;
+        event_loop.run(move |event, _, control_flow| {
+            *control_flow = ControlFlow::Poll;
+            match event {
+                Event::MainEventsCleared => {
+                    window.request_redraw();
+                }
+                Event::RedrawRequested(_) => loop {
+                    match actions.pop() {
+                        Some(trace::Action::CreateSwapChain { id, desc }) => {
+                            log::info!("Initializing the swapchain");
+                            assert_eq!(id.to_surface_id(), surface);
+                            window.set_inner_size(winit::dpi::PhysicalSize::new(
+                                desc.width,
+                                desc.height,
+                            ));
+                            gfx_select!(device => global.device_create_swap_chain(device, surface, &desc));
                         }
-                    },
-                    Event::WindowEvent { event, .. } => match event {
-                        WindowEvent::KeyboardInput {
-                            input:
-                                KeyboardInput {
-                                    virtual_keycode: Some(VirtualKeyCode::Escape),
-                                    state: ElementState::Pressed,
-                                    ..
-                                },
-                            ..
+                        Some(trace::Action::PresentSwapChain(id)) => {
+                            frame_count += 1;
+                            log::debug!("Presenting frame {}", frame_count);
+                            gfx_select!(device => global.swap_chain_present(id));
+                            break;
                         }
-                        | WindowEvent::CloseRequested => {
-                            *control_flow = ControlFlow::Exit;
+                        Some(action) => {
+                            gfx_select!(device => global.process(device, action, &dir, &mut command_buffer_id_manager));
                         }
-                        _ => {}
-                    },
-                    Event::LoopDestroyed => {
-                        log::info!("Closing");
-                        gfx_select!(device => global.device_poll(device, true));
+                        None => break,
+                    }
+                },
+                Event::WindowEvent { event, .. } => match event {
+                    WindowEvent::KeyboardInput {
+                        input:
+                            KeyboardInput {
+                                virtual_keycode: Some(VirtualKeyCode::Escape),
+                                state: ElementState::Pressed,
+                                ..
+                            },
+                        ..
+                    }
+                    | WindowEvent::CloseRequested => {
+                        *control_flow = ControlFlow::Exit;
                     }
                     _ => {}
+                },
+                Event::LoopDestroyed => {
+                    log::info!("Closing");
+                    gfx_select!(device => global.device_poll(device, true));
                 }
-            },
-        );
-    }
-
-    #[cfg(not(feature = "winit"))]
-    while let Some(action) = actions.pop() {
-        gfx_select!(device => global.process(device, action, &dir, &mut command_buffer_id_manager));
+                _ => {}
+            }
+        });
     }
 }
diff --git a/wgpu-core/src/command/compute.rs b/wgpu-core/src/command/compute.rs
index 8d35b94934..bd6d3b4f6c 100644
--- a/wgpu-core/src/command/compute.rs
+++ b/wgpu-core/src/command/compute.rs
@@ -33,7 +33,7 @@ pub enum ComputeCommand {
         index: u8,
         num_dynamic_offsets: u8,
         bind_group_id: id::BindGroupId,
-        #[cfg_attr(feature = "serde", serde(skip))]
+        #[cfg_attr(any(feature = "trace", feature = "replay"), serde(skip))]
         phantom_offsets: PhantomSlice<DynamicOffset>,
     },
     SetPipeline(id::ComputePipelineId),
diff --git a/wgpu-core/src/command/render.rs b/wgpu-core/src/command/render.rs
index 6c8b0222de..9d445559ae 100644
--- a/wgpu-core/src/command/render.rs
+++ b/wgpu-core/src/command/render.rs
@@ -63,7 +63,7 @@ pub enum RenderCommand {
         index: u8,
         num_dynamic_offsets: u8,
         bind_group_id: id::BindGroupId,
-        #[cfg_attr(feature = "serde", serde(skip))]
+        #[cfg_attr(any(feature = "trace", feature = "replay"), serde(skip))]
         phantom_offsets: PhantomSlice<DynamicOffset>,
     },
     SetPipeline(id::RenderPipelineId),
diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs
index f47b7a3af0..57c0331b70 100644
--- a/wgpu-core/src/device/mod.rs
+++ b/wgpu-core/src/device/mod.rs
@@ -199,6 +199,7 @@ pub struct Device<B: hal::Backend> {
     temp_suspected: life::SuspectedResources,
     pub(crate) private_features: PrivateFeatures,
     limits: wgt::Limits,
+    extensions: wgt::Extensions,
     #[cfg(feature = "trace")]
     pub(crate) trace: Option<Mutex<Trace>>,
 }
@@ -211,8 +212,8 @@ impl<B: GfxBackend> Device<B> {
         mem_props: hal::adapter::MemoryProperties,
         non_coherent_atom_size: u64,
         supports_texture_d24_s8: bool,
-        limits: wgt::Limits,
-        #[cfg(feature = "trace")] trace_path: Option<&std::path::Path>,
+        desc: &wgt::DeviceDescriptor,
+        trace_path: Option<&std::path::Path>,
     ) -> Self {
         // don't start submission index at zero
         let life_guard = LifeGuard::new();
@@ -232,6 +233,11 @@ impl<B: GfxBackend> Device<B> {
                 non_coherent_atom_size,
             )
         };
+        #[cfg(not(feature = "trace"))]
+        match trace_path {
+            Some(_) => log::warn!("Tracing feature is not enabled"),
+            None => (),
+        }
 
         Device {
             raw,
@@ -250,7 +256,8 @@ impl<B: GfxBackend> Device<B> {
             trace: trace_path.and_then(|path| match Trace::new(path) {
                 Ok(mut trace) => {
                     trace.add(Action::Init {
-                        limits: limits.clone(),
+                        desc: desc.clone(),
+                        backend: B::VARIANT,
                     });
                     Some(Mutex::new(trace))
                 }
@@ -262,7 +269,8 @@ impl<B: GfxBackend> Device<B> {
             private_features: PrivateFeatures {
                 supports_texture_d24_s8,
             },
-            limits,
+            limits: desc.limits.clone(),
+            extensions: desc.extensions.clone(),
         }
     }
 
@@ -2336,7 +2344,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
 
     #[cfg(feature = "replay")]
     /// Only triange suspected resource IDs. This helps us to avoid ID collisions
-    /// upon creating new resources when re-plaing a trace.
+    /// upon creating new resources when re-playing a trace.
     pub fn device_maintain_ids<B: GfxBackend>(&self, device_id: id::DeviceId) {
         let hub = B::hub(self);
         let mut token = Token::root();
diff --git a/wgpu-core/src/device/trace.rs b/wgpu-core/src/device/trace.rs
index 4301a5eeb0..e34656cef7 100644
--- a/wgpu-core/src/device/trace.rs
+++ b/wgpu-core/src/device/trace.rs
@@ -96,7 +96,8 @@ pub struct RenderPipelineDescriptor {
 #[cfg_attr(feature = "replay", derive(serde::Deserialize))]
 pub enum Action {
     Init {
-        limits: wgt::Limits,
+        desc: wgt::DeviceDescriptor,
+        backend: wgt::Backend,
     },
     CreateBuffer {
         id: id::BufferId,
diff --git a/wgpu-core/src/id.rs b/wgpu-core/src/id.rs
index 966d1eb6db..ee4eafb62d 100644
--- a/wgpu-core/src/id.rs
+++ b/wgpu-core/src/id.rs
@@ -11,9 +11,37 @@ const EPOCH_MASK: u32 = (1 << (32 - BACKEND_BITS)) - 1;
 type Dummy = crate::backend::Empty;
 
 #[repr(transparent)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize), serde(into = "SerialId"))]
+#[cfg_attr(
+    feature = "replay",
+    derive(serde::Deserialize),
+    serde(from = "SerialId")
+)]
+pub struct Id<T>(NonZeroU64, PhantomData<T>);
+
+// This type represents Id in a more readable (and editable) way.
+#[allow(dead_code)]
 #[cfg_attr(feature = "trace", derive(serde::Serialize))]
 #[cfg_attr(feature = "replay", derive(serde::Deserialize))]
-pub struct Id<T>(NonZeroU64, PhantomData<T>);
+enum SerialId {
+    // The only variant forces RON to not ignore "Id"
+    Id(Index, Epoch, Backend),
+}
+#[cfg(feature = "trace")]
+impl<T> From<Id<T>> for SerialId {
+    fn from(id: Id<T>) -> Self {
+        let (index, epoch, backend) = id.unzip();
+        SerialId::Id(index, epoch, backend)
+    }
+}
+#[cfg(feature = "replay")]
+impl<T> From<SerialId> for Id<T> {
+    fn from(id: SerialId) -> Self {
+        match id {
+            SerialId::Id(index, epoch, backend) => TypedId::zip(index, epoch, backend),
+        }
+    }
+}
 
 // required for PeekPoke
 impl<T> Default for Id<T> {
diff --git a/wgpu-core/src/instance.rs b/wgpu-core/src/instance.rs
index c25258f6f7..9819f42d33 100644
--- a/wgpu-core/src/instance.rs
+++ b/wgpu-core/src/instance.rs
@@ -580,7 +580,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         &self,
         adapter_id: AdapterId,
         desc: &DeviceDescriptor,
-        #[cfg(feature = "trace")] trace_path: Option<&std::path::Path>,
+        trace_path: Option<&std::path::Path>,
         id_in: Input<G, DeviceId>,
     ) -> DeviceId {
         let hub = B::hub(self);
@@ -646,8 +646,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                 mem_props,
                 limits.non_coherent_atom_size as u64,
                 supports_texture_d24_s8,
-                desc.limits.clone(),
-                #[cfg(feature = "trace")]
+                desc,
                 trace_path,
             )
         };
diff --git a/wgpu-types/src/lib.rs b/wgpu-types/src/lib.rs
index 5394aa473e..fc8318e5f4 100644
--- a/wgpu-types/src/lib.rs
+++ b/wgpu-types/src/lib.rs
@@ -37,7 +37,7 @@ pub enum PowerPreference {
 bitflags::bitflags! {
     #[repr(transparent)]
     #[cfg_attr(feature = "trace", derive(Serialize))]
-#[cfg_attr(feature = "replay", derive(Deserialize))]
+    #[cfg_attr(feature = "replay", derive(Deserialize))]
     pub struct BackendBit: u32 {
         const VULKAN = 1 << Backend::Vulkan as u32;
         const GL = 1 << Backend::Gl as u32;