Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 330 insertions, 0 deletions

diff --git a/dom/webgpu/RenderPassEncoder.cpp b/dom/webgpu/RenderPassEncoder.cpp
new file mode 100644
index 0000000000..9f5a311415
--- /dev/null
+++ b/dom/webgpu/RenderPassEncoder.cpp
@@ -0,0 +1,330 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "RenderPassEncoder.h"
+#include "BindGroup.h"
+#include "CommandEncoder.h"
+#include "RenderBundle.h"
+#include "RenderPipeline.h"
+#include "mozilla/webgpu/ffi/wgpu.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(RenderPassEncoder, mParent, mUsedBindGroups,
+                          mUsedBuffers, mUsedPipelines, mUsedTextureViews,
+                          mUsedRenderBundles)
+GPU_IMPL_JS_WRAP(RenderPassEncoder)
+
+ffi::WGPURenderPass* ScopedFfiRenderTraits::empty() { return nullptr; }
+
+void ScopedFfiRenderTraits::release(ffi::WGPURenderPass* raw) {
+  if (raw) {
+    ffi::wgpu_render_pass_destroy(raw);
+  }
+}
+
+static ffi::WGPULoadOp ConvertLoadOp(const dom::GPULoadOp& aOp) {
+  switch (aOp) {
+    case dom::GPULoadOp::Load:
+      return ffi::WGPULoadOp_Load;
+    case dom::GPULoadOp::Clear:
+      return ffi::WGPULoadOp_Clear;
+    case dom::GPULoadOp::EndGuard_:
+      break;
+  }
+  MOZ_CRASH("bad GPULoadOp");
+}
+
+static ffi::WGPUStoreOp ConvertStoreOp(const dom::GPUStoreOp& aOp) {
+  switch (aOp) {
+    case dom::GPUStoreOp::Store:
+      return ffi::WGPUStoreOp_Store;
+    case dom::GPUStoreOp::Discard:
+      return ffi::WGPUStoreOp_Discard;
+    case dom::GPUStoreOp::EndGuard_:
+      break;
+  }
+  MOZ_CRASH("bad GPUStoreOp");
+}
+
+static ffi::WGPUColor ConvertColor(const dom::Sequence<double>& aSeq) {
+  ffi::WGPUColor color;
+  color.r = aSeq.SafeElementAt(0, 0.0);
+  color.g = aSeq.SafeElementAt(1, 0.0);
+  color.b = aSeq.SafeElementAt(2, 0.0);
+  color.a = aSeq.SafeElementAt(3, 1.0);
+  return color;
+}
+
+static ffi::WGPUColor ConvertColor(const dom::GPUColorDict& aColor) {
+  ffi::WGPUColor color = {aColor.mR, aColor.mG, aColor.mB, aColor.mA};
+  return color;
+}
+
+static ffi::WGPUColor ConvertColor(
+    const dom::DoubleSequenceOrGPUColorDict& aColor) {
+  if (aColor.IsDoubleSequence()) {
+    return ConvertColor(aColor.GetAsDoubleSequence());
+  }
+  if (aColor.IsGPUColorDict()) {
+    return ConvertColor(aColor.GetAsGPUColorDict());
+  }
+  MOZ_ASSERT_UNREACHABLE(
+      "Unexpected dom::DoubleSequenceOrGPUColorDict variant");
+  return ffi::WGPUColor();
+}
+static ffi::WGPUColor ConvertColor(
+    const dom::OwningDoubleSequenceOrGPUColorDict& aColor) {
+  if (aColor.IsDoubleSequence()) {
+    return ConvertColor(aColor.GetAsDoubleSequence());
+  }
+  if (aColor.IsGPUColorDict()) {
+    return ConvertColor(aColor.GetAsGPUColorDict());
+  }
+  MOZ_ASSERT_UNREACHABLE(
+      "Unexpected dom::OwningDoubleSequenceOrGPUColorDict variant");
+  return ffi::WGPUColor();
+}
+
+ffi::WGPURenderPass* BeginRenderPass(
+    CommandEncoder* const aParent, const dom::GPURenderPassDescriptor& aDesc) {
+  ffi::WGPURenderPassDescriptor desc = {};
+
+  webgpu::StringHelper label(aDesc.mLabel);
+  desc.label = label.Get();
+
+  ffi::WGPURenderPassDepthStencilAttachment dsDesc = {};
+  if (aDesc.mDepthStencilAttachment.WasPassed()) {
+    const auto& dsa = aDesc.mDepthStencilAttachment.Value();
+    dsDesc.view = dsa.mView->mId;
+
+    // -
+
+    if (dsa.mDepthClearValue.WasPassed()) {
+      dsDesc.depth.clear_value = dsa.mDepthClearValue.Value();
+    }
+    if (dsa.mDepthLoadOp.WasPassed()) {
+      dsDesc.depth.load_op = ConvertLoadOp(dsa.mDepthLoadOp.Value());
+    }
+    if (dsa.mDepthStoreOp.WasPassed()) {
+      dsDesc.depth.store_op = ConvertStoreOp(dsa.mDepthStoreOp.Value());
+    }
+    dsDesc.depth.read_only = dsa.mDepthReadOnly;
+
+    // -
+
+    dsDesc.stencil.clear_value = dsa.mStencilClearValue;
+    if (dsa.mStencilLoadOp.WasPassed()) {
+      dsDesc.stencil.load_op = ConvertLoadOp(dsa.mStencilLoadOp.Value());
+    }
+    if (dsa.mStencilStoreOp.WasPassed()) {
+      dsDesc.stencil.store_op = ConvertStoreOp(dsa.mStencilStoreOp.Value());
+    }
+    dsDesc.stencil.read_only = dsa.mStencilReadOnly;
+
+    // -
+
+    desc.depth_stencil_attachment = &dsDesc;
+  }
+
+  if (aDesc.mColorAttachments.Length() > WGPUMAX_COLOR_ATTACHMENTS) {
+    aParent->GetDevice()->GenerateError(nsLiteralCString(
+        "Too many color attachments in GPURenderPassDescriptor"));
+    return nullptr;
+  }
+
+  std::array<ffi::WGPURenderPassColorAttachment, WGPUMAX_COLOR_ATTACHMENTS>
+      colorDescs = {};
+  desc.color_attachments = colorDescs.data();
+  desc.color_attachments_length = aDesc.mColorAttachments.Length();
+
+  for (size_t i = 0; i < aDesc.mColorAttachments.Length(); ++i) {
+    const auto& ca = aDesc.mColorAttachments[i];
+    ffi::WGPURenderPassColorAttachment& cd = colorDescs[i];
+    cd.view = ca.mView->mId;
+    cd.channel.store_op = ConvertStoreOp(ca.mStoreOp);
+
+    if (ca.mResolveTarget.WasPassed()) {
+      cd.resolve_target = ca.mResolveTarget.Value().mId;
+    }
+
+    cd.channel.load_op = ConvertLoadOp(ca.mLoadOp);
+    if (ca.mClearValue.WasPassed()) {
+      cd.channel.clear_value = ConvertColor(ca.mClearValue.Value());
+    }
+  }
+
+  return ffi::wgpu_command_encoder_begin_render_pass(aParent->mId, &desc);
+}
+
+RenderPassEncoder::RenderPassEncoder(CommandEncoder* const aParent,
+                                     const dom::GPURenderPassDescriptor& aDesc)
+    : ChildOf(aParent), mPass(BeginRenderPass(aParent, aDesc)) {
+  if (!mPass) {
+    mValid = false;
+    return;
+  }
+
+  for (const auto& at : aDesc.mColorAttachments) {
+    mUsedTextureViews.AppendElement(at.mView);
+  }
+  if (aDesc.mDepthStencilAttachment.WasPassed()) {
+    mUsedTextureViews.AppendElement(
+        aDesc.mDepthStencilAttachment.Value().mView);
+  }
+}
+
+RenderPassEncoder::~RenderPassEncoder() {
+  if (mValid) {
+    mValid = false;
+  }
+}
+
+void RenderPassEncoder::SetBindGroup(
+    uint32_t aSlot, const BindGroup& aBindGroup,
+    const dom::Sequence<uint32_t>& aDynamicOffsets) {
+  if (mValid) {
+    mUsedBindGroups.AppendElement(&aBindGroup);
+    ffi::wgpu_render_pass_set_bind_group(mPass, aSlot, aBindGroup.mId,
+                                         aDynamicOffsets.Elements(),
+                                         aDynamicOffsets.Length());
+  }
+}
+
+void RenderPassEncoder::SetPipeline(const RenderPipeline& aPipeline) {
+  if (mValid) {
+    mUsedPipelines.AppendElement(&aPipeline);
+    ffi::wgpu_render_pass_set_pipeline(mPass, aPipeline.mId);
+  }
+}
+
+void RenderPassEncoder::SetIndexBuffer(const Buffer& aBuffer,
+                                       const dom::GPUIndexFormat& aIndexFormat,
+                                       uint64_t aOffset, uint64_t aSize) {
+  if (mValid) {
+    mUsedBuffers.AppendElement(&aBuffer);
+    const auto iformat = aIndexFormat == dom::GPUIndexFormat::Uint32
+                             ? ffi::WGPUIndexFormat_Uint32
+                             : ffi::WGPUIndexFormat_Uint16;
+    ffi::wgpu_render_pass_set_index_buffer(mPass, aBuffer.mId, iformat, aOffset,
+                                           aSize);
+  }
+}
+
+void RenderPassEncoder::SetVertexBuffer(uint32_t aSlot, const Buffer& aBuffer,
+                                        uint64_t aOffset, uint64_t aSize) {
+  if (mValid) {
+    mUsedBuffers.AppendElement(&aBuffer);
+    ffi::wgpu_render_pass_set_vertex_buffer(mPass, aSlot, aBuffer.mId, aOffset,
+                                            aSize);
+  }
+}
+
+void RenderPassEncoder::Draw(uint32_t aVertexCount, uint32_t aInstanceCount,
+                             uint32_t aFirstVertex, uint32_t aFirstInstance) {
+  if (mValid) {
+    ffi::wgpu_render_pass_draw(mPass, aVertexCount, aInstanceCount,
+                               aFirstVertex, aFirstInstance);
+  }
+}
+
+void RenderPassEncoder::DrawIndexed(uint32_t aIndexCount,
+                                    uint32_t aInstanceCount,
+                                    uint32_t aFirstIndex, int32_t aBaseVertex,
+                                    uint32_t aFirstInstance) {
+  if (mValid) {
+    ffi::wgpu_render_pass_draw_indexed(mPass, aIndexCount, aInstanceCount,
+                                       aFirstIndex, aBaseVertex,
+                                       aFirstInstance);
+  }
+}
+
+void RenderPassEncoder::DrawIndirect(const Buffer& aIndirectBuffer,
+                                     uint64_t aIndirectOffset) {
+  if (mValid) {
+    ffi::wgpu_render_pass_draw_indirect(mPass, aIndirectBuffer.mId,
+                                        aIndirectOffset);
+  }
+}
+
+void RenderPassEncoder::DrawIndexedIndirect(const Buffer& aIndirectBuffer,
+                                            uint64_t aIndirectOffset) {
+  if (mValid) {
+    ffi::wgpu_render_pass_draw_indexed_indirect(mPass, aIndirectBuffer.mId,
+                                                aIndirectOffset);
+  }
+}
+
+void RenderPassEncoder::SetViewport(float x, float y, float width, float height,
+                                    float minDepth, float maxDepth) {
+  if (mValid) {
+    ffi::wgpu_render_pass_set_viewport(mPass, x, y, width, height, minDepth,
+                                       maxDepth);
+  }
+}
+
+void RenderPassEncoder::SetScissorRect(uint32_t x, uint32_t y, uint32_t width,
+                                       uint32_t height) {
+  if (mValid) {
+    ffi::wgpu_render_pass_set_scissor_rect(mPass, x, y, width, height);
+  }
+}
+
+void RenderPassEncoder::SetBlendConstant(
+    const dom::DoubleSequenceOrGPUColorDict& color) {
+  if (mValid) {
+    ffi::WGPUColor aColor = ConvertColor(color);
+    ffi::wgpu_render_pass_set_blend_constant(mPass, &aColor);
+  }
+}
+
+void RenderPassEncoder::SetStencilReference(uint32_t reference) {
+  if (mValid) {
+    ffi::wgpu_render_pass_set_stencil_reference(mPass, reference);
+  }
+}
+
+void RenderPassEncoder::ExecuteBundles(
+    const dom::Sequence<OwningNonNull<RenderBundle>>& aBundles) {
+  if (mValid) {
+    nsTArray<ffi::WGPURenderBundleId> renderBundles(aBundles.Length());
+    for (const auto& bundle : aBundles) {
+      mUsedRenderBundles.AppendElement(bundle);
+      renderBundles.AppendElement(bundle->mId);
+    }
+    ffi::wgpu_render_pass_execute_bundles(mPass, renderBundles.Elements(),
+                                          renderBundles.Length());
+  }
+}
+
+void RenderPassEncoder::PushDebugGroup(const nsAString& aString) {
+  if (mValid) {
+    const NS_ConvertUTF16toUTF8 utf8(aString);
+    ffi::wgpu_render_pass_push_debug_group(mPass, utf8.get(), 0);
+  }
+}
+void RenderPassEncoder::PopDebugGroup() {
+  if (mValid) {
+    ffi::wgpu_render_pass_pop_debug_group(mPass);
+  }
+}
+void RenderPassEncoder::InsertDebugMarker(const nsAString& aString) {
+  if (mValid) {
+    const NS_ConvertUTF16toUTF8 utf8(aString);
+    ffi::wgpu_render_pass_insert_debug_marker(mPass, utf8.get(), 0);
+  }
+}
+
+void RenderPassEncoder::End(ErrorResult& aRv) {
+  if (mValid) {
+    mValid = false;
+    auto* pass = mPass.forget();
+    MOZ_ASSERT(pass);
+    mParent->EndRenderPass(*pass, aRv);
+  }
+}
+
+}  // namespace mozilla::webgpu