dom/webgpu/CommandEncoder.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "mozilla/dom/WebGPUBinding.h"
   7 #include "CommandEncoder.h"
   8
   9 #include "CommandBuffer.h"
  10 #include "Buffer.h"
  11 #include "ComputePassEncoder.h"
  12 #include "Device.h"
  13 #include "RenderPassEncoder.h"
  14 #include "Utility.h"
  15 #include "mozilla/webgpu/CanvasContext.h"
  16 #include "mozilla/webgpu/ffi/wgpu.h"
  17 #include "ipc/WebGPUChild.h"
  18
  19 namespace mozilla::webgpu {
  20
  21 GPU_IMPL_CYCLE_COLLECTION(CommandEncoder, mParent, mBridge)
  22 GPU_IMPL_JS_WRAP(CommandEncoder)
  23
  24 void CommandEncoder::ConvertTextureDataLayoutToFFI(
  25     const dom::GPUImageDataLayout& aLayout,
  26     ffi::WGPUImageDataLayout* aLayoutFFI) {
  27   *aLayoutFFI = {};
  28   aLayoutFFI->offset = aLayout.mOffset;
  29
  30   if (aLayout.mBytesPerRow.WasPassed()) {
  31     aLayoutFFI->bytes_per_row = &aLayout.mBytesPerRow.Value();
  32   } else {
  33     aLayoutFFI->bytes_per_row = nullptr;
  34   }
  35
  36   if (aLayout.mRowsPerImage.WasPassed()) {
  37     aLayoutFFI->rows_per_image = &aLayout.mRowsPerImage.Value();
  38   } else {
  39     aLayoutFFI->rows_per_image = nullptr;
  40   }
  41 }
  42
  43 void CommandEncoder::ConvertTextureCopyViewToFFI(
  44     const dom::GPUImageCopyTexture& aCopy,
  45     ffi::WGPUImageCopyTexture* aViewFFI) {
  46   *aViewFFI = {};
  47   aViewFFI->texture = aCopy.mTexture->mId;
  48   aViewFFI->mip_level = aCopy.mMipLevel;
  49   if (aCopy.mOrigin.WasPassed()) {
  50     const auto& origin = aCopy.mOrigin.Value();
  51     if (origin.IsRangeEnforcedUnsignedLongSequence()) {
  52       const auto& seq = origin.GetAsRangeEnforcedUnsignedLongSequence();
  53       aViewFFI->origin.x = seq.Length() > 0 ? seq[0] : 0;
  54       aViewFFI->origin.y = seq.Length() > 1 ? seq[1] : 0;
  55       aViewFFI->origin.z = seq.Length() > 2 ? seq[2] : 0;
  56     } else if (origin.IsGPUOrigin3DDict()) {
  57       const auto& dict = origin.GetAsGPUOrigin3DDict();
  58       aViewFFI->origin.x = dict.mX;
  59       aViewFFI->origin.y = dict.mY;
  60       aViewFFI->origin.z = dict.mZ;
  61     } else {
  62       MOZ_CRASH("Unexpected origin type");
  63     }
  64   }
  65 }
  66
  67 static ffi::WGPUImageCopyTexture ConvertTextureCopyView(
  68     const dom::GPUImageCopyTexture& aCopy) {
  69   ffi::WGPUImageCopyTexture view = {};
  70   CommandEncoder::ConvertTextureCopyViewToFFI(aCopy, &view);
  71   return view;
  72 }
  73
  74 CommandEncoder::CommandEncoder(Device* const aParent,
  75                                WebGPUChild* const aBridge, RawId aId)
  76     : ChildOf(aParent), mId(aId), mBridge(aBridge) {}
  77
  78 CommandEncoder::~CommandEncoder() { Cleanup(); }
  79
  80 void CommandEncoder::Cleanup() {
  81   if (mValid) {
  82     mValid = false;
  83     if (mBridge->IsOpen()) {
  84       mBridge->SendCommandEncoderDestroy(mId);
  85     }
  86   }
  87 }
  88
  89 void CommandEncoder::CopyBufferToBuffer(const Buffer& aSource,
  90                                         BufferAddress aSourceOffset,
  91                                         const Buffer& aDestination,
  92                                         BufferAddress aDestinationOffset,
  93                                         BufferAddress aSize) {
  94   if (mValid && mBridge->IsOpen()) {
  95     ipc::ByteBuf bb;
  96     ffi::wgpu_command_encoder_copy_buffer_to_buffer(
  97         aSource.mId, aSourceOffset, aDestination.mId, aDestinationOffset, aSize,
  98         ToFFI(&bb));
  99     mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(bb));
 100   }
 101 }
 102
 103 void CommandEncoder::CopyBufferToTexture(
 104     const dom::GPUImageCopyBuffer& aSource,
 105     const dom::GPUImageCopyTexture& aDestination,
 106     const dom::GPUExtent3D& aCopySize) {
 107   if (mValid && mBridge->IsOpen()) {
 108     ipc::ByteBuf bb;
 109     ffi::WGPUImageDataLayout src_layout = {};
 110     CommandEncoder::ConvertTextureDataLayoutToFFI(aSource, &src_layout);
 111     ffi::wgpu_command_encoder_copy_buffer_to_texture(
 112         aSource.mBuffer->mId, &src_layout, ConvertTextureCopyView(aDestination),
 113         ConvertExtent(aCopySize), ToFFI(&bb));
 114     mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(bb));
 115
 116     const auto& targetContext = aDestination.mTexture->mTargetContext;
 117     if (targetContext) {
 118       mTargetContexts.AppendElement(targetContext);
 119     }
 120   }
 121 }
 122 void CommandEncoder::CopyTextureToBuffer(
 123     const dom::GPUImageCopyTexture& aSource,
 124     const dom::GPUImageCopyBuffer& aDestination,
 125     const dom::GPUExtent3D& aCopySize) {
 126   if (mValid && mBridge->IsOpen()) {
 127     ipc::ByteBuf bb;
 128     ffi::WGPUImageDataLayout dstLayout = {};
 129     CommandEncoder::ConvertTextureDataLayoutToFFI(aDestination, &dstLayout);
 130     ffi::wgpu_command_encoder_copy_texture_to_buffer(
 131         ConvertTextureCopyView(aSource), aDestination.mBuffer->mId, &dstLayout,
 132         ConvertExtent(aCopySize), ToFFI(&bb));
 133     mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(bb));
 134   }
 135 }
 136 void CommandEncoder::CopyTextureToTexture(
 137     const dom::GPUImageCopyTexture& aSource,
 138     const dom::GPUImageCopyTexture& aDestination,
 139     const dom::GPUExtent3D& aCopySize) {
 140   if (mValid && mBridge->IsOpen()) {
 141     ipc::ByteBuf bb;
 142     ffi::wgpu_command_encoder_copy_texture_to_texture(
 143         ConvertTextureCopyView(aSource), ConvertTextureCopyView(aDestination),
 144         ConvertExtent(aCopySize), ToFFI(&bb));
 145     mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(bb));
 146
 147     const auto& targetContext = aDestination.mTexture->mTargetContext;
 148     if (targetContext) {
 149       mTargetContexts.AppendElement(targetContext);
 150     }
 151   }
 152 }
 153
 154 void CommandEncoder::PushDebugGroup(const nsAString& aString) {
 155   if (mValid && mBridge->IsOpen()) {
 156     ipc::ByteBuf bb;
 157     NS_ConvertUTF16toUTF8 marker(aString);
 158     ffi::wgpu_command_encoder_push_debug_group(&marker, ToFFI(&bb));
 159     mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(bb));
 160   }
 161 }
 162 void CommandEncoder::PopDebugGroup() {
 163   if (mValid && mBridge->IsOpen()) {
 164     ipc::ByteBuf bb;
 165     ffi::wgpu_command_encoder_pop_debug_group(ToFFI(&bb));
 166     mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(bb));
 167   }
 168 }
 169 void CommandEncoder::InsertDebugMarker(const nsAString& aString) {
 170   if (mValid && mBridge->IsOpen()) {
 171     ipc::ByteBuf bb;
 172     NS_ConvertUTF16toUTF8 marker(aString);
 173     ffi::wgpu_command_encoder_insert_debug_marker(&marker, ToFFI(&bb));
 174     mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(bb));
 175   }
 176 }
 177
 178 already_AddRefed<ComputePassEncoder> CommandEncoder::BeginComputePass(
 179     const dom::GPUComputePassDescriptor& aDesc) {
 180   RefPtr<ComputePassEncoder> pass = new ComputePassEncoder(this, aDesc);
 181   return pass.forget();
 182 }
 183
 184 already_AddRefed<RenderPassEncoder> CommandEncoder::BeginRenderPass(
 185     const dom::GPURenderPassDescriptor& aDesc) {
 186   for (const auto& at : aDesc.mColorAttachments) {
 187     auto* targetContext = at.mView->GetTargetContext();
 188     if (targetContext) {
 189       mTargetContexts.AppendElement(targetContext);
 190     }
 191     if (at.mResolveTarget.WasPassed()) {
 192       targetContext = at.mResolveTarget.Value().GetTargetContext();
 193       mTargetContexts.AppendElement(targetContext);
 194     }
 195   }
 196
 197   RefPtr<RenderPassEncoder> pass = new RenderPassEncoder(this, aDesc);
 198   return pass.forget();
 199 }
 200
 201 void CommandEncoder::EndComputePass(ffi::WGPUComputePass& aPass,
 202                                     ErrorResult& aRv) {
 203   if (!mValid || !mBridge->IsOpen()) {
 204     return aRv.ThrowInvalidStateError("Command encoder is not valid");
 205   }
 206
 207   ipc::ByteBuf byteBuf;
 208   ffi::wgpu_compute_pass_finish(&aPass, ToFFI(&byteBuf));
 209   mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(byteBuf));
 210 }
 211
 212 void CommandEncoder::EndRenderPass(ffi::WGPURenderPass& aPass,
 213                                    ErrorResult& aRv) {
 214   if (!mValid || !mBridge->IsOpen()) {
 215     return aRv.ThrowInvalidStateError("Command encoder is not valid");
 216   }
 217
 218   ipc::ByteBuf byteBuf;
 219   ffi::wgpu_render_pass_finish(&aPass, ToFFI(&byteBuf));
 220   mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(byteBuf));
 221 }
 222
 223 already_AddRefed<CommandBuffer> CommandEncoder::Finish(
 224     const dom::GPUCommandBufferDescriptor& aDesc) {
 225   RawId id = 0;
 226   if (mValid && mBridge->IsOpen()) {
 227     mValid = false;
 228     id = mBridge->CommandEncoderFinish(mId, mParent->mId, aDesc);
 229   }
 230   RefPtr<CommandBuffer> comb =
 231       new CommandBuffer(mParent, id, std::move(mTargetContexts));
 232   return comb.forget();
 233 }
 234
 235 }  // namespace mozilla::webgpu