Auto merge of #26769 - kunalmohan:gpu-render-pass, r=kvark

Implement GPURenderPassEncoder

Add webidls for GPURenderPassEncoder and  GPURenderEncoderBase and
implement relevant methods.

<!-- Please describe your changes on the following line: -->
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
- [ ] These changes fix #___ (GitHub issue number if applicable)

<!-- Either: -->
- [ ] There are tests for these changes OR
- [ ] These changes do not require tests because ___

<!-- 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. -->

components/script/dom/gpuadapter.rs

@@ -39,8 +39,8 @@ impl GPUAdapter {
         name: DOMString,
         extensions: Heap<*mut JSObject>,
         adapter: WebGPUAdapter,
-    ) -> GPUAdapter {
-        GPUAdapter {
+    ) -> Self {
+        Self {
             reflector_: Reflector::new(),
             channel,
             name,
@@ -55,7 +55,7 @@ impl GPUAdapter {
         name: DOMString,
         extensions: Heap<*mut JSObject>,
         adapter: WebGPUAdapter,
-    ) -> DomRoot<GPUAdapter> {
+    ) -> DomRoot<Self> {
         reflect_dom_object(
             Box::new(GPUAdapter::new_inherited(
                 channel, name, extensions, adapter,
@@ -81,9 +81,7 @@ impl GPUAdapterMethods for GPUAdapter {
         let promise = Promise::new_in_current_realm(&self.global(), comp);
         let sender = response_async(&promise, self);
         let desc = wgt::DeviceDescriptor {
-            extensions: wgt::Extensions {
-                anisotropic_filtering: descriptor.extensions.anisotropicFiltering,
-            },
+            extensions: wgt::Extensions::empty(),
             limits: wgt::Limits {
                 max_bind_groups: descriptor.limits.maxBindGroups,
             },

components/script/dom/gpubindgroup.rs

@@ -21,7 +21,7 @@ pub struct GPUBindGroup {
 }
 
 impl GPUBindGroup {
-    fn new_inherited(bind_group: WebGPUBindGroup, valid: bool) -> GPUBindGroup {
+    fn new_inherited(bind_group: WebGPUBindGroup, valid: bool) -> Self {
         Self {
             reflector_: Reflector::new(),
             label: DomRefCell::new(None),
@@ -30,11 +30,7 @@ impl GPUBindGroup {
         }
     }
 
-    pub fn new(
-        global: &GlobalScope,
-        bind_group: WebGPUBindGroup,
-        valid: bool,
-    ) -> DomRoot<GPUBindGroup> {
+    pub fn new(global: &GlobalScope, bind_group: WebGPUBindGroup, valid: bool) -> DomRoot<Self> {
         reflect_dom_object(
             Box::new(GPUBindGroup::new_inherited(bind_group, valid)),
             global,

components/script/dom/gpubindgrouplayout.rs

@@ -32,7 +32,7 @@ impl GPUBindGroupLayout {
         bind_group_layout: WebGPUBindGroupLayout,
         bindings: Vec<GPUBindGroupLayoutEntry>,
         valid: bool,
-    ) -> GPUBindGroupLayout {
+    ) -> Self {
         Self {
             reflector_: Reflector::new(),
             channel,
@@ -49,7 +49,7 @@ impl GPUBindGroupLayout {
         bind_group_layout: WebGPUBindGroupLayout,
         bindings: Vec<GPUBindGroupLayoutEntry>,
         valid: bool,
-    ) -> DomRoot<GPUBindGroupLayout> {
+    ) -> DomRoot<Self> {
         reflect_dom_object(
             Box::new(GPUBindGroupLayout::new_inherited(
                 channel,

components/script/dom/gpubuffer.rs

@@ -57,7 +57,7 @@ impl GPUBuffer {
         usage: u32,
         valid: bool,
         mapping: RootedTraceableBox<Heap<*mut JSObject>>,
-    ) -> GPUBuffer {
+    ) -> Self {
         Self {
             reflector_: Reflector::new(),
             channel,
@@ -83,7 +83,7 @@ impl GPUBuffer {
         usage: u32,
         valid: bool,
         mapping: RootedTraceableBox<Heap<*mut JSObject>>,
-    ) -> DomRoot<GPUBuffer> {
+    ) -> DomRoot<Self> {
         reflect_dom_object(
             Box::new(GPUBuffer::new_inherited(
                 channel, buffer, device, state, size, usage, valid, mapping,

components/script/dom/gpucommandbuffer.rs

@@ -37,8 +37,8 @@ impl GPUCommandBuffer {
         channel: WebGPU,
         command_buffer: WebGPUCommandBuffer,
         buffers: HashSet<DomRoot<GPUBuffer>>,
-    ) -> GPUCommandBuffer {
-        GPUCommandBuffer {
+    ) -> Self {
+        Self {
             channel,
             reflector_: Reflector::new(),
             label: DomRefCell::new(None),
@@ -52,7 +52,7 @@ impl GPUCommandBuffer {
         channel: WebGPU,
         command_buffer: WebGPUCommandBuffer,
         buffers: HashSet<DomRoot<GPUBuffer>>,
-    ) -> DomRoot<GPUCommandBuffer> {
+    ) -> DomRoot<Self> {
         reflect_dom_object(
             Box::new(GPUCommandBuffer::new_inherited(
                 channel,

components/script/dom/gpucommandencoder.rs

@@ -6,6 +6,10 @@ use crate::dom::bindings::cell::DomRefCell;
 use crate::dom::bindings::codegen::Bindings::GPUBufferBinding::GPUSize64;
 use crate::dom::bindings::codegen::Bindings::GPUCommandEncoderBinding::{
     GPUCommandBufferDescriptor, GPUCommandEncoderMethods, GPUComputePassDescriptor,
+    GPURenderPassDescriptor, GPUStencilLoadValue, GPUStoreOp,
+};
+use crate::dom::bindings::codegen::UnionTypes::{
+    GPULoadOpOrDoubleSequenceOrGPUColorDict as GPUColorLoad, GPULoadOpOrFloat,
 };
 use crate::dom::bindings::reflector::DomObject;
 use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
@@ -15,17 +19,20 @@ use crate::dom::globalscope::GlobalScope;
 use crate::dom::gpubuffer::GPUBuffer;
 use crate::dom::gpucommandbuffer::GPUCommandBuffer;
 use crate::dom::gpucomputepassencoder::GPUComputePassEncoder;
+use crate::dom::gpurenderpassencoder::GPURenderPassEncoder;
 use dom_struct::dom_struct;
 use std::cell::Cell;
 use std::collections::HashSet;
-use webgpu::wgt::BufferUsage;
-use webgpu::{self, WebGPU, WebGPURequest};
+use webgpu::wgpu::command::{
+    RawPass, RenderPassColorAttachmentDescriptor, RenderPassDepthStencilAttachmentDescriptor,
+    RenderPassDescriptor,
+};
+use webgpu::{self, wgt, WebGPU, WebGPUDevice, WebGPURequest};
 
 const BUFFER_COPY_ALIGN_MASK: u64 = 3;
 
 // https://gpuweb.github.io/gpuweb/#enumdef-encoder-state
 #[derive(MallocSizeOf, PartialEq)]
-#[allow(dead_code)]
 pub enum GPUCommandEncoderState {
     Open,
     EncodingRenderPass,
@@ -42,19 +49,22 @@ pub struct GPUCommandEncoder {
     encoder: webgpu::WebGPUCommandEncoder,
     buffers: DomRefCell<HashSet<DomRoot<GPUBuffer>>>,
     state: DomRefCell<GPUCommandEncoderState>,
+    device: WebGPUDevice,
     valid: Cell<bool>,
 }
 
 impl GPUCommandEncoder {
     pub fn new_inherited(
         channel: WebGPU,
+        device: WebGPUDevice,
         encoder: webgpu::WebGPUCommandEncoder,
         valid: bool,
-    ) -> GPUCommandEncoder {
-        GPUCommandEncoder {
+    ) -> Self {
+        Self {
             channel,
             reflector_: Reflector::new(),
             label: DomRefCell::new(None),
+            device,
             encoder,
             buffers: DomRefCell::new(HashSet::new()),
             state: DomRefCell::new(GPUCommandEncoderState::Open),
@@ -65,11 +75,14 @@ impl GPUCommandEncoder {
     pub fn new(
         global: &GlobalScope,
         channel: WebGPU,
+        device: WebGPUDevice,
         encoder: webgpu::WebGPUCommandEncoder,
         valid: bool,
-    ) -> DomRoot<GPUCommandEncoder> {
+    ) -> DomRoot<Self> {
         reflect_dom_object(
-            Box::new(GPUCommandEncoder::new_inherited(channel, encoder, valid)),
+            Box::new(GPUCommandEncoder::new_inherited(
+                channel, device, encoder, valid,
+            )),
             global,
         )
     }
@@ -113,6 +126,94 @@ impl GPUCommandEncoderMethods for GPUCommandEncoder {
         GPUComputePassEncoder::new(&self.global(), self.channel.clone(), &self)
     }
 
+    #[allow(unsafe_code)]
+    /// https://gpuweb.github.io/gpuweb/#dom-gpucommandencoder-beginrenderpass
+    fn BeginRenderPass(
+        &self,
+        descriptor: &GPURenderPassDescriptor,
+    ) -> DomRoot<GPURenderPassEncoder> {
+        self.set_state(
+            GPUCommandEncoderState::EncodingRenderPass,
+            GPUCommandEncoderState::Open,
+        );
+
+        let colors = descriptor
+            .colorAttachments
+            .iter()
+            .map(|color| {
+                let (load_op, clear_color) = match color.loadValue {
+                    GPUColorLoad::GPULoadOp(_) => (wgt::LoadOp::Load, wgt::Color::TRANSPARENT),
+                    GPUColorLoad::DoubleSequence(ref s) => (
+                        wgt::LoadOp::Clear,
+                        wgt::Color {
+                            r: *s[0],
+                            g: *s[1],
+                            b: *s[2],
+                            a: *s[3],
+                        },
+                    ),
+                    GPUColorLoad::GPUColorDict(ref d) => (
+                        wgt::LoadOp::Clear,
+                        wgt::Color {
+                            r: *d.r,
+                            g: *d.g,
+                            b: *d.b,
+                            a: *d.a,
+                        },
+                    ),
+                };
+                RenderPassColorAttachmentDescriptor {
+                    attachment: color.attachment.id().0,
+                    resolve_target: color.resolveTarget.as_ref().map(|t| t.id().0),
+                    load_op,
+                    store_op: match color.storeOp {
+                        GPUStoreOp::Store => wgt::StoreOp::Store,
+                        GPUStoreOp::Clear => wgt::StoreOp::Clear,
+                    },
+                    clear_color,
+                }
+            })
+            .collect::<Vec<_>>();
+
+        let depth_stencil = descriptor.depthStencilAttachment.as_ref().map(|depth| {
+            let (depth_load_op, clear_depth) = match depth.depthLoadValue {
+                GPULoadOpOrFloat::GPULoadOp(_) => (wgt::LoadOp::Load, 0.0f32),
+                GPULoadOpOrFloat::Float(f) => (wgt::LoadOp::Clear, *f),
+            };
+            let (stencil_load_op, clear_stencil) = match depth.stencilLoadValue {
+                GPUStencilLoadValue::GPULoadOp(_) => (wgt::LoadOp::Load, 0u32),
+                GPUStencilLoadValue::RangeEnforcedUnsignedLong(l) => (wgt::LoadOp::Clear, l),
+            };
+            RenderPassDepthStencilAttachmentDescriptor {
+                attachment: depth.attachment.id().0,
+                depth_load_op,
+                depth_store_op: match depth.depthStoreOp {
+                    GPUStoreOp::Store => wgt::StoreOp::Store,
+                    GPUStoreOp::Clear => wgt::StoreOp::Clear,
+                },
+                clear_depth,
+                depth_read_only: depth.depthReadOnly,
+                stencil_load_op,
+                stencil_store_op: match depth.stencilStoreOp {
+                    GPUStoreOp::Store => wgt::StoreOp::Store,
+                    GPUStoreOp::Clear => wgt::StoreOp::Clear,
+                },
+                clear_stencil,
+                stencil_read_only: depth.stencilReadOnly,
+            }
+        });
+
+        let desc = RenderPassDescriptor {
+            color_attachments: colors.as_ptr(),
+            color_attachments_length: colors.len(),
+            depth_stencil_attachment: depth_stencil.as_ref(),
+        };
+
+        let raw_pass = unsafe { RawPass::new_render(self.id().0, &desc) };
+
+        GPURenderPassEncoder::new(&self.global(), self.channel.clone(), raw_pass, &self)
+    }
+
     /// https://gpuweb.github.io/gpuweb/#dom-gpucommandencoder-copybuffertobuffer
     fn CopyBufferToBuffer(
         &self,
@@ -130,12 +231,12 @@ impl GPUCommandEncoderMethods for GPUCommandEncoder {
             Some(_) => true,
             None => false,
         };
-        valid &= match BufferUsage::from_bits(source.usage()) {
-            Some(usage) => usage.contains(BufferUsage::COPY_SRC),
+        valid &= match wgt::BufferUsage::from_bits(source.usage()) {
+            Some(usage) => usage.contains(wgt::BufferUsage::COPY_SRC),
             None => false,
         };
-        valid &= match BufferUsage::from_bits(destination.usage()) {
-            Some(usage) => usage.contains(BufferUsage::COPY_DST),
+        valid &= match wgt::BufferUsage::from_bits(destination.usage()) {
+            Some(usage) => usage.contains(wgt::BufferUsage::COPY_DST),
             None => false,
         };
         valid &= (*self.state.borrow() == GPUCommandEncoderState::Open) &&