webgpu: Update wgpu and revamp RenderPass (#32665)

* Update wgpu and revamp RenderPass

* Set good expectations

* Set one bad expectation

* send_render_command

* small fixups

* docs

* doc

* Put RenderPass inside PassState

* Use Pass enum for ComputePass too

* fix docs
This commit is contained in:
Samson 2024-07-04 14:16:42 +02:00 committed by GitHub
parent 26624a109f
commit 99c1f886b8
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
15 changed files with 559 additions and 1032 deletions

View file

@ -2,13 +2,12 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
use std::borrow::Cow;
use std::cell::Cell;
use std::collections::HashSet;
use dom_struct::dom_struct;
use webgpu::wgc::command as wgpu_com;
use webgpu::{self, wgt, WebGPU, WebGPUComputePass, WebGPURequest};
use webgpu::{self, wgt, WebGPU, WebGPUComputePass, WebGPURenderPass, WebGPURequest};
use super::gpuconvert::convert_label;
use crate::dom::bindings::cell::DomRefCell;
@ -134,89 +133,85 @@ impl GPUCommandEncoderMethods for GPUCommandEncoder {
&self,
descriptor: &GPURenderPassDescriptor,
) -> DomRoot<GPURenderPassEncoder> {
let render_pass = if !self.valid.get() {
None
} else {
let depth_stencil = descriptor.depthStencilAttachment.as_ref().map(|depth| {
wgpu_com::RenderPassDepthStencilAttachment {
depth: wgpu_com::PassChannel {
load_op: convert_load_op(depth.depthLoadOp),
store_op: convert_store_op(depth.depthStoreOp),
clear_value: *depth.depthClearValue.unwrap_or_default(),
read_only: depth.depthReadOnly,
},
stencil: wgpu_com::PassChannel {
load_op: convert_load_op(depth.stencilLoadOp),
store_op: convert_store_op(depth.stencilStoreOp),
clear_value: depth.stencilClearValue,
read_only: depth.stencilReadOnly,
},
view: depth.view.id().0,
}
});
let depth_stencil_attachment = descriptor.depthStencilAttachment.as_ref().map(|depth| {
wgpu_com::RenderPassDepthStencilAttachment {
depth: wgpu_com::PassChannel {
load_op: convert_load_op(depth.depthLoadOp),
store_op: convert_store_op(depth.depthStoreOp),
clear_value: *depth.depthClearValue.unwrap_or_default(),
read_only: depth.depthReadOnly,
},
stencil: wgpu_com::PassChannel {
load_op: convert_load_op(depth.stencilLoadOp),
store_op: convert_store_op(depth.stencilStoreOp),
clear_value: depth.stencilClearValue,
read_only: depth.stencilReadOnly,
},
view: depth.view.id().0,
}
});
let desc = wgpu_com::RenderPassDescriptor {
color_attachments: Cow::Owned(
descriptor
.colorAttachments
.iter()
.map(|color| {
let channel = wgpu_com::PassChannel {
load_op: convert_load_op(Some(color.loadOp)),
store_op: convert_store_op(Some(color.storeOp)),
clear_value: if let Some(clear_val) = &color.clearValue {
match clear_val {
DoubleSequenceOrGPUColorDict::DoubleSequence(s) => {
let mut w = s.clone();
if w.len() < 3 {
w.resize(3, Finite::wrap(0.0f64));
}
w.resize(4, Finite::wrap(1.0f64));
wgt::Color {
r: *w[0],
g: *w[1],
b: *w[2],
a: *w[3],
}
},
DoubleSequenceOrGPUColorDict::GPUColorDict(d) => {
wgt::Color {
r: *d.r,
g: *d.g,
b: *d.b,
a: *d.a,
}
},
}
} else {
wgt::Color::TRANSPARENT
},
read_only: false,
};
Some(wgpu_com::RenderPassColorAttachment {
resolve_target: color.resolveTarget.as_ref().map(|t| t.id().0),
channel,
view: color.view.id().0,
})
})
.collect::<Vec<_>>(),
),
depth_stencil_attachment: depth_stencil.as_ref(),
label: descriptor
.parent
.label
.as_ref()
.map(|l| Cow::Borrowed(&**l)),
timestamp_writes: None,
occlusion_query_set: None,
};
Some(wgpu_com::RenderPass::new(self.encoder.0, &desc))
};
let color_attachments = descriptor
.colorAttachments
.iter()
.map(|color| {
let channel = wgpu_com::PassChannel {
load_op: convert_load_op(Some(color.loadOp)),
store_op: convert_store_op(Some(color.storeOp)),
clear_value: if let Some(clear_val) = &color.clearValue {
match clear_val {
DoubleSequenceOrGPUColorDict::DoubleSequence(s) => {
let mut w = s.clone();
if w.len() < 3 {
w.resize(3, Finite::wrap(0.0f64));
}
w.resize(4, Finite::wrap(1.0f64));
wgt::Color {
r: *w[0],
g: *w[1],
b: *w[2],
a: *w[3],
}
},
DoubleSequenceOrGPUColorDict::GPUColorDict(d) => wgt::Color {
r: *d.r,
g: *d.g,
b: *d.b,
a: *d.a,
},
}
} else {
wgt::Color::TRANSPARENT
},
read_only: false,
};
Some(wgpu_com::RenderPassColorAttachment {
resolve_target: color.resolveTarget.as_ref().map(|t| t.id().0),
channel,
view: color.view.id().0,
})
})
.collect::<Vec<_>>();
let render_pass_id = self
.global()
.wgpu_id_hub()
.create_render_pass_id(self.device.id().0.backend());
if let Err(e) = self.channel.0.send(WebGPURequest::BeginRenderPass {
command_encoder_id: self.id().0,
render_pass_id,
label: convert_label(&descriptor.parent),
depth_stencil_attachment,
color_attachments,
device_id: self.device.id().0,
}) {
warn!("Failed to send WebGPURequest::BeginRenderPass {e:?}");
}
GPURenderPassEncoder::new(
&self.global(),
self.channel.clone(),
render_pass,
WebGPURenderPass(render_pass_id),
self,
descriptor.parent.label.clone().unwrap_or_default(),
)

View file

@ -5,7 +5,6 @@
use dom_struct::dom_struct;
use webgpu::{WebGPU, WebGPUComputePass, WebGPURequest};
use super::bindings::error::Fallible;
use crate::dom::bindings::cell::DomRefCell;
use crate::dom::bindings::codegen::Bindings::WebGPUBinding::GPUComputePassEncoderMethods;
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
@ -109,7 +108,7 @@ impl GPUComputePassEncoderMethods for GPUComputePassEncoder {
}
/// <https://gpuweb.github.io/gpuweb/#dom-gpurenderpassencoder-endpass>
fn End(&self) -> Fallible<()> {
fn End(&self) {
if let Err(e) = self.channel.0.send(WebGPURequest::EndComputePass {
compute_pass_id: self.compute_pass.0,
device_id: self.command_encoder.device_id().0,
@ -117,11 +116,9 @@ impl GPUComputePassEncoderMethods for GPUComputePassEncoder {
}) {
warn!("Failed to send WebGPURequest::EndComputePass: {e:?}");
}
Ok(())
}
/// <https://gpuweb.github.io/gpuweb/#dom-gpuprogrammablepassencoder-setbindgroup>
#[allow(unsafe_code)]
fn SetBindGroup(&self, index: u32, bind_group: &GPUBindGroup, offsets: Vec<u32>) {
if let Err(e) = self.channel.0.send(WebGPURequest::ComputePassSetBindGroup {
compute_pass_id: self.compute_pass.0,

View file

@ -3,11 +3,9 @@
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
use dom_struct::dom_struct;
use webgpu::wgc::command::{render_commands as wgpu_render, RenderPass};
use webgpu::{wgt, WebGPU, WebGPURequest};
use webgpu::{wgt, RenderCommand, WebGPU, WebGPURenderPass, WebGPURequest};
use super::bindings::codegen::Bindings::WebGPUBinding::GPUIndexFormat;
use super::bindings::error::Fallible;
use crate::dom::bindings::cell::DomRefCell;
use crate::dom::bindings::codegen::Bindings::WebGPUBinding::{
GPUColor, GPURenderPassEncoderMethods,
@ -30,16 +28,15 @@ pub struct GPURenderPassEncoder {
#[no_trace]
channel: WebGPU,
label: DomRefCell<USVString>,
#[ignore_malloc_size_of = "defined in wgpu-core"]
#[no_trace]
render_pass: DomRefCell<Option<RenderPass>>,
render_pass: WebGPURenderPass,
command_encoder: Dom<GPUCommandEncoder>,
}
impl GPURenderPassEncoder {
fn new_inherited(
channel: WebGPU,
render_pass: Option<RenderPass>,
render_pass: WebGPURenderPass,
parent: &GPUCommandEncoder,
label: USVString,
) -> Self {
@ -47,7 +44,7 @@ impl GPURenderPassEncoder {
channel,
reflector_: Reflector::new(),
label: DomRefCell::new(label),
render_pass: DomRefCell::new(render_pass),
render_pass,
command_encoder: Dom::from_ref(parent),
}
}
@ -55,7 +52,7 @@ impl GPURenderPassEncoder {
pub fn new(
global: &GlobalScope,
channel: WebGPU,
render_pass: Option<RenderPass>,
render_pass: WebGPURenderPass,
parent: &GPUCommandEncoder,
label: USVString,
) -> DomRoot<Self> {
@ -69,6 +66,16 @@ impl GPURenderPassEncoder {
global,
)
}
fn send_render_command(&self, render_command: RenderCommand) {
if let Err(e) = self.channel.0.send(WebGPURequest::RenderPassCommand {
render_pass_id: self.render_pass.0,
render_command,
device_id: self.command_encoder.device_id().0,
}) {
warn!("Error sending WebGPURequest::RenderPassCommand: {e:?}")
}
}
}
impl GPURenderPassEncoderMethods for GPURenderPassEncoder {
@ -83,16 +90,12 @@ impl GPURenderPassEncoderMethods for GPURenderPassEncoder {
}
/// <https://gpuweb.github.io/gpuweb/#dom-gpuprogrammablepassencoder-setbindgroup>
#[allow(unsafe_code)]
fn SetBindGroup(&self, index: u32, bind_group: &GPUBindGroup, dynamic_offsets: Vec<u32>) {
if let Some(render_pass) = self.render_pass.borrow_mut().as_mut() {
wgpu_render::wgpu_render_pass_set_bind_group(
render_pass,
index,
bind_group.id().0,
&dynamic_offsets,
)
}
fn SetBindGroup(&self, index: u32, bind_group: &GPUBindGroup, offsets: Vec<u32>) {
self.send_render_command(RenderCommand::SetBindGroup {
index,
bind_group_id: bind_group.id().0,
offsets,
})
}
/// <https://gpuweb.github.io/gpuweb/#dom-gpurenderpassencoder-setviewport>
@ -105,79 +108,70 @@ impl GPURenderPassEncoderMethods for GPURenderPassEncoder {
min_depth: Finite<f32>,
max_depth: Finite<f32>,
) {
if let Some(render_pass) = self.render_pass.borrow_mut().as_mut() {
wgpu_render::wgpu_render_pass_set_viewport(
render_pass,
*x,
*y,
*width,
*height,
*min_depth,
*max_depth,
);
}
self.send_render_command(RenderCommand::SetViewport {
x: *x,
y: *y,
width: *width,
height: *height,
min_depth: *min_depth,
max_depth: *max_depth,
})
}
/// <https://gpuweb.github.io/gpuweb/#dom-gpurenderpassencoder-setscissorrect>
fn SetScissorRect(&self, x: u32, y: u32, width: u32, height: u32) {
if let Some(render_pass) = self.render_pass.borrow_mut().as_mut() {
wgpu_render::wgpu_render_pass_set_scissor_rect(render_pass, x, y, width, height);
}
self.send_render_command(RenderCommand::SetScissorRect {
x,
y,
width,
height,
})
}
/// <https://gpuweb.github.io/gpuweb/#dom-gpurenderpassencoder-setblendcolor>
fn SetBlendConstant(&self, color: GPUColor) {
if let Some(render_pass) = self.render_pass.borrow_mut().as_mut() {
let colors = match color {
GPUColor::GPUColorDict(d) => wgt::Color {
r: *d.r,
g: *d.g,
b: *d.b,
a: *d.a,
},
GPUColor::DoubleSequence(mut s) => {
if s.len() < 3 {
s.resize(3, Finite::wrap(0.0f64));
}
s.resize(4, Finite::wrap(1.0f64));
wgt::Color {
r: *s[0],
g: *s[1],
b: *s[2],
a: *s[3],
}
},
};
wgpu_render::wgpu_render_pass_set_blend_constant(render_pass, &colors);
}
let color = match color {
GPUColor::GPUColorDict(d) => wgt::Color {
r: *d.r,
g: *d.g,
b: *d.b,
a: *d.a,
},
GPUColor::DoubleSequence(mut s) => {
if s.len() < 3 {
s.resize(3, Finite::wrap(0.0f64));
}
s.resize(4, Finite::wrap(1.0f64));
wgt::Color {
r: *s[0],
g: *s[1],
b: *s[2],
a: *s[3],
}
},
};
self.send_render_command(RenderCommand::SetBlendConstant(color))
}
/// <https://gpuweb.github.io/gpuweb/#dom-gpurenderpassencoder-setstencilreference>
fn SetStencilReference(&self, reference: u32) {
if let Some(render_pass) = self.render_pass.borrow_mut().as_mut() {
wgpu_render::wgpu_render_pass_set_stencil_reference(render_pass, reference);
}
self.send_render_command(RenderCommand::SetStencilReference(reference))
}
/// <https://gpuweb.github.io/gpuweb/#dom-gpurenderpassencoder-end>
fn End(&self) -> Fallible<()> {
let render_pass = self.render_pass.borrow_mut().take();
self.channel
.0
.send(WebGPURequest::EndRenderPass {
render_pass,
device_id: self.command_encoder.device_id().0,
})
.expect("Failed to send RunRenderPass");
Ok(())
fn End(&self) {
if let Err(e) = self.channel.0.send(WebGPURequest::EndRenderPass {
render_pass_id: self.render_pass.0,
device_id: self.command_encoder.device_id().0,
command_encoder_id: self.command_encoder.id().0,
}) {
warn!("Failed to send WebGPURequest::EndRenderPass: {e:?}");
}
}
/// <https://gpuweb.github.io/gpuweb/#dom-gpurenderencoderbase-setpipeline>
fn SetPipeline(&self, pipeline: &GPURenderPipeline) {
if let Some(render_pass) = self.render_pass.borrow_mut().as_mut() {
wgpu_render::wgpu_render_pass_set_pipeline(render_pass, pipeline.id().0);
}
self.send_render_command(RenderCommand::SetPipeline(pipeline.id().0))
}
/// <https://gpuweb.github.io/gpuweb/#dom-gpurendercommandsmixin-setindexbuffer>
@ -188,44 +182,35 @@ impl GPURenderPassEncoderMethods for GPURenderPassEncoder {
offset: u64,
size: u64,
) {
if let Some(render_pass) = self.render_pass.borrow_mut().as_mut() {
wgpu_render::wgpu_render_pass_set_index_buffer(
render_pass,
buffer.id().0,
match index_format {
GPUIndexFormat::Uint16 => wgt::IndexFormat::Uint16,
GPUIndexFormat::Uint32 => wgt::IndexFormat::Uint32,
},
offset,
wgt::BufferSize::new(size),
);
}
self.send_render_command(RenderCommand::SetIndexBuffer {
buffer_id: buffer.id().0,
index_format: match index_format {
GPUIndexFormat::Uint16 => wgt::IndexFormat::Uint16,
GPUIndexFormat::Uint32 => wgt::IndexFormat::Uint32,
},
offset,
size: wgt::BufferSize::new(size),
})
}
/// <https://gpuweb.github.io/gpuweb/#dom-gpurenderencoderbase-setvertexbuffer>
fn SetVertexBuffer(&self, slot: u32, buffer: &GPUBuffer, offset: u64, size: u64) {
if let Some(render_pass) = self.render_pass.borrow_mut().as_mut() {
wgpu_render::wgpu_render_pass_set_vertex_buffer(
render_pass,
slot,
buffer.id().0,
offset,
wgt::BufferSize::new(size),
);
}
self.send_render_command(RenderCommand::SetVertexBuffer {
slot,
buffer_id: buffer.id().0,
offset,
size: wgt::BufferSize::new(size),
})
}
/// <https://gpuweb.github.io/gpuweb/#dom-gpurenderencoderbase-draw>
fn Draw(&self, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32) {
if let Some(render_pass) = self.render_pass.borrow_mut().as_mut() {
wgpu_render::wgpu_render_pass_draw(
render_pass,
vertex_count,
instance_count,
first_vertex,
first_instance,
);
}
self.send_render_command(RenderCommand::Draw {
vertex_count,
instance_count,
first_vertex,
first_instance,
})
}
/// <https://gpuweb.github.io/gpuweb/#dom-gpurenderencoderbase-drawindexed>
@ -237,46 +222,47 @@ impl GPURenderPassEncoderMethods for GPURenderPassEncoder {
base_vertex: i32,
first_instance: u32,
) {
if let Some(render_pass) = self.render_pass.borrow_mut().as_mut() {
wgpu_render::wgpu_render_pass_draw_indexed(
render_pass,
index_count,
instance_count,
first_index,
base_vertex,
first_instance,
);
}
self.send_render_command(RenderCommand::DrawIndexed {
index_count,
instance_count,
first_index,
base_vertex,
first_instance,
})
}
/// <https://gpuweb.github.io/gpuweb/#dom-gpurenderencoderbase-drawindirect>
fn DrawIndirect(&self, indirect_buffer: &GPUBuffer, indirect_offset: u64) {
if let Some(render_pass) = self.render_pass.borrow_mut().as_mut() {
wgpu_render::wgpu_render_pass_draw_indirect(
render_pass,
indirect_buffer.id().0,
indirect_offset,
);
}
fn DrawIndirect(&self, buffer: &GPUBuffer, offset: u64) {
self.send_render_command(RenderCommand::DrawIndirect {
buffer_id: buffer.id().0,
offset,
})
}
/// <https://gpuweb.github.io/gpuweb/#dom-gpurenderencoderbase-drawindexedindirect>
fn DrawIndexedIndirect(&self, indirect_buffer: &GPUBuffer, indirect_offset: u64) {
if let Some(render_pass) = self.render_pass.borrow_mut().as_mut() {
wgpu_render::wgpu_render_pass_draw_indexed_indirect(
render_pass,
indirect_buffer.id().0,
indirect_offset,
);
}
fn DrawIndexedIndirect(&self, buffer: &GPUBuffer, offset: u64) {
self.send_render_command(RenderCommand::DrawIndexedIndirect {
buffer_id: buffer.id().0,
offset,
})
}
/// <https://gpuweb.github.io/gpuweb/#dom-gpurenderpassencoder-executebundles>
#[allow(unsafe_code)]
fn ExecuteBundles(&self, bundles: Vec<DomRoot<GPURenderBundle>>) {
let bundle_ids = bundles.iter().map(|b| b.id().0).collect::<Vec<_>>();
if let Some(render_pass) = self.render_pass.borrow_mut().as_mut() {
wgpu_render::wgpu_render_pass_execute_bundles(render_pass, &bundle_ids)
let bundle_ids: Vec<_> = bundles.iter().map(|b| b.id().0).collect();
self.send_render_command(RenderCommand::ExecuteBundles(bundle_ids))
}
}
impl Drop for GPURenderPassEncoder {
fn drop(&mut self) {
if let Err(e) = self
.channel
.0
.send(WebGPURequest::DropRenderPass(self.render_pass.0))
{
warn!("Failed to send WebGPURequest::DropRenderPass with {e:?}");
}
}
}

View file

@ -3,7 +3,7 @@
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
use smallvec::SmallVec;
use webgpu::identity::{ComputePass, ComputePassId};
use webgpu::identity::{ComputePass, ComputePassId, RenderPass, RenderPassId};
use webgpu::wgc::id::markers::{
Adapter, BindGroup, BindGroupLayout, Buffer, CommandEncoder, ComputePipeline, Device,
PipelineLayout, RenderBundle, RenderPipeline, Sampler, ShaderModule, Texture, TextureView,
@ -33,6 +33,7 @@ pub struct IdentityHub {
render_pipelines: IdentityManager<RenderPipeline>,
render_bundles: IdentityManager<RenderBundle>,
compute_passes: IdentityManager<ComputePass>,
render_passes: IdentityManager<RenderPass>,
}
impl IdentityHub {
@ -53,6 +54,7 @@ impl IdentityHub {
render_pipelines: IdentityManager::new(),
render_bundles: IdentityManager::new(),
compute_passes: IdentityManager::new(),
render_passes: IdentityManager::new(),
}
}
}
@ -236,6 +238,14 @@ impl Identities {
pub fn free_compute_pass_id(&self, id: ComputePassId) {
self.select(id.backend()).compute_passes.free(id);
}
pub fn create_render_pass_id(&self, backend: Backend) -> RenderPassId {
self.select(backend).render_passes.process(backend)
}
pub fn free_render_pass_id(&self, id: RenderPassId) {
self.select(id.backend()).render_passes.free(id);
}
}
impl Default for Identities {

View file

@ -840,7 +840,6 @@ interface GPUComputePassEncoder {
//[Pref="dom.webgpu.indirect-dispatch.enabled"]
undefined dispatchWorkgroupsIndirect(GPUBuffer indirectBuffer, GPUSize64 indirectOffset);
[Throws]
undefined end();
};
GPUComputePassEncoder includes GPUObjectBase;
@ -871,7 +870,6 @@ interface GPURenderPassEncoder {
undefined executeBundles(sequence<GPURenderBundle> bundles);
[Throws]
undefined end();
};
GPURenderPassEncoder includes GPUObjectBase;

View file

@ -2444,6 +2444,8 @@ impl ScriptThread {
WebGPUMsg::FreeRenderPipeline(id) => self.gpu_id_hub.free_render_pipeline_id(id),
WebGPUMsg::FreeTexture(id) => self.gpu_id_hub.free_texture_id(id),
WebGPUMsg::FreeTextureView(id) => self.gpu_id_hub.free_texture_view_id(id),
WebGPUMsg::FreeComputePass(id) => self.gpu_id_hub.free_compute_pass_id(id),
WebGPUMsg::FreeRenderPass(id) => self.gpu_id_hub.free_render_pass_id(id),
WebGPUMsg::Exit => *self.webgpu_port.borrow_mut() = None,
WebGPUMsg::DeviceLost {
pipeline_id,