Merge #65

65: First bits of wgpu-remote r=grovesNL a=kvark



Co-authored-by: Dzmitry Malyshau <dmalyshau@mozilla.com>
Co-authored-by: Dzmitry Malyshau <kvarkus@gmail.com>

Author: bors[bot]

Cargo.lock

@@ -2,6 +2,7 @@
 members = [
     "wgpu-native",
     "wgpu-bindings",
+    "wgpu-remote",
     "wgpu-rs",
     "examples",
     "gfx-examples",

Cargo.toml

@@ -53,7 +53,7 @@ lib-native: Cargo.lock wgpu-native/Cargo.toml $(wildcard wgpu-native/**/*.rs)
 lib-rust: Cargo.lock wgpu-rs/Cargo.toml $(wildcard wgpu-rs/**/*.rs)
 	cargo build --manifest-path wgpu-rs/Cargo.toml --features $(FEATURE_RUST)
 
-wgpu-bindings/wgpu.h: Cargo.lock wgpu-bindings/src/*.rs lib-native
+wgpu-bindings/*.h: Cargo.lock wgpu-bindings/src/*.rs lib-native
 	cargo +nightly-2018-12-27 run --manifest-path wgpu-bindings/Cargo.toml
 
 examples-native: lib-native wgpu-bindings/wgpu.h $(wildcard wgpu-native/**/*.c)

Makefile

@@ -1,6 +1,7 @@
 use log::info;
 
 
+#[allow(dead_code)]
 pub fn cast_slice<T>(data: &[T]) -> &[u8] {
     use std::mem::size_of;
     use std::slice::from_raw_parts;

gfx-examples/src/framework.rs

@@ -1 +1,2 @@
 newline_style = "Native"
+spaces_around_ranges = true

rustfmt.toml

@@ -2,42 +2,51 @@ extern crate cbindgen;
 
 use std::path::PathBuf;
 
-const HEADER: &str = "
-#ifdef WGPU_REMOTE
-    typedef uint32_t WGPUId;
-#else
-    typedef void *WGPUId;
-#endif
-";
+struct Binding<'a> {
+    library: &'a str,
+    features: &'a [&'a str],
+    output: &'a str,
+}
+
+const BINDINGS: [Binding; 2] = [
+    Binding {
+        library: "wgpu-native",
+        features: &["local"],
+        output: "wgpu.h",
+    },
+    Binding {
+        library: "wgpu-remote",
+        features: &[],
+        output: "wgpu-remote.h",
+    },
+];
 
 fn main() {
     let crate_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-    let source_dir = crate_dir.parent().unwrap().join("wgpu-native");
+    let parent = crate_dir.parent().unwrap();
 
-    let config = cbindgen::Config {
-        header: Some(String::from(HEADER.trim())),
-        enumeration: cbindgen::EnumConfig {
-            prefix_with_name: true,
-            ..Default::default()
-        },
-        export: cbindgen::ExportConfig {
-            prefix: Some(String::from("WGPU")),
-            exclude: vec![
-                // We manually define `Id` is within the header, so exclude it here
-                String::from("Id"),
-            ],
+    for bind in &BINDINGS {
+        let config = cbindgen::Config {
+            enumeration: cbindgen::EnumConfig {
+                prefix_with_name: true,
+                ..Default::default()
+            },
+            export: cbindgen::ExportConfig {
+                prefix: Some(String::from("WGPU")),
+                ..Default::default()
+            },
+            language: cbindgen::Language::C,
             ..Default::default()
-        },
-        language: cbindgen::Language::C,
-        ..Default::default()
-    };
+        };
 
-    cbindgen::Builder::new()
-        .with_crate(source_dir)
-        .with_config(config)
-        .with_parse_expand(&["wgpu-native"])
-        .with_parse_expand_features(&["local"])
-        .generate()
-        .unwrap()
-        .write_to_file(crate_dir.join("wgpu.h"));
+        println!("Generating {}...", bind.output);
+        cbindgen::Builder::new()
+            .with_crate(parent.join(bind.library))
+            .with_config(config)
+            .with_parse_expand(&[bind.library])
+            .with_parse_expand_features(bind.features)
+            .generate()
+            .unwrap()
+            .write_to_file(crate_dir.join(bind.output));
+    }
 }

wgpu-bindings/src/main.rs

@@ -0,0 +1,14 @@
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct WGPUClient WGPUClient;
+
+WGPUDeviceId wgpu_adapter_create_device(const WGPUClient *client,
+                                        WGPUAdapterId adapter_id,
+                                        const WGPUDeviceDescriptor *desc);
+
+WGPUAdapterId wgpu_instance_get_adapter(const WGPUClient *client,
+                                        WGPUInstanceId instance_id,
+                                        const WGPUAdapterDescriptor *desc);

wgpu-bindings/wgpu-remote.h

@@ -1,9 +1,3 @@
-#ifdef WGPU_REMOTE
-    typedef uint32_t WGPUId;
-#else
-    typedef void *WGPUId;
-#endif
-
 #include <stdarg.h>
 #include <stdbool.h>
 #include <stdint.h>
