mirror of
https://github.com/servo/servo.git
synced 2025-08-03 04:30:10 +01:00
Auto merge of #27389 - kunalmohan:update-wgpu, r=kvark
Implement GPURenderBundles <!-- Please describe your changes on the following line: --> 1. Implement `GPURenderBundleEncoder` and `GPURenderBundle`. 2. Update wgpu to use serializable descriptors. 3. Set user-defined labels on object creation. r?@kvark --- <!-- Thank you for contributing to Servo! Please replace each `[ ]` by `[X]` when the step is complete, and replace `___` with appropriate data: --> - [X] `./mach build -d` does not report any errors - [X] `./mach test-tidy` does not report any errors <!-- Also, please make sure that "Allow edits from maintainers" checkbox is checked, so that we can help you if you get stuck somewhere along the way.--> <!-- Pull requests that do not address these steps are welcome, but they will require additional verification as part of the review process. -->
This commit is contained in:
commit
ebec798263
31 changed files with 899 additions and 443 deletions
|
@ -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);
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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,
|
||||
)
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
)
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
)
|
||||
|
|
|
@ -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
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
)
|
||||
|
|
|
@ -25,6 +25,7 @@ use crate::dom::gpucomputepassencoder::GPUComputePassEncoder;
|
|||
use crate::dom::gpudevice::{convert_texture_size_to_dict, convert_texture_size_to_wgt};
|
||||
use crate::dom::gpurenderpassencoder::GPURenderPassEncoder;
|
||||
use dom_struct::dom_struct;
|
||||
use std::borrow::Cow;
|
||||
use std::cell::Cell;
|
||||
use std::collections::HashSet;
|
||||
use webgpu::wgpu::command as wgpu_com;
|
||||
|
@ -58,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()),
|
||||
|
@ -77,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,
|
||||
)
|
||||
|
@ -116,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
|
||||
|
@ -135,55 +143,6 @@ impl GPUCommandEncoderMethods for GPUCommandEncoder {
|
|||
GPUCommandEncoderState::Open,
|
||||
);
|
||||
|
||||
let colors = descriptor
|
||||
.colorAttachments
|
||||
.iter()
|
||||
.map(|color| {
|
||||
let (load_op, clear_value) = match color.loadValue {
|
||||
GPUColorLoad::GPULoadOp(_) => (wgpu_com::LoadOp::Load, wgt::Color::TRANSPARENT),
|
||||
GPUColorLoad::DoubleSequence(ref s) => {
|
||||
let mut w = s.clone();
|
||||
if w.len() < 3 {
|
||||
w.resize(3, Finite::wrap(0.0f64));
|
||||
}
|
||||
w.resize(4, Finite::wrap(1.0f64));
|
||||
(
|
||||
wgpu_com::LoadOp::Clear,
|
||||
wgt::Color {
|
||||
r: *w[0],
|
||||
g: *w[1],
|
||||
b: *w[2],
|
||||
a: *w[3],
|
||||
},
|
||||
)
|
||||
},
|
||||
GPUColorLoad::GPUColorDict(ref d) => (
|
||||
wgpu_com::LoadOp::Clear,
|
||||
wgt::Color {
|
||||
r: *d.r,
|
||||
g: *d.g,
|
||||
b: *d.b,
|
||||
a: *d.a,
|
||||
},
|
||||
),
|
||||
};
|
||||
let channel = wgpu_com::PassChannel {
|
||||
load_op,
|
||||
store_op: match color.storeOp {
|
||||
GPUStoreOp::Store => wgpu_com::StoreOp::Store,
|
||||
GPUStoreOp::Clear => wgpu_com::StoreOp::Clear,
|
||||
},
|
||||
clear_value,
|
||||
read_only: false,
|
||||
};
|
||||
wgpu_com::ColorAttachmentDescriptor {
|
||||
attachment: color.attachment.id().0,
|
||||
resolve_target: color.resolveTarget.as_ref().map(|t| t.id().0),
|
||||
channel,
|
||||
}
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
let depth_stencil = descriptor.depthStencilAttachment.as_ref().map(|depth| {
|
||||
let (depth_load_op, clear_depth) = match depth.depthLoadValue {
|
||||
GPULoadOpOrFloat::GPULoadOp(_) => (wgpu_com::LoadOp::Load, 0.0f32),
|
||||
|
@ -219,13 +178,70 @@ impl GPUCommandEncoderMethods for GPUCommandEncoder {
|
|||
});
|
||||
|
||||
let desc = wgpu_com::RenderPassDescriptor {
|
||||
color_attachments: colors.as_slice(),
|
||||
color_attachments: Cow::Owned(
|
||||
descriptor
|
||||
.colorAttachments
|
||||
.iter()
|
||||
.map(|color| {
|
||||
let (load_op, clear_value) = match color.loadValue {
|
||||
GPUColorLoad::GPULoadOp(_) => {
|
||||
(wgpu_com::LoadOp::Load, wgt::Color::TRANSPARENT)
|
||||
},
|
||||
GPUColorLoad::DoubleSequence(ref s) => {
|
||||
let mut w = s.clone();
|
||||
if w.len() < 3 {
|
||||
w.resize(3, Finite::wrap(0.0f64));
|
||||
}
|
||||
w.resize(4, Finite::wrap(1.0f64));
|
||||
(
|
||||
wgpu_com::LoadOp::Clear,
|
||||
wgt::Color {
|
||||
r: *w[0],
|
||||
g: *w[1],
|
||||
b: *w[2],
|
||||
a: *w[3],
|
||||
},
|
||||
)
|
||||
},
|
||||
GPUColorLoad::GPUColorDict(ref d) => (
|
||||
wgpu_com::LoadOp::Clear,
|
||||
wgt::Color {
|
||||
r: *d.r,
|
||||
g: *d.g,
|
||||
b: *d.b,
|
||||
a: *d.a,
|
||||
},
|
||||
),
|
||||
};
|
||||
let channel = wgpu_com::PassChannel {
|
||||
load_op,
|
||||
store_op: match color.storeOp {
|
||||
GPUStoreOp::Store => wgpu_com::StoreOp::Store,
|
||||
GPUStoreOp::Clear => wgpu_com::StoreOp::Clear,
|
||||
},
|
||||
clear_value,
|
||||
read_only: false,
|
||||
};
|
||||
wgpu_com::ColorAttachmentDescriptor {
|
||||
attachment: color.attachment.id().0,
|
||||
resolve_target: color.resolveTarget.as_ref().map(|t| t.id().0),
|
||||
channel,
|
||||
}
|
||||
})
|
||||
.collect::<Vec<_>>(),
|
||||
),
|
||||
depth_stencil_attachment: depth_stencil.as_ref(),
|
||||
};
|
||||
|
||||
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
|
||||
|
@ -349,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 {
|
||||
|
@ -366,6 +382,7 @@ impl GPUCommandEncoderMethods for GPUCommandEncoder {
|
|||
self.channel.clone(),
|
||||
buffer,
|
||||
self.buffers.borrow_mut().drain().collect(),
|
||||
descriptor.parent.label.as_ref().cloned(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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,
|
||||
)
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
@ -57,16 +59,17 @@ use crate::dom::gputexture::GPUTexture;
|
|||
use crate::dom::promise::Promise;
|
||||
use crate::realms::InRealm;
|
||||
use crate::script_runtime::JSContext as SafeJSContext;
|
||||
use arrayvec::ArrayVec;
|
||||
use dom_struct::dom_struct;
|
||||
use js::jsapi::{Heap, JSObject};
|
||||
use std::borrow::Cow;
|
||||
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::BufferBinding;
|
||||
use webgpu::{self, wgt, WebGPU, WebGPUBindings, WebGPURequest};
|
||||
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(),
|
||||
)
|
||||
}
|
||||
|
||||
|
@ -401,6 +403,15 @@ impl GPUDeviceMethods for GPUDevice {
|
|||
}
|
||||
}
|
||||
|
||||
let desc = wgt::BindGroupLayoutDescriptor {
|
||||
label: descriptor
|
||||
.parent
|
||||
.label
|
||||
.as_ref()
|
||||
.map(|s| Cow::Owned(s.to_string())),
|
||||
entries: Cow::Owned(entries.clone()),
|
||||
};
|
||||
|
||||
let bind_group_layout_id = self
|
||||
.global()
|
||||
.wgpu_id_hub()
|
||||
|
@ -411,19 +422,18 @@ impl GPUDeviceMethods for GPUDevice {
|
|||
.send(WebGPURequest::CreateBindGroupLayout {
|
||||
device_id: self.device.0,
|
||||
bind_group_layout_id,
|
||||
entries: entries.clone(),
|
||||
scope_id,
|
||||
label: descriptor
|
||||
.parent
|
||||
.label
|
||||
.as_ref()
|
||||
.map(|s| String::from(s.as_ref())),
|
||||
descriptor: desc,
|
||||
})
|
||||
.expect("Failed to create WebGPU BindGroupLayout");
|
||||
|
||||
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()
|
||||
|
@ -437,11 +447,16 @@ impl GPUDeviceMethods for GPUDevice {
|
|||
&self,
|
||||
descriptor: &GPUPipelineLayoutDescriptor,
|
||||
) -> DomRoot<GPUPipelineLayout> {
|
||||
let mut bgl_ids = Vec::new();
|
||||
descriptor
|
||||
.bindGroupLayouts
|
||||
.iter()
|
||||
.for_each(|each| bgl_ids.push(each.id().0));
|
||||
let desc = wgt::PipelineLayoutDescriptor {
|
||||
bind_group_layouts: Cow::Owned(
|
||||
descriptor
|
||||
.bindGroupLayouts
|
||||
.iter()
|
||||
.map(|each| each.id().0)
|
||||
.collect::<Vec<_>>(),
|
||||
),
|
||||
push_constant_ranges: Cow::Owned(vec![]),
|
||||
};
|
||||
|
||||
let scope_id = self.use_current_scope();
|
||||
|
||||
|
@ -455,13 +470,17 @@ impl GPUDeviceMethods for GPUDevice {
|
|||
.send(WebGPURequest::CreatePipelineLayout {
|
||||
device_id: self.device.0,
|
||||
pipeline_layout_id,
|
||||
bind_group_layouts: bgl_ids,
|
||||
descriptor: desc,
|
||||
scope_id,
|
||||
})
|
||||
.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
|
||||
|
@ -469,26 +488,36 @@ impl GPUDeviceMethods for GPUDevice {
|
|||
let entries = descriptor
|
||||
.entries
|
||||
.iter()
|
||||
.map(|bind| {
|
||||
(
|
||||
bind.binding,
|
||||
match bind.resource {
|
||||
GPUBindingResource::GPUSampler(ref s) => WebGPUBindings::Sampler(s.id().0),
|
||||
GPUBindingResource::GPUTextureView(ref t) => {
|
||||
WebGPUBindings::TextureView(t.id().0)
|
||||
},
|
||||
GPUBindingResource::GPUBufferBindings(ref b) => {
|
||||
WebGPUBindings::Buffer(BufferBinding {
|
||||
buffer_id: b.buffer.id().0,
|
||||
offset: b.offset,
|
||||
size: b.size.and_then(wgt::BufferSize::new),
|
||||
})
|
||||
},
|
||||
.map(|bind| wgpu_bind::BindGroupEntry {
|
||||
binding: bind.binding,
|
||||
resource: match bind.resource {
|
||||
GPUBindingResource::GPUSampler(ref s) => {
|
||||
wgpu_bind::BindingResource::Sampler(s.id().0)
|
||||
},
|
||||
)
|
||||
GPUBindingResource::GPUTextureView(ref t) => {
|
||||
wgpu_bind::BindingResource::TextureView(t.id().0)
|
||||
},
|
||||
GPUBindingResource::GPUBufferBindings(ref b) => {
|
||||
wgpu_bind::BindingResource::Buffer(wgpu_bind::BufferBinding {
|
||||
buffer_id: b.buffer.id().0,
|
||||
offset: b.offset,
|
||||
size: b.size.and_then(wgt::BufferSize::new),
|
||||
})
|
||||
},
|
||||
},
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
let desc = wgpu_bind::BindGroupDescriptor {
|
||||
label: descriptor
|
||||
.parent
|
||||
.label
|
||||
.as_ref()
|
||||
.map(|l| Cow::Owned(l.to_string())),
|
||||
layout: descriptor.layout.id().0,
|
||||
entries: Cow::Owned(entries),
|
||||
};
|
||||
|
||||
let scope_id = self.use_current_scope();
|
||||
|
||||
let bind_group_id = self
|
||||
|
@ -501,20 +530,20 @@ impl GPUDeviceMethods for GPUDevice {
|
|||
.send(WebGPURequest::CreateBindGroup {
|
||||
device_id: self.device.0,
|
||||
bind_group_id,
|
||||
bind_group_layout_id: descriptor.layout.id().0,
|
||||
entries,
|
||||
descriptor: desc,
|
||||
scope_id,
|
||||
label: descriptor
|
||||
.parent
|
||||
.label
|
||||
.as_ref()
|
||||
.map(|s| String::from(s.as_ref())),
|
||||
})
|
||||
.expect("Failed to create WebGPU BindGroup");
|
||||
|
||||
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
|
||||
|
@ -543,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
|
||||
|
@ -551,9 +584,6 @@ impl GPUDeviceMethods for GPUDevice {
|
|||
&self,
|
||||
descriptor: &GPUComputePipelineDescriptor,
|
||||
) -> DomRoot<GPUComputePipeline> {
|
||||
let pipeline = descriptor.parent.layout.id();
|
||||
let program = descriptor.computeStage.module.id();
|
||||
let entry_point = descriptor.computeStage.entryPoint.to_string();
|
||||
let compute_pipeline_id = self
|
||||
.global()
|
||||
.wgpu_id_hub()
|
||||
|
@ -562,20 +592,30 @@ impl GPUDeviceMethods for GPUDevice {
|
|||
|
||||
let scope_id = self.use_current_scope();
|
||||
|
||||
let desc = wgpu_pipe::ComputePipelineDescriptor {
|
||||
layout: descriptor.parent.layout.id().0,
|
||||
compute_stage: wgpu_pipe::ProgrammableStageDescriptor {
|
||||
module: descriptor.computeStage.module.id().0,
|
||||
entry_point: Cow::Owned(descriptor.computeStage.entryPoint.to_string()),
|
||||
},
|
||||
};
|
||||
|
||||
self.channel
|
||||
.0
|
||||
.send(WebGPURequest::CreateComputePipeline {
|
||||
device_id: self.device.0,
|
||||
scope_id,
|
||||
compute_pipeline_id,
|
||||
pipeline_layout_id: pipeline.0,
|
||||
program_id: program.0,
|
||||
entry_point,
|
||||
descriptor: desc,
|
||||
})
|
||||
.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
|
||||
|
@ -593,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");
|
||||
|
||||
|
@ -609,6 +645,7 @@ impl GPUDeviceMethods for GPUDevice {
|
|||
self.device,
|
||||
encoder,
|
||||
true,
|
||||
descriptor.parent.label.as_ref().cloned(),
|
||||
)
|
||||
}
|
||||
|
||||
|
@ -616,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,
|
||||
|
@ -664,6 +697,7 @@ impl GPUDeviceMethods for GPUDevice {
|
|||
descriptor.dimension,
|
||||
descriptor.format,
|
||||
descriptor.usage,
|
||||
descriptor.parent.label.as_ref().cloned(),
|
||||
)
|
||||
}
|
||||
|
||||
|
@ -676,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),
|
||||
|
@ -704,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
|
||||
|
@ -712,104 +748,113 @@ impl GPUDeviceMethods for GPUDevice {
|
|||
&self,
|
||||
descriptor: &GPURenderPipelineDescriptor,
|
||||
) -> DomRoot<GPURenderPipeline> {
|
||||
let vertex_module = descriptor.vertexStage.module.id().0;
|
||||
let vertex_entry_point = descriptor.vertexStage.entryPoint.to_string();
|
||||
let (fragment_module, fragment_entry_point) = match descriptor.fragmentStage {
|
||||
Some(ref frag) => (Some(frag.module.id().0), Some(frag.entryPoint.to_string())),
|
||||
None => (None, None),
|
||||
};
|
||||
|
||||
let primitive_topology = match descriptor.primitiveTopology {
|
||||
GPUPrimitiveTopology::Point_list => wgt::PrimitiveTopology::PointList,
|
||||
GPUPrimitiveTopology::Line_list => wgt::PrimitiveTopology::LineList,
|
||||
GPUPrimitiveTopology::Line_strip => wgt::PrimitiveTopology::LineStrip,
|
||||
GPUPrimitiveTopology::Triangle_list => wgt::PrimitiveTopology::TriangleList,
|
||||
GPUPrimitiveTopology::Triangle_strip => wgt::PrimitiveTopology::TriangleStrip,
|
||||
};
|
||||
|
||||
let ref rs_desc = descriptor.rasterizationState;
|
||||
let rasterization_state = wgt::RasterizationStateDescriptor {
|
||||
front_face: match rs_desc.frontFace {
|
||||
GPUFrontFace::Ccw => wgt::FrontFace::Ccw,
|
||||
GPUFrontFace::Cw => wgt::FrontFace::Cw,
|
||||
},
|
||||
cull_mode: match rs_desc.cullMode {
|
||||
GPUCullMode::None => wgt::CullMode::None,
|
||||
GPUCullMode::Front => wgt::CullMode::Front,
|
||||
GPUCullMode::Back => wgt::CullMode::Back,
|
||||
},
|
||||
depth_bias: rs_desc.depthBias,
|
||||
depth_bias_slope_scale: *rs_desc.depthBiasSlopeScale,
|
||||
depth_bias_clamp: *rs_desc.depthBiasClamp,
|
||||
};
|
||||
|
||||
let color_states = descriptor
|
||||
.colorStates
|
||||
.iter()
|
||||
.map(|state| wgt::ColorStateDescriptor {
|
||||
format: convert_texture_format(state.format),
|
||||
alpha_blend: convert_blend_descriptor(&state.alphaBlend),
|
||||
color_blend: convert_blend_descriptor(&state.colorBlend),
|
||||
write_mask: match wgt::ColorWrite::from_bits(state.writeMask) {
|
||||
Some(mask) => mask,
|
||||
None => wgt::ColorWrite::empty(),
|
||||
},
|
||||
})
|
||||
.collect::<ArrayVec<_>>();
|
||||
|
||||
let depth_stencil_state = if let Some(ref dss_desc) = descriptor.depthStencilState {
|
||||
Some(wgt::DepthStencilStateDescriptor {
|
||||
format: convert_texture_format(dss_desc.format),
|
||||
depth_write_enabled: dss_desc.depthWriteEnabled,
|
||||
depth_compare: convert_compare_function(dss_desc.depthCompare),
|
||||
stencil_front: wgt::StencilStateFaceDescriptor {
|
||||
compare: convert_compare_function(dss_desc.stencilFront.compare),
|
||||
fail_op: convert_stencil_op(dss_desc.stencilFront.failOp),
|
||||
depth_fail_op: convert_stencil_op(dss_desc.stencilFront.depthFailOp),
|
||||
pass_op: convert_stencil_op(dss_desc.stencilFront.passOp),
|
||||
},
|
||||
stencil_back: wgt::StencilStateFaceDescriptor {
|
||||
compare: convert_compare_function(dss_desc.stencilBack.compare),
|
||||
fail_op: convert_stencil_op(dss_desc.stencilBack.failOp),
|
||||
depth_fail_op: convert_stencil_op(dss_desc.stencilBack.depthFailOp),
|
||||
pass_op: convert_stencil_op(dss_desc.stencilBack.passOp),
|
||||
},
|
||||
stencil_read_mask: dss_desc.stencilReadMask,
|
||||
stencil_write_mask: dss_desc.stencilWriteMask,
|
||||
})
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let ref vs_desc = descriptor.vertexState;
|
||||
let vertex_state = (
|
||||
match vs_desc.indexFormat {
|
||||
GPUIndexFormat::Uint16 => wgt::IndexFormat::Uint16,
|
||||
GPUIndexFormat::Uint32 => wgt::IndexFormat::Uint32,
|
||||
|
||||
let desc = wgpu_pipe::RenderPipelineDescriptor {
|
||||
layout: descriptor.parent.layout.id().0,
|
||||
vertex_stage: wgpu_pipe::ProgrammableStageDescriptor {
|
||||
module: descriptor.vertexStage.module.id().0,
|
||||
entry_point: Cow::Owned(descriptor.vertexStage.entryPoint.to_string()),
|
||||
},
|
||||
vs_desc
|
||||
.vertexBuffers
|
||||
.iter()
|
||||
.map(|buffer| {
|
||||
(
|
||||
buffer.arrayStride,
|
||||
match buffer.stepMode {
|
||||
GPUInputStepMode::Vertex => wgt::InputStepMode::Vertex,
|
||||
GPUInputStepMode::Instance => wgt::InputStepMode::Instance,
|
||||
fragment_stage: descriptor.fragmentStage.as_ref().map(|stage| {
|
||||
wgpu_pipe::ProgrammableStageDescriptor {
|
||||
module: stage.module.id().0,
|
||||
entry_point: Cow::Owned(stage.entryPoint.to_string()),
|
||||
}
|
||||
}),
|
||||
rasterization_state: Some(wgt::RasterizationStateDescriptor {
|
||||
front_face: match rs_desc.frontFace {
|
||||
GPUFrontFace::Ccw => wgt::FrontFace::Ccw,
|
||||
GPUFrontFace::Cw => wgt::FrontFace::Cw,
|
||||
},
|
||||
cull_mode: match rs_desc.cullMode {
|
||||
GPUCullMode::None => wgt::CullMode::None,
|
||||
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,
|
||||
}),
|
||||
primitive_topology: match descriptor.primitiveTopology {
|
||||
GPUPrimitiveTopology::Point_list => wgt::PrimitiveTopology::PointList,
|
||||
GPUPrimitiveTopology::Line_list => wgt::PrimitiveTopology::LineList,
|
||||
GPUPrimitiveTopology::Line_strip => wgt::PrimitiveTopology::LineStrip,
|
||||
GPUPrimitiveTopology::Triangle_list => wgt::PrimitiveTopology::TriangleList,
|
||||
GPUPrimitiveTopology::Triangle_strip => wgt::PrimitiveTopology::TriangleStrip,
|
||||
},
|
||||
color_states: Cow::Owned(
|
||||
descriptor
|
||||
.colorStates
|
||||
.iter()
|
||||
.map(|state| wgt::ColorStateDescriptor {
|
||||
format: convert_texture_format(state.format),
|
||||
alpha_blend: convert_blend_descriptor(&state.alphaBlend),
|
||||
color_blend: convert_blend_descriptor(&state.colorBlend),
|
||||
write_mask: match wgt::ColorWrite::from_bits(state.writeMask) {
|
||||
Some(mask) => mask,
|
||||
None => wgt::ColorWrite::empty(),
|
||||
},
|
||||
buffer
|
||||
.attributes
|
||||
.iter()
|
||||
.map(|att| wgt::VertexAttributeDescriptor {
|
||||
format: convert_vertex_format(att.format),
|
||||
offset: att.offset,
|
||||
shader_location: att.shaderLocation,
|
||||
})
|
||||
.collect::<Vec<_>>(),
|
||||
)
|
||||
})
|
||||
.collect::<Vec<_>>(),
|
||||
);
|
||||
})
|
||||
.collect::<Vec<_>>(),
|
||||
),
|
||||
depth_stencil_state: descriptor.depthStencilState.as_ref().map(|dss_desc| {
|
||||
wgt::DepthStencilStateDescriptor {
|
||||
format: convert_texture_format(dss_desc.format),
|
||||
depth_write_enabled: dss_desc.depthWriteEnabled,
|
||||
depth_compare: convert_compare_function(dss_desc.depthCompare),
|
||||
stencil_front: wgt::StencilStateFaceDescriptor {
|
||||
compare: convert_compare_function(dss_desc.stencilFront.compare),
|
||||
fail_op: convert_stencil_op(dss_desc.stencilFront.failOp),
|
||||
depth_fail_op: convert_stencil_op(dss_desc.stencilFront.depthFailOp),
|
||||
pass_op: convert_stencil_op(dss_desc.stencilFront.passOp),
|
||||
},
|
||||
stencil_back: wgt::StencilStateFaceDescriptor {
|
||||
compare: convert_compare_function(dss_desc.stencilBack.compare),
|
||||
fail_op: convert_stencil_op(dss_desc.stencilBack.failOp),
|
||||
depth_fail_op: convert_stencil_op(dss_desc.stencilBack.depthFailOp),
|
||||
pass_op: convert_stencil_op(dss_desc.stencilBack.passOp),
|
||||
},
|
||||
stencil_read_mask: dss_desc.stencilReadMask,
|
||||
stencil_write_mask: dss_desc.stencilWriteMask,
|
||||
}
|
||||
}),
|
||||
vertex_state: wgt::VertexStateDescriptor {
|
||||
index_format: match vs_desc.indexFormat {
|
||||
GPUIndexFormat::Uint16 => wgt::IndexFormat::Uint16,
|
||||
GPUIndexFormat::Uint32 => wgt::IndexFormat::Uint32,
|
||||
},
|
||||
vertex_buffers: Cow::Owned(
|
||||
vs_desc
|
||||
.vertexBuffers
|
||||
.iter()
|
||||
.map(|buffer| wgt::VertexBufferDescriptor {
|
||||
stride: buffer.arrayStride,
|
||||
step_mode: match buffer.stepMode {
|
||||
GPUInputStepMode::Vertex => wgt::InputStepMode::Vertex,
|
||||
GPUInputStepMode::Instance => wgt::InputStepMode::Instance,
|
||||
},
|
||||
attributes: Cow::Owned(
|
||||
buffer
|
||||
.attributes
|
||||
.iter()
|
||||
.map(|att| wgt::VertexAttributeDescriptor {
|
||||
format: convert_vertex_format(att.format),
|
||||
offset: att.offset,
|
||||
shader_location: att.shaderLocation,
|
||||
})
|
||||
.collect::<Vec<_>>(),
|
||||
),
|
||||
})
|
||||
.collect::<Vec<_>>(),
|
||||
),
|
||||
},
|
||||
sample_count: descriptor.sampleCount,
|
||||
sample_mask: descriptor.sampleMask,
|
||||
alpha_to_coverage_enabled: descriptor.alphaToCoverageEnabled,
|
||||
};
|
||||
|
||||
let render_pipeline_id = self
|
||||
.global()
|
||||
|
@ -825,25 +870,54 @@ impl GPUDeviceMethods for GPUDevice {
|
|||
device_id: self.device.0,
|
||||
render_pipeline_id,
|
||||
scope_id,
|
||||
pipeline_layout_id: descriptor.parent.layout.id().0,
|
||||
vertex_module,
|
||||
vertex_entry_point,
|
||||
fragment_module,
|
||||
fragment_entry_point,
|
||||
primitive_topology,
|
||||
rasterization_state,
|
||||
color_states,
|
||||
depth_stencil_state,
|
||||
vertex_state,
|
||||
sample_count: descriptor.sampleCount,
|
||||
sample_mask: descriptor.sampleMask,
|
||||
alpha_to_coverage_enabled: descriptor.alphaToCoverageEnabled,
|
||||
descriptor: desc,
|
||||
})
|
||||
.expect("Failed to create WebGPU render pipeline");
|
||||
|
||||
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
|
||||
|
|
|
@ -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
75
components/script/dom/gpurenderbundle.rs
Normal 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
213
components/script/dom/gpurenderbundleencoder.rs
Normal 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(),
|
||||
)
|
||||
}
|
||||
}
|
|
@ -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(),
|
||||
)
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
)
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
)
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
)
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
)
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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,
|
||||
)
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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
12
components/script/dom/webidls/GPURenderBundle.webidl
Normal 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
18
components/script/dom/webidls/GPURenderBundleEncoder.webidl
Normal 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;
|
||||
};
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue