Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Implement GPURenderBundleEncoder and GPURenderBundle

Browse source
This commit is contained in:
Kunal Mohan 2020-07-22 17:52:49 +05:30
parent 75abccb16b
commit aff22db33f
32 changed files with 676 additions and 115 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Cargo.lock generated
View file

@ -3642,13 +3642,14 @@ checksum = "0419348c027fa7be448d2ae7ea0e4e04c2334c31dc4e74ab29f00a2a7ca69204"
[[package]]
name = "naga"
version = "0.1.0"
source = "git+https://github.com/gfx-rs/naga?rev=a9228d2aed38c71388489a95817238ff98198fa3#a9228d2aed38c71388489a95817238ff98198fa3"
source = "git+https://github.com/gfx-rs/naga?rev=94802078c3bc5d138f497419ea3e7a869f10916d#94802078c3bc5d138f497419ea3e7a869f10916d"
dependencies = [
"bitflags",
"fxhash",
"log",
"num-traits",
"spirv_headers",
"thiserror",
]
[[package]]
@ -6861,7 +6862,7 @@ dependencies = [
[[package]]
name = "wgpu-core"
version = "0.5.0"
source = "git+https://github.com/gfx-rs/wgpu#4ed2c0a313deb48a99f15e8fe0558ad3d095ca01"
source = "git+https://github.com/gfx-rs/wgpu#8a2ee26fffcdf02fc5e7f0a29771f4720522f7d8"
dependencies = [
"arrayvec 0.5.1",
"bitflags",
@ -6881,7 +6882,6 @@ dependencies = [
"ron",
"serde",
"smallvec 1.4.1",
"spirv_headers",
"thiserror",
"tracing",
"wgpu-types",
@ -6890,7 +6890,7 @@ dependencies = [
[[package]]
name = "wgpu-types"
version = "0.5.0"
source = "git+https://github.com/gfx-rs/wgpu#4ed2c0a313deb48a99f15e8fe0558ad3d095ca01"
source = "git+https://github.com/gfx-rs/wgpu#8a2ee26fffcdf02fc5e7f0a29771f4720522f7d8"
dependencies = [
"bitflags",
"serde",

8
components/script/dom/bindings/trace.rs
View file

@ -168,12 +168,12 @@ use tendril::{StrTendril, TendrilSink};
use time::{Duration, Timespec, Tm};
use uuid::Uuid;
use webgpu::{
wgpu::command::{ComputePass, RenderPass},
wgpu::command::{ComputePass, RenderBundleEncoder, RenderPass},
wgt::BindGroupLayoutEntry,
WebGPU, WebGPUAdapter, WebGPUBindGroup, WebGPUBindGroupLayout, WebGPUBuffer,
WebGPUCommandBuffer, WebGPUCommandEncoder, WebGPUComputePipeline, WebGPUDevice,
WebGPUPipelineLayout, WebGPUQueue, WebGPURenderPipeline, WebGPUSampler, WebGPUShaderModule,
WebGPUTexture, WebGPUTextureView,
WebGPUPipelineLayout, WebGPUQueue, WebGPURenderBundle, WebGPURenderPipeline, WebGPUSampler,
WebGPUShaderModule, WebGPUTexture, WebGPUTextureView,
};
use webrender_api::{DocumentId, ExternalImageId, ImageKey};
use webxr_api::{Finger, Hand, Ray, View};
@ -618,6 +618,7 @@ unsafe_no_jsmanaged_fields!(WebGPUBindGroup);
unsafe_no_jsmanaged_fields!(WebGPUBindGroupLayout);
unsafe_no_jsmanaged_fields!(WebGPUComputePipeline);
unsafe_no_jsmanaged_fields!(WebGPURenderPipeline);
unsafe_no_jsmanaged_fields!(WebGPURenderBundle);
unsafe_no_jsmanaged_fields!(WebGPUPipelineLayout);
unsafe_no_jsmanaged_fields!(WebGPUQueue);
unsafe_no_jsmanaged_fields!(WebGPUShaderModule);
@ -630,6 +631,7 @@ unsafe_no_jsmanaged_fields!(WebGPUCommandEncoder);
unsafe_no_jsmanaged_fields!(WebGPUDevice);
unsafe_no_jsmanaged_fields!(BindGroupLayoutEntry);
unsafe_no_jsmanaged_fields!(Option<RenderPass>);
unsafe_no_jsmanaged_fields!(Option<RenderBundleEncoder>);
unsafe_no_jsmanaged_fields!(Option<ComputePass>);
unsafe_no_jsmanaged_fields!(GPUBufferState);
unsafe_no_jsmanaged_fields!(GPUCommandEncoderState);

3
components/script/dom/gpuadapter.rs
View file

@ -103,6 +103,7 @@ impl GPUAdapterMethods for GPUAdapter {
descriptor: desc,
device_id: id,
pipeline_id,
label: descriptor.parent.label.as_ref().map(|s| s.to_string()),
})
.is_err()
{
@ -119,6 +120,7 @@ impl AsyncWGPUListener for GPUAdapter {
device_id,
queue_id,
_descriptor,
label,
} => {
let device = GPUDevice::new(
&self.global(),
@ -128,6 +130,7 @@ impl AsyncWGPUListener for GPUAdapter {
Heap::default(),
device_id,
queue_id,
label,
);
self.global().add_gpu_device(&device);
promise.resolve_native(&device);

8
components/script/dom/gpubindgroup.rs
View file

@ -26,10 +26,11 @@ impl GPUBindGroup {
bind_group: WebGPUBindGroup,
device: WebGPUDevice,
layout: &GPUBindGroupLayout,
label: Option<USVString>,
) -> Self {
Self {
reflector_: Reflector::new(),
label: DomRefCell::new(None),
label: DomRefCell::new(label),
bind_group,
device,
layout: Dom::from_ref(layout),
@ -41,9 +42,12 @@ impl GPUBindGroup {
bind_group: WebGPUBindGroup,
device: WebGPUDevice,
layout: &GPUBindGroupLayout,
label: Option<USVString>,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(GPUBindGroup::new_inherited(bind_group, device, layout)),
Box::new(GPUBindGroup::new_inherited(
bind_group, device, layout, label,
)),
global,
)
}

12
components/script/dom/gpubindgrouplayout.rs
View file

@ -19,17 +19,21 @@ pub struct GPUBindGroupLayout {
}
impl GPUBindGroupLayout {
fn new_inherited(bind_group_layout: WebGPUBindGroupLayout) -> Self {
fn new_inherited(bind_group_layout: WebGPUBindGroupLayout, label: Option<USVString>) -> Self {
Self {
reflector_: Reflector::new(),
label: DomRefCell::new(None),
label: DomRefCell::new(label),
bind_group_layout,
}
}
pub fn new(global: &GlobalScope, bind_group_layout: WebGPUBindGroupLayout) -> DomRoot<Self> {
pub fn new(
global: &GlobalScope,
bind_group_layout: WebGPUBindGroupLayout,
label: Option<USVString>,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(GPUBindGroupLayout::new_inherited(bind_group_layout)),
Box::new(GPUBindGroupLayout::new_inherited(bind_group_layout, label)),
global,
)
}

6
components/script/dom/gpubuffer.rs
View file

@ -76,11 +76,12 @@ impl GPUBuffer {
state: GPUBufferState,
size: GPUSize64,
map_info: DomRefCell<Option<GPUBufferMapInfo>>,
label: Option<USVString>,
) -> Self {
Self {
reflector_: Reflector::new(),
channel,
label: DomRefCell::new(None),
label: DomRefCell::new(label),
state: Cell::new(state),
device,
buffer,
@ -99,10 +100,11 @@ impl GPUBuffer {
state: GPUBufferState,
size: GPUSize64,
map_info: DomRefCell<Option<GPUBufferMapInfo>>,
label: Option<USVString>,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(GPUBuffer::new_inherited(
channel, buffer, device, state, size, map_info,
channel, buffer, device, state, size, map_info, label,
)),
global,
)

8
components/script/dom/gpucanvascontext.rs
View file

@ -201,7 +201,13 @@ impl GPUCanvasContextMethods for GPUCanvasContext {
self.webrender_image.set(Some(receiver.recv().unwrap()));
let swap_chain = GPUSwapChain::new(&self.global(), self.channel.clone(), &self, &*texture);
let swap_chain = GPUSwapChain::new(
&self.global(),
self.channel.clone(),
&self,
&*texture,
descriptor.parent.label.as_ref().cloned(),
);
*self.swap_chain.borrow_mut() = Some(Dom::from_ref(&*swap_chain));
swap_chain
}

5
components/script/dom/gpucommandbuffer.rs
View file

@ -37,11 +37,12 @@ impl GPUCommandBuffer {
channel: WebGPU,
command_buffer: WebGPUCommandBuffer,
buffers: HashSet<DomRoot<GPUBuffer>>,
label: Option<USVString>,
) -> Self {
Self {
channel,
reflector_: Reflector::new(),
label: DomRefCell::new(None),
label: DomRefCell::new(label),
command_buffer,
buffers: DomRefCell::new(buffers.into_iter().map(|b| Dom::from_ref(&*b)).collect()),
}
@ -52,12 +53,14 @@ impl GPUCommandBuffer {
channel: WebGPU,
command_buffer: WebGPUCommandBuffer,
buffers: HashSet<DomRoot<GPUBuffer>>,
label: Option<USVString>,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(GPUCommandBuffer::new_inherited(
channel,
command_buffer,
buffers,
label,
)),
global,
)

26
components/script/dom/gpucommandencoder.rs
View file

@ -59,11 +59,12 @@ impl GPUCommandEncoder {
device: WebGPUDevice,
encoder: webgpu::WebGPUCommandEncoder,
valid: bool,
label: Option<USVString>,
) -> Self {
Self {
channel,
reflector_: Reflector::new(),
label: DomRefCell::new(None),
label: DomRefCell::new(label),
device,
encoder,
buffers: DomRefCell::new(HashSet::new()),
@ -78,10 +79,11 @@ impl GPUCommandEncoder {
device: WebGPUDevice,
encoder: webgpu::WebGPUCommandEncoder,
valid: bool,
label: Option<USVString>,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(GPUCommandEncoder::new_inherited(
channel, device, encoder, valid,
channel, device, encoder, valid, label,
)),
global,
)
@ -117,13 +119,18 @@ impl GPUCommandEncoderMethods for GPUCommandEncoder {
/// https://gpuweb.github.io/gpuweb/#dom-gpucommandencoder-begincomputepass
fn BeginComputePass(
&self,
_descriptor: &GPUComputePassDescriptor,
descriptor: &GPUComputePassDescriptor,
) -> DomRoot<GPUComputePassEncoder> {
self.set_state(
GPUCommandEncoderState::EncodingComputePass,
GPUCommandEncoderState::Open,
);
GPUComputePassEncoder::new(&self.global(), self.channel.clone(), &self)
GPUComputePassEncoder::new(
&self.global(),
self.channel.clone(),
&self,
descriptor.parent.label.as_ref().cloned(),
)
}
/// https://gpuweb.github.io/gpuweb/#dom-gpucommandencoder-beginrenderpass
@ -228,7 +235,13 @@ impl GPUCommandEncoderMethods for GPUCommandEncoder {
let render_pass = wgpu_com::RenderPass::new(self.encoder.0, desc);
GPURenderPassEncoder::new(&self.global(), self.channel.clone(), render_pass, &self)
GPURenderPassEncoder::new(
&self.global(),
self.channel.clone(),
render_pass,
&self,
descriptor.parent.label.as_ref().cloned(),
)
}
/// https://gpuweb.github.io/gpuweb/#dom-gpucommandencoder-copybuffertobuffer
@ -352,7 +365,7 @@ impl GPUCommandEncoderMethods for GPUCommandEncoder {
}
/// https://gpuweb.github.io/gpuweb/#dom-gpucommandencoder-finish
fn Finish(&self, _descriptor: &GPUCommandBufferDescriptor) -> DomRoot<GPUCommandBuffer> {
fn Finish(&self, descriptor: &GPUCommandBufferDescriptor) -> DomRoot<GPUCommandBuffer> {
self.channel
.0
.send(WebGPURequest::CommandEncoderFinish {
@ -369,6 +382,7 @@ impl GPUCommandEncoderMethods for GPUCommandEncoder {
self.channel.clone(),
buffer,
self.buffers.borrow_mut().drain().collect(),
descriptor.parent.label.as_ref().cloned(),
)
}
}

19
components/script/dom/gpucomputepassencoder.rs
View file

@ -30,19 +30,28 @@ pub struct GPUComputePassEncoder {
}
impl GPUComputePassEncoder {
fn new_inherited(channel: WebGPU, parent: &GPUCommandEncoder) -> Self {
fn new_inherited(
channel: WebGPU,
parent: &GPUCommandEncoder,
label: Option<USVString>,
) -> Self {
Self {
channel,
reflector_: Reflector::new(),
label: DomRefCell::new(None),
label: DomRefCell::new(label),
compute_pass: DomRefCell::new(Some(ComputePass::new(parent.id().0))),
command_encoder: Dom::from_ref(parent),
}
}
pub fn new(global: &GlobalScope, channel: WebGPU, parent: &GPUCommandEncoder) -> DomRoot<Self> {
pub fn new(
global: &GlobalScope,
channel: WebGPU,
parent: &GPUCommandEncoder,
label: Option<USVString>,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(GPUComputePassEncoder::new_inherited(channel, parent)),
Box::new(GPUComputePassEncoder::new_inherited(channel, parent, label)),
global,
)
}
@ -86,7 +95,7 @@ impl GPUComputePassEncoderMethods for GPUComputePassEncoder {
command_encoder_id: self.command_encoder.id().0,
compute_pass,
})
.unwrap();
.expect("Failed to send RunComputePass");
self.command_encoder.set_state(
GPUCommandEncoderState::Open,

12
components/script/dom/gpucomputepipeline.rs
View file

@ -20,17 +20,21 @@ pub struct GPUComputePipeline {
}
impl GPUComputePipeline {
fn new_inherited(compute_pipeline: WebGPUComputePipeline) -> Self {
fn new_inherited(compute_pipeline: WebGPUComputePipeline, label: Option<USVString>) -> Self {
Self {
reflector_: Reflector::new(),
label: DomRefCell::new(None),
label: DomRefCell::new(label),
compute_pipeline,
}
}
pub fn new(global: &GlobalScope, compute_pipeline: WebGPUComputePipeline) -> DomRoot<Self> {
pub fn new(
global: &GlobalScope,
compute_pipeline: WebGPUComputePipeline,
label: Option<USVString>,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(GPUComputePipeline::new_inherited(compute_pipeline)),
Box::new(GPUComputePipeline::new_inherited(compute_pipeline, label)),
global,
)
}

124
components/script/dom/gpudevice.rs
View file

@ -17,6 +17,7 @@ use crate::dom::bindings::codegen::Bindings::GPUDeviceBinding::{
GPUCommandEncoderDescriptor, GPUDeviceMethods,
};
use crate::dom::bindings::codegen::Bindings::GPUPipelineLayoutBinding::GPUPipelineLayoutDescriptor;
use crate::dom::bindings::codegen::Bindings::GPURenderBundleEncoderBinding::GPURenderBundleEncoderDescriptor;
use crate::dom::bindings::codegen::Bindings::GPURenderPipelineBinding::{
GPUBlendDescriptor, GPUBlendFactor, GPUBlendOperation, GPUCullMode, GPUFrontFace,
GPUIndexFormat, GPUInputStepMode, GPUPrimitiveTopology, GPURenderPipelineDescriptor,
@ -50,6 +51,7 @@ use crate::dom::gpucommandencoder::GPUCommandEncoder;
use crate::dom::gpucomputepipeline::GPUComputePipeline;
use crate::dom::gpupipelinelayout::GPUPipelineLayout;
use crate::dom::gpuqueue::GPUQueue;
use crate::dom::gpurenderbundleencoder::GPURenderBundleEncoder;
use crate::dom::gpurenderpipeline::GPURenderPipeline;
use crate::dom::gpusampler::GPUSampler;
use crate::dom::gpushadermodule::GPUShaderModule;
@ -64,8 +66,9 @@ use std::cell::RefCell;
use std::collections::HashMap;
use std::ptr::NonNull;
use std::rc::Rc;
use std::string::String;
use webgpu::wgpu::{binding_model as wgpu_bind, pipeline as wgpu_pipe};
use webgpu::wgpu::{
binding_model as wgpu_bind, command::RenderBundleEncoder, pipeline as wgpu_pipe,
};
use webgpu::{self, wgt, WebGPU, WebGPURequest};
type ErrorScopeId = u64;
@ -116,6 +119,7 @@ impl GPUDevice {
limits: Heap<*mut JSObject>,
device: webgpu::WebGPUDevice,
queue: &GPUQueue,
label: Option<String>,
) -> Self {
Self {
eventtarget: EventTarget::new_inherited(),
@ -123,7 +127,7 @@ impl GPUDevice {
adapter: Dom::from_ref(adapter),
extensions,
limits,
label: DomRefCell::new(None),
label: DomRefCell::new(label.map(|l| USVString::from(l))),
device,
default_queue: Dom::from_ref(queue),
scope_context: DomRefCell::new(ScopeContext {
@ -144,11 +148,12 @@ impl GPUDevice {
limits: Heap<*mut JSObject>,
device: webgpu::WebGPUDevice,
queue: webgpu::WebGPUQueue,
label: Option<String>,
) -> DomRoot<Self> {
let queue = GPUQueue::new(global, channel.clone(), queue);
reflect_dom_object(
Box::new(GPUDevice::new_inherited(
channel, adapter, extensions, limits, device, &queue,
channel, adapter, extensions, limits, device, &queue, label,
)),
global,
)
@ -247,11 +252,7 @@ impl GPUDeviceMethods for GPUDevice {
/// https://gpuweb.github.io/gpuweb/#dom-gpudevice-createbuffer
fn CreateBuffer(&self, descriptor: &GPUBufferDescriptor) -> DomRoot<GPUBuffer> {
let wgpu_descriptor = wgt::BufferDescriptor {
label: descriptor
.parent
.label
.as_ref()
.map(|s| String::from(s.as_ref())),
label: descriptor.parent.label.as_ref().map(|s| s.to_string()),
size: descriptor.size,
usage: match wgt::BufferUsage::from_bits(descriptor.usage) {
Some(u) => u,
@ -299,6 +300,7 @@ impl GPUDeviceMethods for GPUDevice {
state,
descriptor.size,
map_info,
descriptor.parent.label.as_ref().cloned(),
)
}
@ -427,7 +429,11 @@ impl GPUDeviceMethods for GPUDevice {
let bgl = webgpu::WebGPUBindGroupLayout(bind_group_layout_id);
let layout = GPUBindGroupLayout::new(&self.global(), bgl);
let layout = GPUBindGroupLayout::new(
&self.global(),
bgl,
descriptor.parent.label.as_ref().cloned(),
);
self.bind_group_layouts
.borrow_mut()
@ -470,7 +476,11 @@ impl GPUDeviceMethods for GPUDevice {
.expect("Failed to create WebGPU PipelineLayout");
let pipeline_layout = webgpu::WebGPUPipelineLayout(pipeline_layout_id);
GPUPipelineLayout::new(&self.global(), pipeline_layout)
GPUPipelineLayout::new(
&self.global(),
pipeline_layout,
descriptor.parent.label.as_ref().cloned(),
)
}
/// https://gpuweb.github.io/gpuweb/#dom-gpudevice-createbindgroup
@ -527,7 +537,13 @@ impl GPUDeviceMethods for GPUDevice {
let bind_group = webgpu::WebGPUBindGroup(bind_group_id);
GPUBindGroup::new(&self.global(), bind_group, self.device, &*descriptor.layout)
GPUBindGroup::new(
&self.global(),
bind_group,
self.device,
&*descriptor.layout,
descriptor.parent.label.as_ref().cloned(),
)
}
/// https://gpuweb.github.io/gpuweb/#dom-gpudevice-createshadermodule
@ -556,7 +572,11 @@ impl GPUDeviceMethods for GPUDevice {
.expect("Failed to create WebGPU ShaderModule");
let shader_module = webgpu::WebGPUShaderModule(program_id);
GPUShaderModule::new(&self.global(), shader_module)
GPUShaderModule::new(
&self.global(),
shader_module,
descriptor.parent.label.as_ref().cloned(),
)
}
/// https://gpuweb.github.io/gpuweb/#dom-gpudevice-createcomputepipeline
@ -591,7 +611,11 @@ impl GPUDeviceMethods for GPUDevice {
.expect("Failed to create WebGPU ComputePipeline");
let compute_pipeline = webgpu::WebGPUComputePipeline(compute_pipeline_id);
GPUComputePipeline::new(&self.global(), compute_pipeline)
GPUComputePipeline::new(
&self.global(),
compute_pipeline,
descriptor.parent.parent.label.as_ref().cloned(),
)
}
/// https://gpuweb.github.io/gpuweb/#dom-gpudevice-createcommandencoder
@ -609,11 +633,7 @@ impl GPUDeviceMethods for GPUDevice {
.send(WebGPURequest::CreateCommandEncoder {
device_id: self.device.0,
command_encoder_id,
label: descriptor
.parent
.label
.as_ref()
.map(|s| String::from(s.as_ref())),
label: descriptor.parent.label.as_ref().map(|s| s.to_string()),
})
.expect("Failed to create WebGPU command encoder");
@ -625,6 +645,7 @@ impl GPUDeviceMethods for GPUDevice {
self.device,
encoder,
true,
descriptor.parent.label.as_ref().cloned(),
)
}
@ -632,11 +653,7 @@ impl GPUDeviceMethods for GPUDevice {
fn CreateTexture(&self, descriptor: &GPUTextureDescriptor) -> DomRoot<GPUTexture> {
let size = convert_texture_size_to_dict(&descriptor.size);
let desc = wgt::TextureDescriptor {
label: descriptor
.parent
.label
.as_ref()
.map(|s| String::from(s.as_ref())),
label: descriptor.parent.label.as_ref().map(|s| s.to_string()),
size: convert_texture_size_to_wgt(&size),
mip_level_count: descriptor.mipLevelCount,
sample_count: descriptor.sampleCount,
@ -680,6 +697,7 @@ impl GPUDeviceMethods for GPUDevice {
descriptor.dimension,
descriptor.format,
descriptor.usage,
descriptor.parent.label.as_ref().cloned(),
)
}
@ -692,11 +710,7 @@ impl GPUDeviceMethods for GPUDevice {
.create_sampler_id(self.device.0.backend());
let compare_enable = descriptor.compare.is_some();
let desc = wgt::SamplerDescriptor {
label: descriptor
.parent
.label
.as_ref()
.map(|s| String::from(s.as_ref())),
label: descriptor.parent.label.as_ref().map(|s| s.to_string()),
address_mode_u: convert_address_mode(descriptor.addressModeU),
address_mode_v: convert_address_mode(descriptor.addressModeV),
address_mode_w: convert_address_mode(descriptor.addressModeW),
@ -720,7 +734,13 @@ impl GPUDeviceMethods for GPUDevice {
let sampler = webgpu::WebGPUSampler(sampler_id);
GPUSampler::new(&self.global(), self.device, compare_enable, sampler)
GPUSampler::new(
&self.global(),
self.device,
compare_enable,
sampler,
descriptor.parent.label.as_ref().cloned(),
)
}
/// https://gpuweb.github.io/gpuweb/#dom-gpudevice-createrenderpipeline
@ -753,6 +773,7 @@ impl GPUDeviceMethods for GPUDevice {
GPUCullMode::Front => wgt::CullMode::Front,
GPUCullMode::Back => wgt::CullMode::Back,
},
clamp_depth: rs_desc.clampDepth,
depth_bias: rs_desc.depthBias,
depth_bias_slope_scale: *rs_desc.depthBiasSlopeScale,
depth_bias_clamp: *rs_desc.depthBiasClamp,
@ -855,7 +876,48 @@ impl GPUDeviceMethods for GPUDevice {
let render_pipeline = webgpu::WebGPURenderPipeline(render_pipeline_id);
GPURenderPipeline::new(&self.global(), render_pipeline, self.device)
GPURenderPipeline::new(
&self.global(),
render_pipeline,
self.device,
descriptor.parent.parent.label.as_ref().cloned(),
)
}
/// https://gpuweb.github.io/gpuweb/#dom-gpudevice-createrenderbundleencoder
fn CreateRenderBundleEncoder(
&self,
descriptor: &GPURenderBundleEncoderDescriptor,
) -> DomRoot<GPURenderBundleEncoder> {
let desc = wgt::RenderBundleEncoderDescriptor {
label: descriptor
.parent
.label
.as_ref()
.map(|s| Cow::Owned(s.to_string())),
color_formats: Cow::Owned(
descriptor
.colorFormats
.iter()
.map(|f| convert_texture_format(*f))
.collect::<Vec<_>>(),
),
depth_stencil_format: descriptor
.depthStencilFormat
.map(|f| convert_texture_format(f)),
sample_count: descriptor.sampleCount,
};
// Handle error gracefully
let render_bundle_encoder = RenderBundleEncoder::new(&desc, self.device.0, None).unwrap();
GPURenderBundleEncoder::new(
&self.global(),
render_bundle_encoder,
self.device,
self.channel.clone(),
descriptor.parent.label.as_ref().cloned(),
)
}
/// https://gpuweb.github.io/gpuweb/#dom-gpudevice-pusherrorscope

12
components/script/dom/gpupipelinelayout.rs
View file

@ -19,17 +19,21 @@ pub struct GPUPipelineLayout {
}
impl GPUPipelineLayout {
fn new_inherited(pipeline_layout: WebGPUPipelineLayout) -> Self {
fn new_inherited(pipeline_layout: WebGPUPipelineLayout, label: Option<USVString>) -> Self {
Self {
reflector_: Reflector::new(),
label: DomRefCell::new(None),
label: DomRefCell::new(label),
pipeline_layout,
}
}
pub fn new(global: &GlobalScope, pipeline_layout: WebGPUPipelineLayout) -> DomRoot<Self> {
pub fn new(
global: &GlobalScope,
pipeline_layout: WebGPUPipelineLayout,
label: Option<USVString>,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(GPUPipelineLayout::new_inherited(pipeline_layout)),
Box::new(GPUPipelineLayout::new_inherited(pipeline_layout, label)),
global,
)
}

75
components/script/dom/gpurenderbundle.rs Normal file
View file

@ -0,0 +1,75 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* 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 crate::dom::bindings::cell::DomRefCell;
use crate::dom::bindings::codegen::Bindings::GPURenderBundleBinding::GPURenderBundleMethods;
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
use crate::dom::bindings::root::DomRoot;
use crate::dom::bindings::str::USVString;
use crate::dom::globalscope::GlobalScope;
use dom_struct::dom_struct;
use webgpu::{WebGPU, WebGPUDevice, WebGPURenderBundle};
#[dom_struct]
pub struct GPURenderBundle {
reflector_: Reflector,
#[ignore_malloc_size_of = "channels are hard"]
channel: WebGPU,
device: WebGPUDevice,
render_bundle: WebGPURenderBundle,
label: DomRefCell<Option<USVString>>,
}
impl GPURenderBundle {
fn new_inherited(
render_bundle: WebGPURenderBundle,
device: WebGPUDevice,
channel: WebGPU,
label: Option<USVString>,
) -> Self {
Self {
reflector_: Reflector::new(),
render_bundle,
device,
channel,
label: DomRefCell::new(label),
}
}
pub fn new(
global: &GlobalScope,
render_bundle: WebGPURenderBundle,
device: WebGPUDevice,
channel: WebGPU,
label: Option<USVString>,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(GPURenderBundle::new_inherited(
render_bundle,
device,
channel,
label,
)),
global,
)
}
}
impl GPURenderBundle {
pub fn id(&self) -> WebGPURenderBundle {
self.render_bundle
}
}
impl GPURenderBundleMethods for GPURenderBundle {
/// https://gpuweb.github.io/gpuweb/#dom-gpuobjectbase-label
fn GetLabel(&self) -> Option<USVString> {
self.label.borrow().clone()
}
/// https://gpuweb.github.io/gpuweb/#dom-gpuobjectbase-label
fn SetLabel(&self, value: Option<USVString>) {
*self.label.borrow_mut() = value;
}
}

213
components/script/dom/gpurenderbundleencoder.rs Normal file
View file

@ -0,0 +1,213 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* 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 crate::dom::bindings::cell::DomRefCell;
use crate::dom::bindings::codegen::Bindings::GPURenderBundleBinding::GPURenderBundleDescriptor;
use crate::dom::bindings::codegen::Bindings::GPURenderBundleEncoderBinding::GPURenderBundleEncoderMethods;
use crate::dom::bindings::reflector::{reflect_dom_object, DomObject, Reflector};
use crate::dom::bindings::root::DomRoot;
use crate::dom::bindings::str::USVString;
use crate::dom::globalscope::GlobalScope;
use crate::dom::gpubindgroup::GPUBindGroup;
use crate::dom::gpubuffer::GPUBuffer;
use crate::dom::gpurenderbundle::GPURenderBundle;
use crate::dom::gpurenderpipeline::GPURenderPipeline;
use dom_struct::dom_struct;
use webgpu::{
wgpu::command::{bundle_ffi as wgpu_bundle, RenderBundleEncoder},
wgt, WebGPU, WebGPUDevice, WebGPURenderBundle, WebGPURequest,
};
#[dom_struct]
pub struct GPURenderBundleEncoder {
reflector_: Reflector,
#[ignore_malloc_size_of = "channels are hard"]
channel: WebGPU,
device: WebGPUDevice,
#[ignore_malloc_size_of = "defined in wgpu-core"]
render_bundle_encoder: DomRefCell<Option<RenderBundleEncoder>>,
label: DomRefCell<Option<USVString>>,
}
impl GPURenderBundleEncoder {
fn new_inherited(
render_bundle_encoder: RenderBundleEncoder,
device: WebGPUDevice,
channel: WebGPU,
label: Option<USVString>,
) -> Self {
Self {
reflector_: Reflector::new(),
render_bundle_encoder: DomRefCell::new(Some(render_bundle_encoder)),
device,
channel,
label: DomRefCell::new(label),
}
}
pub fn new(
global: &GlobalScope,
render_bundle_encoder: RenderBundleEncoder,
device: WebGPUDevice,
channel: WebGPU,
label: Option<USVString>,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(GPURenderBundleEncoder::new_inherited(
render_bundle_encoder,
device,
channel,
label,
)),
global,
)
}
}
impl GPURenderBundleEncoderMethods for GPURenderBundleEncoder {
/// https://gpuweb.github.io/gpuweb/#dom-gpuobjectbase-label
fn GetLabel(&self) -> Option<USVString> {
self.label.borrow().clone()
}
/// https://gpuweb.github.io/gpuweb/#dom-gpuobjectbase-label
fn SetLabel(&self, value: Option<USVString>) {
*self.label.borrow_mut() = value;
}
/// 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(encoder) = self.render_bundle_encoder.borrow_mut().as_mut() {
unsafe {
wgpu_bundle::wgpu_render_bundle_set_bind_group(
encoder,
index,
bind_group.id().0,
dynamic_offsets.as_ptr(),
dynamic_offsets.len(),
)
};
}
}
/// https://gpuweb.github.io/gpuweb/#dom-gpurenderencoderbase-setpipeline
fn SetPipeline(&self, pipeline: &GPURenderPipeline) {
if let Some(encoder) = self.render_bundle_encoder.borrow_mut().as_mut() {
wgpu_bundle::wgpu_render_bundle_set_pipeline(encoder, pipeline.id().0);
}
}
/// https://gpuweb.github.io/gpuweb/#dom-gpurenderencoderbase-setindexbuffer
fn SetIndexBuffer(&self, buffer: &GPUBuffer, offset: u64, size: u64) {
if let Some(encoder) = self.render_bundle_encoder.borrow_mut().as_mut() {
wgpu_bundle::wgpu_render_bundle_set_index_buffer(
encoder,
buffer.id().0,
offset,
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(encoder) = self.render_bundle_encoder.borrow_mut().as_mut() {
wgpu_bundle::wgpu_render_bundle_set_vertex_buffer(
encoder,
slot,
buffer.id().0,
offset,
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(encoder) = self.render_bundle_encoder.borrow_mut().as_mut() {
wgpu_bundle::wgpu_render_bundle_draw(
encoder,
vertex_count,
instance_count,
first_vertex,
first_instance,
);
}
}
/// https://gpuweb.github.io/gpuweb/#dom-gpurenderencoderbase-drawindexed
fn DrawIndexed(
&self,
index_count: u32,
instance_count: u32,
first_index: u32,
base_vertex: i32,
first_instance: u32,
) {
if let Some(encoder) = self.render_bundle_encoder.borrow_mut().as_mut() {
wgpu_bundle::wgpu_render_bundle_draw_indexed(
encoder,
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(encoder) = self.render_bundle_encoder.borrow_mut().as_mut() {
wgpu_bundle::wgpu_render_bundle_draw_indirect(
encoder,
indirect_buffer.id().0,
indirect_offset,
);
}
}
/// https://gpuweb.github.io/gpuweb/#dom-gpurenderencoderbase-drawindexedindirect
fn DrawIndexedIndirect(&self, indirect_buffer: &GPUBuffer, indirect_offset: u64) {
if let Some(encoder) = self.render_bundle_encoder.borrow_mut().as_mut() {
wgpu_bundle::wgpu_render_pass_bundle_indexed_indirect(
encoder,
indirect_buffer.id().0,
indirect_offset,
);
}
}
/// https://gpuweb.github.io/gpuweb/#dom-gpurenderbundleencoder-finish
fn Finish(&self, descriptor: &GPURenderBundleDescriptor) -> DomRoot<GPURenderBundle> {
let desc = wgt::RenderBundleDescriptor {
label: descriptor.parent.label.as_ref().map(|s| s.to_string()),
};
let encoder = self.render_bundle_encoder.borrow_mut().take().unwrap();
let render_bundle_id = self
.global()
.wgpu_id_hub()
.lock()
.create_render_bundle_id(self.device.0.backend());
self.channel
.0
.send(WebGPURequest::RenderBundleEncoderFinish {
render_bundle_encoder: encoder,
descriptor: desc,
render_bundle_id,
})
.expect("Failed to send RenderBundleEncoderFinish");
let render_bundle = WebGPURenderBundle(render_bundle_id);
GPURenderBundle::new(
&self.global(),
render_bundle,
self.device,
self.channel.clone(),
descriptor.parent.label.as_ref().cloned(),
)
}
}

45
components/script/dom/gpurenderpassencoder.rs
View file

@ -13,6 +13,7 @@ use crate::dom::globalscope::GlobalScope;
use crate::dom::gpubindgroup::GPUBindGroup;
use crate::dom::gpubuffer::GPUBuffer;
use crate::dom::gpucommandencoder::{GPUCommandEncoder, GPUCommandEncoderState};
use crate::dom::gpurenderbundle::GPURenderBundle;
use crate::dom::gpurenderpipeline::GPURenderPipeline;
use dom_struct::dom_struct;
use webgpu::{
@ -32,11 +33,16 @@ pub struct GPURenderPassEncoder {
}
impl GPURenderPassEncoder {
fn new_inherited(channel: WebGPU, render_pass: RenderPass, parent: &GPUCommandEncoder) -> Self {
fn new_inherited(
channel: WebGPU,
render_pass: RenderPass,
parent: &GPUCommandEncoder,
label: Option<USVString>,
) -> Self {
Self {
channel,
reflector_: Reflector::new(),
label: DomRefCell::new(None),
label: DomRefCell::new(label),
render_pass: DomRefCell::new(Some(render_pass)),
command_encoder: Dom::from_ref(parent),
}
@ -47,12 +53,14 @@ impl GPURenderPassEncoder {
channel: WebGPU,
render_pass: RenderPass,
parent: &GPUCommandEncoder,
label: Option<USVString>,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(GPURenderPassEncoder::new_inherited(
channel,
render_pass,
parent,
label,
)),
global,
)
@ -125,11 +133,17 @@ impl GPURenderPassEncoderMethods for GPURenderPassEncoder {
b: *d.b,
a: *d.a,
},
GPUColor::DoubleSequence(s) => wgt::Color {
r: *s[0],
g: *s[1],
b: *s[2],
a: *s[3],
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],
}
},
};
if let Some(render_pass) = self.render_pass.borrow_mut().as_mut() {
@ -153,7 +167,7 @@ impl GPURenderPassEncoderMethods for GPURenderPassEncoder {
command_encoder_id: self.command_encoder.id().0,
render_pass,
})
.unwrap();
.expect("Failed to send RunRenderPass");
self.command_encoder.set_state(
GPUCommandEncoderState::Open,
@ -249,4 +263,19 @@ impl GPURenderPassEncoderMethods for GPURenderPassEncoder {
);
}
}
/// 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() {
unsafe {
wgpu_render::wgpu_render_pass_execute_bundles(
render_pass,
bundle_ids.as_ptr(),
bundle_ids.len(),
)
};
}
}
}

15
components/script/dom/gpurenderpipeline.rs
View file

@ -21,10 +21,14 @@ pub struct GPURenderPipeline {
}
impl GPURenderPipeline {
fn new_inherited(render_pipeline: WebGPURenderPipeline, device: WebGPUDevice) -> Self {
fn new_inherited(
render_pipeline: WebGPURenderPipeline,
device: WebGPUDevice,
label: Option<USVString>,
) -> Self {
Self {
reflector_: Reflector::new(),
label: DomRefCell::new(None),
label: DomRefCell::new(label),
render_pipeline,
device,
}
@ -34,9 +38,14 @@ impl GPURenderPipeline {
global: &GlobalScope,
render_pipeline: WebGPURenderPipeline,
device: WebGPUDevice,
label: Option<USVString>,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(GPURenderPipeline::new_inherited(render_pipeline, device)),
Box::new(GPURenderPipeline::new_inherited(
render_pipeline,
device,
label,
)),
global,
)
}

17
components/script/dom/gpusampler.rs
View file

@ -21,10 +21,15 @@ pub struct GPUSampler {
}
impl GPUSampler {
fn new_inherited(device: WebGPUDevice, compare_enable: bool, sampler: WebGPUSampler) -> Self {
fn new_inherited(
device: WebGPUDevice,
compare_enable: bool,
sampler: WebGPUSampler,
label: Option<USVString>,
) -> Self {
Self {
reflector_: Reflector::new(),
label: DomRefCell::new(None),
label: DomRefCell::new(label),
device,
sampler,
compare_enable,
@ -36,9 +41,15 @@ impl GPUSampler {
device: WebGPUDevice,
compare_enable: bool,
sampler: WebGPUSampler,
label: Option<USVString>,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(GPUSampler::new_inherited(device, compare_enable, sampler)),
Box::new(GPUSampler::new_inherited(
device,
compare_enable,
sampler,
label,
)),
global,
)
}

12
components/script/dom/gpushadermodule.rs
View file

@ -19,17 +19,21 @@ pub struct GPUShaderModule {
}
impl GPUShaderModule {
fn new_inherited(shader_module: WebGPUShaderModule) -> Self {
fn new_inherited(shader_module: WebGPUShaderModule, label: Option<USVString>) -> Self {
Self {
reflector_: Reflector::new(),
label: DomRefCell::new(None),
label: DomRefCell::new(label),
shader_module,
}
}
pub fn new(global: &GlobalScope, shader_module: WebGPUShaderModule) -> DomRoot<Self> {
pub fn new(
global: &GlobalScope,
shader_module: WebGPUShaderModule,
label: Option<USVString>,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(GPUShaderModule::new_inherited(shader_module)),
Box::new(GPUShaderModule::new_inherited(shader_module, label)),
global,
)
}

14
components/script/dom/gpuswapchain.rs
View file

@ -24,13 +24,18 @@ pub struct GPUSwapChain {
}
impl GPUSwapChain {
fn new_inherited(channel: WebGPU, context: &GPUCanvasContext, texture: &GPUTexture) -> Self {
fn new_inherited(
channel: WebGPU,
context: &GPUCanvasContext,
texture: &GPUTexture,
label: Option<USVString>,
) -> Self {
Self {
reflector_: Reflector::new(),
channel,
context: Dom::from_ref(context),
texture: Dom::from_ref(texture),
label: DomRefCell::new(None),
label: DomRefCell::new(label),
}
}
@ -39,9 +44,12 @@ impl GPUSwapChain {
channel: WebGPU,
context: &GPUCanvasContext,
texture: &GPUTexture,
label: Option<USVString>,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(GPUSwapChain::new_inherited(channel, context, texture)),
Box::new(GPUSwapChain::new_inherited(
channel, context, texture, label,
)),
global,
)
}

12
components/script/dom/gputexture.rs
View file

@ -47,11 +47,12 @@ impl GPUTexture {
dimension: GPUTextureDimension,
format: GPUTextureFormat,
texture_usage: u32,
label: Option<USVString>,
) -> Self {
Self {
reflector_: Reflector::new(),
texture,
label: DomRefCell::new(None),
label: DomRefCell::new(label),
device,
channel,
texture_size,
@ -74,6 +75,7 @@ impl GPUTexture {
dimension: GPUTextureDimension,
format: GPUTextureFormat,
texture_usage: u32,
label: Option<USVString>,
) -> DomRoot<Self> {
reflect_dom_object(
Box::new(GPUTexture::new_inherited(
@ -86,6 +88,7 @@ impl GPUTexture {
dimension,
format,
texture_usage,
label,
)),
global,
)
@ -179,7 +182,12 @@ impl GPUTextureMethods for GPUTexture {
let texture_view = WebGPUTextureView(texture_view_id);
GPUTextureView::new(&self.global(), texture_view, &self)
GPUTextureView::new(
&self.global(),
texture_view,
&self,
descriptor.parent.label.as_ref().cloned(),
)
}
/// https://gpuweb.github.io/gpuweb/#dom-gputexture-destroy

11
components/script/dom/gputextureview.rs
View file

@ -21,11 +21,15 @@ pub struct GPUTextureView {
}
impl GPUTextureView {
fn new_inherited(texture_view: WebGPUTextureView, texture: &GPUTexture) -> GPUTextureView {
fn new_inherited(
texture_view: WebGPUTextureView,
texture: &GPUTexture,
label: Option<USVString>,
) -> GPUTextureView {
Self {
reflector_: Reflector::new(),
texture: Dom::from_ref(texture),
label: DomRefCell::new(None),
label: DomRefCell::new(label),
texture_view,
}
}
@ -34,9 +38,10 @@ impl GPUTextureView {
global: &GlobalScope,
texture_view: WebGPUTextureView,
texture: &GPUTexture,
label: Option<USVString>,
) -> DomRoot<GPUTextureView> {
reflect_dom_object(
Box::new(GPUTextureView::new_inherited(texture_view, texture)),
Box::new(GPUTextureView::new_inherited(texture_view, texture, label)),
global,
)
}

14
components/script/dom/identityhub.rs
View file

@ -7,8 +7,8 @@ use webgpu::wgpu::{
hub::IdentityManager,
id::{
AdapterId, BindGroupId, BindGroupLayoutId, BufferId, CommandEncoderId, ComputePipelineId,
DeviceId, PipelineLayoutId, RenderPipelineId, SamplerId, ShaderModuleId, TextureId,
TextureViewId,
DeviceId, PipelineLayoutId, RenderBundleId, RenderPipelineId, SamplerId, ShaderModuleId,
TextureId, TextureViewId,
},
};
use webgpu::wgt::Backend;
@ -28,6 +28,7 @@ pub struct IdentityHub {
texture_views: IdentityManager,
samplers: IdentityManager,
render_pipelines: IdentityManager,
render_bundles: IdentityManager,
}
impl IdentityHub {
@ -46,6 +47,7 @@ impl IdentityHub {
texture_views: IdentityManager::default(),
samplers: IdentityManager::default(),
render_pipelines: IdentityManager::default(),
render_bundles: IdentityManager::default(),
}
}
}
@ -215,4 +217,12 @@ impl Identities {
pub fn kill_texture_view_id(&mut self, id: TextureViewId) {
self.select(id.backend()).texture_views.free(id);
}
pub fn create_render_bundle_id(&mut self, backend: Backend) -> RenderBundleId {
self.select(backend).render_bundles.alloc(backend)
}
pub fn kill_render_bundle_id(&mut self, id: RenderBundleId) {
self.select(id.backend()).render_bundles.free(id);
}
}

2
components/script/dom/mod.rs
View file

@ -338,6 +338,8 @@ pub mod gpumapmode;
pub mod gpuoutofmemoryerror;
pub mod gpupipelinelayout;
pub mod gpuqueue;
pub mod gpurenderbundle;
pub mod gpurenderbundleencoder;
pub mod gpurenderpassencoder;
pub mod gpurenderpipeline;
pub mod gpusampler;

4
components/script/dom/webidls/GPUDevice.webidl
View file

@ -3,7 +3,7 @@
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
// https://gpuweb.github.io/gpuweb/#gpudevice
[Exposed=(Window, DedicatedWorker)/*, Serializable */, Pref="dom.webgpu.enabled"]
[Exposed=(Window, DedicatedWorker), /*Serializable,*/ Pref="dom.webgpu.enabled"]
interface GPUDevice : EventTarget {
[SameObject] readonly attribute GPUAdapter adapter;
readonly attribute object extensions;
@ -24,7 +24,7 @@ interface GPUDevice : EventTarget {
GPURenderPipeline createRenderPipeline(GPURenderPipelineDescriptor descriptor);
GPUCommandEncoder createCommandEncoder(optional GPUCommandEncoderDescriptor descriptor = {});
// GPURenderBundleEncoder createRenderBundleEncoder(GPURenderBundleEncoderDescriptor descriptor);
GPURenderBundleEncoder createRenderBundleEncoder(GPURenderBundleEncoderDescriptor descriptor);
};
GPUDevice includes GPUObjectBase;

12
components/script/dom/webidls/GPURenderBundle.webidl Normal file
View file

@ -0,0 +1,12 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* 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/. */
// https://gpuweb.github.io/gpuweb/#gpurenderbundle
[Exposed=(Window, DedicatedWorker), Pref="dom.webgpu.enabled"]
interface GPURenderBundle {
};
GPURenderBundle includes GPUObjectBase;
dictionary GPURenderBundleDescriptor : GPUObjectDescriptorBase {
};

18
components/script/dom/webidls/GPURenderBundleEncoder.webidl Normal file
View file

@ -0,0 +1,18 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* 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/. */
// https://gpuweb.github.io/gpuweb/#gpurenderbundleencoder
[Exposed=(Window, DedicatedWorker), Pref="dom.webgpu.enabled"]
interface GPURenderBundleEncoder {
GPURenderBundle finish(optional GPURenderBundleDescriptor descriptor = {});
};
GPURenderBundleEncoder includes GPUObjectBase;
GPURenderBundleEncoder includes GPUProgrammablePassEncoder;
GPURenderBundleEncoder includes GPURenderEncoderBase;
dictionary GPURenderBundleEncoderDescriptor : GPUObjectDescriptorBase {
required sequence<GPUTextureFormat> colorFormats;
GPUTextureFormat depthStencilFormat;
GPUSize32 sampleCount = 1;
};

9
components/script/dom/webidls/GPURenderPassEncoder.webidl
View file

@ -16,9 +16,14 @@ interface GPURenderPassEncoder {
void setStencilReference(GPUStencilValue reference);
//void beginOcclusionQuery(GPUSize32 queryIndex);
//void endOcclusionQuery(GPUSize32 queryIndex);
//void endOcclusionQuery();
//void executeBundles(sequence<GPURenderBundle> bundles);
//void beginPipelineStatisticsQuery(GPUQuerySet querySet, GPUSize32 queryIndex);
//void endPipelineStatisticsQuery();
//void writeTimestamp(GPUQuerySet querySet, GPUSize32 queryIndex);
void executeBundles(sequence<GPURenderBundle> bundles);
void endPass();
};
GPURenderPassEncoder includes GPUObjectBase;

2
components/script/dom/webidls/GPURenderPipeline.webidl
View file

@ -38,6 +38,8 @@ typedef [EnforceRange] long GPUDepthBias;
dictionary GPURasterizationStateDescriptor {
GPUFrontFace frontFace = "ccw";
GPUCullMode cullMode = "none";
// Enable depth clamping (requires "depth-clamping" extension)
boolean clampDepth = false;
GPUDepthBias depthBias = 0;
float depthBiasSlopeScale = 0;

1
components/script/script_thread.rs
View file

@ -2057,6 +2057,7 @@ impl ScriptThread {
WebGPUMsg::FreeCommandBuffer(id) => self.gpu_id_hub.lock().kill_command_buffer_id(id),
WebGPUMsg::FreeSampler(id) => self.gpu_id_hub.lock().kill_sampler_id(id),
WebGPUMsg::FreeShaderModule(id) => self.gpu_id_hub.lock().kill_shader_module_id(id),
WebGPUMsg::FreeRenderBundle(id) => self.gpu_id_hub.lock().kill_render_bundle_id(id),
WebGPUMsg::FreeRenderPipeline(id) => self.gpu_id_hub.lock().kill_render_pipeline_id(id),
WebGPUMsg::FreeTexture(id) => self.gpu_id_hub.lock().kill_texture_id(id),
WebGPUMsg::FreeTextureView(id) => self.gpu_id_hub.lock().kill_texture_view_id(id),

4
components/webgpu/identity.rs
View file

@ -57,12 +57,12 @@ pub enum WebGPUMsg {
#[derive(Debug)]
pub struct IdentityRecycler {
sender: IpcSender<WebGPUMsg>,
self_sender: IpcSender<WebGPURequest<'static>>,
self_sender: IpcSender<WebGPURequest>,
}
pub struct IdentityRecyclerFactory {
pub sender: IpcSender<WebGPUMsg>,
pub self_sender: IpcSender<WebGPURequest<'static>>,
pub self_sender: IpcSender<WebGPURequest>,
}
macro_rules! impl_identity_handler {

60
components/webgpu/lib.rs
View file

@ -19,6 +19,7 @@ use msg::constellation_msg::PipelineId;
use serde::{Deserialize, Serialize};
use servo_config::pref;
use smallvec::SmallVec;
use std::borrow::Cow;
use std::collections::HashMap;
use std::ffi::CString;
use std::ptr;
@ -32,7 +33,7 @@ use webrender_traits::{
};
use wgpu::{
binding_model::BindGroupDescriptor,
command::{BufferCopyView, ComputePass, RenderPass, TextureCopyView},
command::{BufferCopyView, ComputePass, RenderBundleEncoder, RenderPass, TextureCopyView},
device::HostMap,
id,
instance::RequestAdapterOptions,
@ -54,6 +55,7 @@ pub enum WebGPUResponse {
device_id: WebGPUDevice,
queue_id: WebGPUQueue,
_descriptor: wgt::DeviceDescriptor,
label: Option<String>,
},
BufferMapAsync(IpcSharedMemory),
}
@ -61,7 +63,7 @@ pub enum WebGPUResponse {
pub type WebGPUResponseResult = Result<WebGPUResponse, String>;
#[derive(Debug, Deserialize, Serialize)]
pub enum WebGPURequest<'a> {
pub enum WebGPURequest {
BufferMapAsync {
sender: IpcSender<WebGPUResponseResult>,
buffer_id: id::BufferId,
@ -105,13 +107,13 @@ pub enum WebGPURequest<'a> {
// TODO: Consider using NonZeroU64 to reduce enum size
scope_id: Option<u64>,
bind_group_id: id::BindGroupId,
descriptor: BindGroupDescriptor<'a>,
descriptor: BindGroupDescriptor<'static>,
},
CreateBindGroupLayout {
device_id: id::DeviceId,
scope_id: Option<u64>,
bind_group_layout_id: id::BindGroupLayoutId,
descriptor: wgt::BindGroupLayoutDescriptor<'a>,
descriptor: wgt::BindGroupLayoutDescriptor<'static>,
},
CreateBuffer {
device_id: id::DeviceId,
@ -129,20 +131,20 @@ pub enum WebGPURequest<'a> {
device_id: id::DeviceId,
scope_id: Option<u64>,
compute_pipeline_id: id::ComputePipelineId,
descriptor: ComputePipelineDescriptor<'a>,
descriptor: ComputePipelineDescriptor<'static>,
},
CreateContext(IpcSender<webrender_api::ExternalImageId>),
CreatePipelineLayout {
device_id: id::DeviceId,
scope_id: Option<u64>,
pipeline_layout_id: id::PipelineLayoutId,
descriptor: wgt::PipelineLayoutDescriptor<'a, id::BindGroupLayoutId>,
descriptor: wgt::PipelineLayoutDescriptor<'static, id::BindGroupLayoutId>,
},
CreateRenderPipeline {
device_id: id::DeviceId,
scope_id: Option<u64>,
render_pipeline_id: id::RenderPipelineId,
descriptor: RenderPipelineDescriptor<'a>,
descriptor: RenderPipelineDescriptor<'static>,
},
CreateSampler {
device_id: id::DeviceId,
@ -180,6 +182,11 @@ pub enum WebGPURequest<'a> {
DestroyTexture(id::TextureId),
Exit(IpcSender<()>),
FreeDevice(id::DeviceId),
RenderBundleEncoderFinish {
render_bundle_encoder: RenderBundleEncoder,
descriptor: wgt::RenderBundleDescriptor<Option<String>>,
render_bundle_id: id::RenderBundleId,
},
RequestAdapter {
sender: IpcSender<WebGPUResponseResult>,
options: RequestAdapterOptions,
@ -191,6 +198,7 @@ pub enum WebGPURequest<'a> {
descriptor: wgt::DeviceDescriptor,
device_id: id::DeviceId,
pipeline_id: PipelineId,
label: Option<String>,
},
RunComputePass {
command_encoder_id: id::CommandEncoderId,
@ -245,7 +253,7 @@ struct BufferMapInfo<'a, T> {
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct WebGPU(pub IpcSender<WebGPURequest<'static>>);
pub struct WebGPU(pub IpcSender<WebGPURequest>);
impl WebGPU {
pub fn new(
@ -309,8 +317,8 @@ impl WebGPU {
}
struct WGPU<'a> {
receiver: IpcReceiver<WebGPURequest<'static>>,
sender: IpcSender<WebGPURequest<'static>>,
receiver: IpcReceiver<WebGPURequest>,
sender: IpcSender<WebGPURequest>,
script_sender: IpcSender<WebGPUMsg>,
global: wgpu::hub::Global<IdentityRecyclerFactory>,
adapters: Vec<WebGPUAdapter>,
@ -320,7 +328,7 @@ struct WGPU<'a> {
// Buffers with pending mapping
buffer_maps: HashMap<id::BufferId, Rc<BufferMapInfo<'a, WebGPUResponseResult>>>,
// Presentation Buffers with pending mapping
present_buffer_maps: HashMap<id::BufferId, Rc<BufferMapInfo<'a, WebGPURequest<'static>>>>,
present_buffer_maps: HashMap<id::BufferId, Rc<BufferMapInfo<'a, WebGPURequest>>>,
webrender_api: webrender_api::RenderApi,
webrender_document: webrender_api::DocumentId,
external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
@ -330,8 +338,8 @@ struct WGPU<'a> {
impl<'a> WGPU<'a> {
fn new(
receiver: IpcReceiver<WebGPURequest<'static>>,
sender: IpcSender<WebGPURequest<'static>>,
receiver: IpcReceiver<WebGPURequest>,
sender: IpcSender<WebGPURequest>,
script_sender: IpcSender<WebGPUMsg>,
webrender_api_sender: webrender_api::RenderApiSender,
webrender_document: webrender_api::DocumentId,
@ -626,7 +634,8 @@ impl<'a> WGPU<'a> {
program,
} => {
let global = &self.global;
let source = wgpu_core::pipeline::ShaderModuleSource::SpirV(&program);
let source =
wgpu_core::pipeline::ShaderModuleSource::SpirV(Cow::Owned(program));
let _ = gfx_select!(program_id =>
global.device_create_shader_module(device_id, source, program_id));
},
@ -766,6 +775,26 @@ impl<'a> WGPU<'a> {
warn!("Unable to send CleanDevice({:?}) ({:?})", device_id, e);
}
},
WebGPURequest::RenderBundleEncoderFinish {
render_bundle_encoder,
descriptor,
render_bundle_id,
} => {
let global = &self.global;
let st;
let label = match descriptor.label {
Some(ref s) => {
st = CString::new(s.as_bytes()).unwrap();
st.as_ptr()
},
None => ptr::null(),
};
let _ = gfx_select!(render_bundle_id => global.render_bundle_encoder_finish(
render_bundle_encoder,
&descriptor.map_label(|_| label),
render_bundle_id
));
},
WebGPURequest::RequestAdapter {
sender,
options,
@ -809,6 +838,7 @@ impl<'a> WGPU<'a> {
descriptor,
device_id,
pipeline_id,
label,
} => {
let global = &self.global;
let result = gfx_select!(device_id => global.adapter_request_device(
@ -828,6 +858,7 @@ impl<'a> WGPU<'a> {
device_id: device,
queue_id: queue,
_descriptor: descriptor,
label,
})) {
warn!(
"Failed to send response to WebGPURequest::RequestDevice ({})",
@ -1136,6 +1167,7 @@ webgpu_resource!(WebGPUComputePipeline, id::ComputePipelineId);
webgpu_resource!(WebGPUDevice, id::DeviceId);
webgpu_resource!(WebGPUPipelineLayout, id::PipelineLayoutId);
webgpu_resource!(WebGPUQueue, id::QueueId);
webgpu_resource!(WebGPURenderBundle, id::RenderBundleId);
webgpu_resource!(WebGPURenderPipeline, id::RenderPipelineId);
webgpu_resource!(WebGPUSampler, id::SamplerId);
webgpu_resource!(WebGPUShaderModule, id::ShaderModuleId);