Files
wgpu/wgpu-remote/src/lib.rs
T

146 lines
3.9 KiB
Rust

//TODO: remove once `cbindgen` is smart enough
extern crate wgpu_native as wgn;
use crate::server::Server;
use ipc_channel::ipc;
use log::error;
use parking_lot::Mutex;
use serde::{Deserialize, Serialize};
use std::ptr;
mod server;
#[derive(Serialize, Deserialize)]
enum InstanceMessage {
Create(wgn::InstanceId),
InstanceGetAdapter(wgn::InstanceId, wgn::AdapterDescriptor, wgn::AdapterId),
AdapterCreateDevice(wgn::AdapterId, wgn::DeviceDescriptor, wgn::DeviceId),
Destroy(wgn::InstanceId),
}
/// A message on the timeline of devices, queues, and resources.
#[derive(Serialize, Deserialize)]
enum GlobalMessage {
Instance(InstanceMessage),
//Device(DeviceMessage),
//Queue(QueueMessage),
//Texture(TextureMessage),
//Command(CommandMessage),
Terminate,
}
#[derive(Default)]
struct IdentityHub {
adapters: wgn::IdentityManager,
devices: wgn::IdentityManager,
}
pub struct Client {
channel: ipc::IpcSender<GlobalMessage>,
instance_id: wgn::InstanceId,
identity: Mutex<IdentityHub>,
}
pub struct ClientFactory {
channel: ipc::IpcSender<GlobalMessage>,
instance_identities: Mutex<wgn::IdentityManager>,
}
#[repr(C)]
pub struct Infrastructure {
pub factory: *mut ClientFactory,
pub server: *mut Server,
pub error: *const u8,
}
#[no_mangle]
pub extern "C" fn wgpu_initialize() -> Infrastructure {
match ipc::channel() {
Ok((sender, receiver)) => {
let factory = ClientFactory {
channel: sender,
instance_identities: Mutex::new(wgn::IdentityManager::default()),
};
let server = Server::new(receiver);
Infrastructure {
factory: Box::into_raw(Box::new(factory)),
server: Box::into_raw(Box::new(server)),
error: ptr::null(),
}
}
Err(e) => {
error!("WGPU initialize failed: {:?}", e);
Infrastructure {
factory: ptr::null_mut(),
server: ptr::null_mut(),
error: ptr::null(), //TODO_remote_
}
}
}
}
#[no_mangle]
pub extern "C" fn wgpu_terminate(factory: *mut ClientFactory) {
let factory = unsafe {
Box::from_raw(factory)
};
let _ = factory.channel.send(GlobalMessage::Terminate);
}
#[no_mangle]
pub extern "C" fn wgpu_client_create(factory: &ClientFactory) -> *mut Client {
let instance_id = factory.instance_identities.lock().alloc();
let msg = GlobalMessage::Instance(InstanceMessage::Create(instance_id));
factory.channel.send(msg).unwrap();
let client = Client {
channel: factory.channel.clone(),
instance_id,
identity: Mutex::new(IdentityHub::default()),
};
Box::into_raw(Box::new(client))
}
#[no_mangle]
pub extern "C" fn wgpu_client_destroy(factory: &ClientFactory, client: *mut Client) {
let client = unsafe {
Box::from_raw(client)
};
factory.instance_identities.lock().free(client.instance_id);
let msg = GlobalMessage::Instance(InstanceMessage::Destroy(client.instance_id));
client.channel.send(msg).unwrap();
}
#[no_mangle]
pub extern "C" fn wgpu_client_get_adapter(
client: &Client,
desc: &wgn::AdapterDescriptor,
) -> wgn::AdapterId {
let id = client.identity.lock().adapters.alloc();
let msg = GlobalMessage::Instance(InstanceMessage::InstanceGetAdapter(
client.instance_id,
desc.clone(),
id,
));
client.channel.send(msg).unwrap();
id
}
#[no_mangle]
pub extern "C" fn wgpu_client_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
}