Skip to content

Commit

Permalink
Inline callbacks
Browse files Browse the repository at this point in the history
  • Loading branch information
@sagudev
sagudev committed Apr 26, 2024
1 parent e577e90 commit be57ce1
Showing 1 changed file with 68 additions and 88 deletions.
156 changes: 68 additions & 88 deletions components/webgpu/lib.rs
View file
Expand Up @@ -83,10 +83,6 @@ pub enum WebGPURequest {
host_map: HostMap,
map_range: std::ops::Range<u64>,
},
BufferMapComplete {
sender: IpcSender<Option<WebGPUResponseResult>>,
buffer_id: id::BufferId,
},
CommandEncoderFinish {
command_encoder_id: id::CommandEncoderId,
device_id: id::DeviceId,
Expand Down Expand Up @@ -259,11 +255,6 @@ pub enum WebGPURequest {
offset: u64,
size: u64,
},
UpdateWebRenderData {
buffer_id: id::BufferId,
external_id: u64,
buffer_size: usize,
},
WriteBuffer {
queue_id: id::QueueId,
buffer_id: id::BufferId,
Expand Down Expand Up @@ -352,14 +343,14 @@ struct WGPU {
receiver: IpcReceiver<(Option<ErrorScopeId>, WebGPURequest)>,
sender: IpcSender<(Option<ErrorScopeId>, WebGPURequest)>,
script_sender: IpcSender<WebGPUMsg>,
global: wgpu::global::Global,
global: Arc<wgpu::global::Global>,
adapters: Vec<WebGPUAdapter>,
devices: HashMap<WebGPUDevice, PipelineId>,
// Track invalid adapters https://gpuweb.github.io/gpuweb/#invalid
_invalid_adapters: Vec<WebGPUAdapter>,
//TODO: Remove this (https://github.com/gfx-rs/wgpu/issues/867)
error_command_encoders: RefCell<HashMap<id::CommandEncoderId, String>>,
webrender_api: RenderApi,
webrender_api: Arc<Mutex<RenderApi>>,
webrender_document: DocumentId,
external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
wgpu_image_map: Arc<Mutex<HashMap<u64, PresentationData>>>,
Expand All @@ -380,18 +371,18 @@ impl WGPU {
receiver,
sender,
script_sender,
global: wgpu::global::Global::new(
global: Arc::new(wgpu::global::Global::new(
"wgpu-core",
InstanceDescriptor {
backends: wgt::Backends::PRIMARY,
..Default::default()
},
),
)),
adapters: Vec::new(),
devices: HashMap::new(),
_invalid_adapters: Vec::new(),
error_command_encoders: RefCell::new(HashMap::new()),
webrender_api: webrender_api_sender.create_api(),
webrender_api: Arc::new(Mutex::new(webrender_api_sender.create_api())),
webrender_document,
external_images,
wgpu_image_map,
Expand All @@ -414,19 +405,26 @@ impl WGPU {
host_map,
map_range,
} => {
let self_sender = self.sender.clone();
let glob = Arc::clone(&self.global);
let resp_sender = sender.clone();
let callback = BufferMapCallback::from_rust(Box::from(move |result| {
match result {
Ok(()) => {
if let Err(e) = self_sender.send((
scope_id,
WebGPURequest::BufferMapComplete {
sender: resp_sender,
buffer_id,
},
)) {
warn!("Could not send BufferMapComplete ({})", e);
let global = &glob;
let (slice_pointer, range_size) = gfx_select!(buffer_id =>
global.buffer_get_mapped_range(buffer_id, 0, None))
.unwrap();
// SAFETY: guarantee to be safe from wgpu
let data = unsafe {
slice::from_raw_parts(slice_pointer, range_size as usize)
};

if let Err(e) =
resp_sender.send(Some(Ok(WebGPUResponse::BufferMapAsync(
IpcSharedMemory::from_bytes(data),
))))
{
warn!("Could not send BufferMapAsync Response ({})", e);
}
},
Err(_) => {
Expand All @@ -453,21 +451,6 @@ impl WGPU {
}
self.send_result(device_id, scope_id, result);
},
WebGPURequest::BufferMapComplete { sender, buffer_id } => {
let global = &self.global;
let (slice_pointer, range_size) = gfx_select!(buffer_id =>
global.buffer_get_mapped_range(buffer_id, 0, None))
.unwrap();
// SAFETY: guarantee to be safe from wgpu
let data =
unsafe { slice::from_raw_parts(slice_pointer, range_size as usize) };

if let Err(e) = sender.send(Some(Ok(WebGPUResponse::BufferMapAsync(
IpcSharedMemory::from_bytes(data),
)))) {
warn!("Could not send BufferMapAsync Response ({})", e);
}
},
WebGPURequest::CommandEncoderFinish {
command_encoder_id,
device_id,
Expand Down Expand Up @@ -730,7 +713,8 @@ impl WGPU {
let width = image_desc.size.width;
let buffer_stride =
((width * 4) as u32 | (wgt::COPY_BYTES_PER_ROW_ALIGNMENT - 1)) + 1;
let image_key = self.webrender_api.generate_image_key();
let mut wr = self.webrender_api.lock().unwrap();
let image_key = wr.generate_image_key();
if let Err(e) = sender.send(image_key) {
warn!("Failed to send ImageKey ({})", e);
}
Expand Down Expand Up @@ -759,8 +743,7 @@ impl WGPU {

let mut txn = Transaction::new();
txn.add_image(image_key, image_desc, image_data, None);
self.webrender_api
.send_transaction(self.webrender_document, txn);
wr.send_transaction(self.webrender_document, txn);
},
WebGPURequest::CreateTexture {
device_id,
Expand Down Expand Up @@ -831,6 +814,8 @@ impl WGPU {
let mut txn = Transaction::new();
txn.delete_image(image_key);
self.webrender_api
.lock()
.unwrap()
.send_transaction(self.webrender_document, txn);
},
WebGPURequest::DestroyTexture {
Expand Down Expand Up @@ -1122,23 +1107,52 @@ impl WGPU {
&[encoder_id.transmute()]
));

let sender = self.sender.clone();
let callback =
BufferMapCallback::from_rust(Box::from(move |result| match result {
let glob = Arc::clone(&self.global);
let wgpu_image_map = Arc::clone(&self.wgpu_image_map);
let webrender_api = Arc::clone(&self.webrender_api);
let webrender_document = self.webrender_document;
let callback = BufferMapCallback::from_rust(Box::from(move |result| {
match result {
Ok(()) => {
if let Err(e) = sender.send((
None,
WebGPURequest::UpdateWebRenderData {
buffer_id,
buffer_size: buffer_size as usize,
external_id,
},
)) {
warn!("Could not send UpdateWebRenderData ({})", e);
let global = &glob;
let (slice_pointer, range_size) = gfx_select!(buffer_id =>
global.buffer_get_mapped_range(buffer_id, 0, Some(buffer_size as u64)))
.unwrap();
let data = unsafe {
slice::from_raw_parts(slice_pointer, range_size as usize)
}
.to_vec();
if let Some(present_data) =
wgpu_image_map.lock().unwrap().get_mut(&external_id)
{
present_data.data = data;
let mut txn = Transaction::new();
txn.update_image(
present_data.image_key,
present_data.image_desc,
present_data.image_data.clone(),
&DirtyRect::All,
);
webrender_api
.lock()
.unwrap()
.send_transaction(webrender_document, txn);
present_data
.queued_buffer_ids
.retain(|b_id| *b_id != buffer_id);
present_data.available_buffer_ids.push(buffer_id);
} else {
warn!(
"Data not found for ExternalImageId({:?})",
external_id
);
}
let _ =
gfx_select!(buffer_id => global.buffer_unmap(buffer_id));
},
_ => error!("Could not map buffer({:?})", buffer_id),
}));
}
}));
let map_op = BufferMapOperation {
host: HostMap::Read,
callback: Some(callback),
Expand Down Expand Up @@ -1170,40 +1184,6 @@ impl WGPU {
let result = gfx_select!(buffer_id => global.buffer_unmap(buffer_id));
self.send_result(device_id, scope_id, result);
},
WebGPURequest::UpdateWebRenderData {
buffer_id,
buffer_size,
external_id,
} => {
let global = &self.global;
let (slice_pointer, range_size) = gfx_select!(buffer_id =>
global.buffer_get_mapped_range(buffer_id, 0, Some(buffer_size as u64)))
.unwrap();
let data =
unsafe { slice::from_raw_parts(slice_pointer, range_size as usize) }
.to_vec();
if let Some(present_data) =
self.wgpu_image_map.lock().unwrap().get_mut(&external_id)
{
present_data.data = data;
let mut txn = Transaction::new();
txn.update_image(
present_data.image_key,
present_data.image_desc,
present_data.image_data.clone(),
&DirtyRect::All,
);
self.webrender_api
.send_transaction(self.webrender_document, txn);
present_data
.queued_buffer_ids
.retain(|b_id| *b_id != buffer_id);
present_data.available_buffer_ids.push(buffer_id);
} else {
warn!("Data not found for ExternalImageId({:?})", external_id);
}
let _ = gfx_select!(buffer_id => global.buffer_unmap(buffer_id));
},
WebGPURequest::WriteBuffer {
queue_id,
buffer_id,
Expand Down

0 comments on commit be57ce1

Please sign in to comment.