First bits of wgpu-remote

Author: kvark

Cargo.lock

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

Cargo.toml

@@ -18,6 +18,7 @@ crate-type = ["lib", "cdylib", "staticlib"]
 [features]
 default = []
 local = ["winit", "gfx-backend-empty/winit"]
+remote = ["serde"]
 metal-auto-capture = ["gfx-backend-metal/auto-capture"]
 
 [dependencies]
@@ -32,4 +33,5 @@ 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 }
 winit = { version = "0.18", optional = true }

wgpu-native/Cargo.toml

@@ -107,6 +107,14 @@ impl<T> Registry<T> {
     }
 }
 
+#[cfg(feature = "remote")]
+impl<T> Registry<T> {
+    pub fn register(&self, id: Id, value: T) {
+        let old = self.data.write().map.insert(id, value);
+        assert!(old.is_none());
+    }
+}
+
 #[derive(Default)]
 pub struct Hub {
     pub(crate) instances: Arc<Registry<InstanceHandle>>,

wgpu-native/src/hub.rs

@@ -7,28 +7,35 @@ use crate::{
 #[cfg(feature = "local")]
 use crate::{DeviceId, SurfaceId};
 
+#[cfg(feature = "remote")]
+use serde::{Serialize, Deserialize};
+
 use hal::{self, Instance as _Instance, PhysicalDevice as _PhysicalDevice};
 
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+#[cfg_attr(feature = "remote", derive(Serialize, Deserialize))]
 pub enum PowerPreference {
     Default = 0,
     LowPower = 1,
     HighPerformance = 2,
 }
 
 #[repr(C)]
+#[cfg_attr(feature = "remote", derive(Clone, Serialize, Deserialize))]
 pub struct AdapterDescriptor {
     pub power_preference: PowerPreference,
 }
 
 #[repr(C)]
+#[cfg_attr(feature = "remote", derive(Clone, Serialize, Deserialize))]
 pub struct Extensions {
     pub anisotropic_filtering: bool,
 }
 
 #[repr(C)]
+#[cfg_attr(feature = "remote", derive(Clone, Serialize, Deserialize))]
 pub struct DeviceDescriptor {
     pub extensions: Extensions,
 }

wgpu-native/src/instance.rs

@@ -39,7 +39,7 @@ pub use self::pipeline::*;
 pub use self::resource::*;
 pub use self::swap_chain::*;
 #[cfg(not(feature = "local"))]
-pub use self::hub::{Id, IdentityManager};
+pub use self::hub::{HUB, Id, IdentityManager, Registry};
 
 use std::ptr;
 use std::sync::atomic::{AtomicUsize, Ordering};

wgpu-native/src/lib.rs

@@ -0,0 +1,18 @@
+[package]
+name = "wgpu-remote"
+version = "0.1.0"
+authors = [
+	"Dzmitry Malyshau <kvark@mozilla.com>",
+	"Joshua Groves <josh@joshgroves.com>",
+]
+edition = "2018"
+
+[features]
+default = []
+
+[dependencies]
+wgpu-native = { path = "../wgpu-native", features = ["remote"] }
+ipc-channel = "0.11"
+log = "0.4"
+parking_lot = { version = "0.7" }
+serde = { version = "1.0", features = ["serde_derive"] }

wgpu-remote/Cargo.toml

@@ -0,0 +1,67 @@
+use ipc_channel::ipc::IpcSender;
+use parking_lot::Mutex;
+use serde::{Serialize, Deserialize};
+
+use wgpu_native as wgn;
+
+
+#[derive(Serialize, Deserialize)]
+pub enum InstanceMessage {
+    InstanceGetAdapter(wgn::InstanceId, wgn::AdapterDescriptor, wgn::AdapterId),
+    AdapterCreateDevice(wgn::AdapterId, wgn::DeviceDescriptor, wgn::DeviceId),
+}
+
+/// A message on the timeline of devices, queues, and resources.
+#[derive(Serialize, Deserialize)]
+pub enum GlobalMessage {
+    Instance(InstanceMessage),
+    //Device(DeviceMessage),
+    //Queue(QueueMessage),
+    //Texture(TextureMessage),
+    //Command(CommandMessage),
+}
+
+#[derive(Default)]
+pub struct IdentityHub {
+    adapters: wgn::IdentityManager,
+    devices: wgn::IdentityManager,
+}
+
+pub struct Client {
+    channel: IpcSender<GlobalMessage>,
+    identity: Mutex<IdentityHub>,
+}
+
+impl Client {
+    pub fn new(channel: IpcSender<GlobalMessage>) -> Self {
+        Client {
+            channel,
+            identity: Mutex::new(IdentityHub::default()),
+        }
+    }
+}
+
+
+#[no_mangle]
+pub extern "C" fn wgpu_instance_get_adapter(
+    client: &Client,
+    instance_id: wgn::InstanceId,
+    desc: &wgn::AdapterDescriptor,
+) -> wgn::AdapterId {
+    let id = client.identity.lock().adapters.alloc();
+    let msg = GlobalMessage::Instance(InstanceMessage::InstanceGetAdapter(instance_id, desc.clone(), id));
+    client.channel.send(msg).unwrap();
+    id
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_adapter_create_device(
+    client: &Client,
+    adapter_id: wgn::AdapterId,
+    desc: &wgn::DeviceDescriptor,
+) -> wgn::DeviceId {
+    let id = client.identity.lock().devices.alloc();
+    let msg = GlobalMessage::Instance(InstanceMessage::AdapterCreateDevice(adapter_id, desc.clone(), id));
+    client.channel.send(msg).unwrap();
+    id
+}

wgpu-remote/src/lib.rs

@@ -0,0 +1,35 @@
+use crate::{GlobalMessage, InstanceMessage}
+
+use ipc_channel::ipc::IpcReceiver;
+
+use wgn;
+
+
+struct Server {
+    channel: IpcReceiver<GlobalMessage>,
+    instance_id: wgn::IntanceId,
+}
+
+impl Server {
+    pub fn new(channel: IpcReceiver<GlobalMessage>) -> Self {
+        Server {
+            channel,
+            instance_id: wgn::wgpu_create_instance(),
+        }
+    }
+}
+
+pub fn process(message: GlobalMessage) {
+    match message {
+        GlobalMessage::Instance(msg) => match msg {
+            InstanceMessage::InstanceGetAdapter(instance_id, ref desc, id) => {
+                let adapter = wgn::instance_get_adapter(instance_id, desc);
+                wgn::HUB.adapters.register(id, adapter);
+            }
+            InstanceMessage::AdapterCreateDevice(adapter_id, ref desc, id) => {
+                let device = wgn::adapter_create_device(adapter_id, desc);
+                wgn::HUB.devices.register(id, device);
+            }
+        },
+    }
+}