@@ -138,7 +132,8 @@ typedef enum {
   WGPUTextureFormat_R8g8b8a8Unorm = 0,
   WGPUTextureFormat_R8g8b8a8Uint = 1,
   WGPUTextureFormat_B8g8r8a8Unorm = 2,
-  WGPUTextureFormat_D32FloatS8Uint = 3,
+  WGPUTextureFormat_D32Float = 3,
+  WGPUTextureFormat_D32FloatS8Uint = 4,
 } WGPUTextureFormat;
 
 typedef enum {
@@ -155,8 +150,13 @@ typedef enum {
   WGPUVertexFormat_FloatR32G32B32 = 1,
   WGPUVertexFormat_FloatR32G32 = 2,
   WGPUVertexFormat_FloatR32 = 3,
+  WGPUVertexFormat_IntR8G8B8A8 = 4,
 } WGPUVertexFormat;
 
+typedef struct WGPUBufferMapAsyncStatus WGPUBufferMapAsyncStatus;
+
+typedef struct WGPUId WGPUId;
+
 typedef WGPUId WGPUDeviceId;
 
 typedef WGPUId WGPUAdapterId;
@@ -171,6 +171,10 @@ typedef struct {
 
 typedef WGPUId WGPUBufferId;
 
+typedef void (*WGPUBufferMapReadCallback)(WGPUBufferMapAsyncStatus status, const uint8_t *data, uint8_t *userdata);
+
+typedef void (*WGPUBufferMapWriteCallback)(WGPUBufferMapAsyncStatus status, uint8_t *data, uint8_t *userdata);
+
 typedef WGPUId WGPUCommandBufferId;
 
 typedef struct {
@@ -555,11 +559,25 @@ WGPUDeviceId wgpu_adapter_create_device(WGPUAdapterId adapter_id, const WGPUDevi
 
 void wgpu_buffer_destroy(WGPUBufferId buffer_id);
 
+void wgpu_buffer_map_read_async(WGPUBufferId buffer_id,
+                                uint32_t start,
+                                uint32_t size,
+                                WGPUBufferMapReadCallback callback,
+                                uint8_t *userdata);
+
+void wgpu_buffer_map_write_async(WGPUBufferId buffer_id,
+                                 uint32_t start,
+                                 uint32_t size,
+                                 WGPUBufferMapWriteCallback callback,
+                                 uint8_t *userdata);
+
 void wgpu_buffer_set_sub_data(WGPUBufferId buffer_id,
                               uint32_t start,
                               uint32_t count,
                               const uint8_t *data);
 
+void wgpu_buffer_unmap(WGPUBufferId buffer_id);
+
 void wgpu_command_buffer_copy_buffer_to_buffer(WGPUCommandBufferId command_buffer_id,
                                                WGPUBufferId src,
                                                uint32_t src_offset,
@@ -632,6 +650,8 @@ WGPUSwapChainId wgpu_device_create_swap_chain(WGPUDeviceId device_id,
 
 WGPUTextureId wgpu_device_create_texture(WGPUDeviceId device_id, const WGPUTextureDescriptor *desc);
 
+void wgpu_device_destroy(WGPUBufferId device_id);
+
 WGPUQueueId wgpu_device_get_queue(WGPUDeviceId device_id);
 
 WGPUSurfaceId wgpu_instance_create_surface_from_macos_layer(WGPUInstanceId instance_id,

wgpu-bindings/wgpu.h

@@ -18,9 +18,11 @@ crate-type = ["lib", "cdylib", "staticlib"]
 [features]
 default = []
 local = ["winit", "gfx-backend-empty/winit"]
+remote = ["serde"]
 metal-auto-capture = ["gfx-backend-metal/auto-capture"]
 
 [dependencies]
+arrayvec = "0.4"
 bitflags = "1.0"
 lazy_static = "1.1.0"
 log = "0.4"
@@ -32,4 +34,6 @@ gfx-backend-dx11 = { version = "0.1.0", optional = true }
 gfx-backend-dx12 = { version = "0.1.0", optional = true }
 gfx-backend-metal = { version = "0.1.0", optional = true }
 #rendy-memory = { git = "https://github.com/rustgd/rendy", rev = "ce7dd7f", features = ["gfx-hal"] }
+serde = { version = "1.0", features = ["serde_derive"], optional = true }
+vec_map = "0.8"
 winit = { version = "0.18", optional = true }

wgpu-native/Cargo.toml

@@ -1,6 +1,6 @@
 use crate::track::TrackerSet;
 use crate::{
-    LifeGuard, WeaklyStored,
+    LifeGuard,
     BindGroupLayoutId, BufferId, SamplerId, TextureViewId,
 };
 
@@ -50,7 +50,7 @@ pub struct PipelineLayoutDescriptor {
 
 pub struct PipelineLayout<B: hal::Backend> {
     pub(crate) raw: B::PipelineLayout,
-    pub(crate) bind_group_layout_ids: Vec<WeaklyStored<BindGroupLayoutId>>,
+    pub(crate) bind_group_layout_ids: Vec<BindGroupLayoutId>,
 }
 
 #[repr(C)]
@@ -82,7 +82,7 @@ pub struct BindGroupDescriptor {
 
 pub struct BindGroup<B: hal::Backend> {
     pub(crate) raw: B::DescriptorSet,
-    pub(crate) layout_id: WeaklyStored<BindGroupLayoutId>,
+    pub(crate) layout_id: BindGroupLayoutId,
     pub(crate) life_guard: LifeGuard,
     pub(crate) used: TrackerSet,
 }