dom/webgpu/Device.h

   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 #ifndef GPU_DEVICE_H_
   7 #define GPU_DEVICE_H_
   8
   9 #include "ObjectModel.h"
  10 #include "nsTHashSet.h"
  11 #include "mozilla/MozPromise.h"
  12 #include "mozilla/RefPtr.h"
  13 #include "mozilla/WeakPtr.h"
  14 #include "mozilla/webgpu/WebGPUTypes.h"
  15 #include "mozilla/webgpu/PWebGPUTypes.h"
  16 #include "mozilla/webrender/WebRenderAPI.h"
  17 #include "mozilla/DOMEventTargetHelper.h"
  18
  19 namespace mozilla {
  20 namespace dom {
  21 struct GPUExtensions;
  22 struct GPUFeatures;
  23 struct GPULimits;
  24 struct GPUExtent3DDict;
  25
  26 struct GPUBufferDescriptor;
  27 struct GPUTextureDescriptor;
  28 struct GPUSamplerDescriptor;
  29 struct GPUBindGroupLayoutDescriptor;
  30 struct GPUPipelineLayoutDescriptor;
  31 struct GPUBindGroupDescriptor;
  32 struct GPUBlendStateDescriptor;
  33 struct GPUDepthStencilStateDescriptor;
  34 struct GPUInputStateDescriptor;
  35 struct GPUShaderModuleDescriptor;
  36 struct GPUAttachmentStateDescriptor;
  37 struct GPUComputePipelineDescriptor;
  38 struct GPURenderBundleEncoderDescriptor;
  39 struct GPURenderPipelineDescriptor;
  40 struct GPUCommandEncoderDescriptor;
  41 struct GPUCanvasConfiguration;
  42
  43 class EventHandlerNonNull;
  44 class Promise;
  45 template <typename T>
  46 class Sequence;
  47 class GPUBufferOrGPUTexture;
  48 enum class GPUDeviceLostReason : uint8_t;
  49 enum class GPUErrorFilter : uint8_t;
  50 enum class GPUFeatureName : uint8_t;
  51 class GPULogCallback;
  52 }  // namespace dom
  53 namespace ipc {
  54 enum class ResponseRejectReason;
  55 }  // namespace ipc
  56
  57 namespace webgpu {
  58 namespace ffi {
  59 struct WGPULimits;
  60 }
  61 class Adapter;
  62 class BindGroup;
  63 class BindGroupLayout;
  64 class Buffer;
  65 class CommandEncoder;
  66 class ComputePipeline;
  67 class Fence;
  68 class InputState;
  69 class PipelineLayout;
  70 class Queue;
  71 class RenderBundleEncoder;
  72 class RenderPipeline;
  73 class Sampler;
  74 class ShaderModule;
  75 class SupportedFeatures;
  76 class SupportedLimits;
  77 class Texture;
  78 class WebGPUChild;
  79
  80 using MappingPromise =
  81     MozPromise<BufferMapResult, ipc::ResponseRejectReason, true>;
  82
  83 class Device final : public DOMEventTargetHelper, public SupportsWeakPtr {
  84  public:
  85   NS_DECL_ISUPPORTS_INHERITED
  86   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(Device, DOMEventTargetHelper)
  87   GPU_DECL_JS_WRAP(Device)
  88
  89   const RawId mId;
  90   RefPtr<SupportedFeatures> mFeatures;
  91   RefPtr<SupportedLimits> mLimits;
  92
  93   static CheckedInt<uint32_t> BufferStrideWithMask(
  94       const gfx::IntSize& aSize, const gfx::SurfaceFormat& aFormat);
  95
  96   explicit Device(Adapter* const aParent, RawId aId, const ffi::WGPULimits&);
  97
  98   RefPtr<WebGPUChild> GetBridge();
  99   already_AddRefed<Texture> InitSwapChain(
 100       const dom::GPUCanvasConfiguration* const aConfig,
 101       const layers::RemoteTextureOwnerId aOwnerId,
 102       bool aUseExternalTextureInSwapChain, gfx::SurfaceFormat aFormat,
 103       gfx::IntSize aCanvasSize);
 104   bool CheckNewWarning(const nsACString& aMessage);
 105
 106   void CleanupUnregisteredInParent();
 107
 108   void GenerateValidationError(const nsCString& aMessage);
 109   void TrackBuffer(Buffer* aBuffer);
 110   void UntrackBuffer(Buffer* aBuffer);
 111
 112   bool IsLost() const;
 113   bool IsBridgeAlive() const;
 114
 115   RawId GetId() const { return mId; }
 116
 117  private:
 118   ~Device();
 119   void Cleanup();
 120
 121   RefPtr<WebGPUChild> mBridge;
 122   bool mValid = true;
 123   nsString mLabel;
 124   RefPtr<dom::Promise> mLostPromise;
 125   RefPtr<Queue> mQueue;
 126   nsTHashSet<nsCString> mKnownWarnings;
 127   nsTHashSet<Buffer*> mTrackedBuffers;
 128
 129  public:
 130   void GetLabel(nsAString& aValue) const;
 131   void SetLabel(const nsAString& aLabel);
 132   dom::Promise* GetLost(ErrorResult& aRv);
 133   void ResolveLost(Maybe<dom::GPUDeviceLostReason> aReason,
 134                    const nsAString& aMessage);
 135
 136   const RefPtr<SupportedFeatures>& Features() const { return mFeatures; }
 137   const RefPtr<SupportedLimits>& Limits() const { return mLimits; }
 138   const RefPtr<Queue>& GetQueue() const { return mQueue; }
 139
 140   already_AddRefed<Buffer> CreateBuffer(const dom::GPUBufferDescriptor& aDesc,
 141                                         ErrorResult& aRv);
 142
 143   already_AddRefed<Texture> CreateTextureForSwapChain(
 144       const dom::GPUCanvasConfiguration* const aConfig,
 145       const gfx::IntSize& aCanvasSize,
 146       const layers::RemoteTextureOwnerId aOwnerId);
 147   already_AddRefed<Texture> CreateTexture(
 148       const dom::GPUTextureDescriptor& aDesc);
 149   already_AddRefed<Texture> CreateTexture(
 150       const dom::GPUTextureDescriptor& aDesc,
 151       Maybe<layers::RemoteTextureOwnerId> aOwnerId);
 152   already_AddRefed<Sampler> CreateSampler(
 153       const dom::GPUSamplerDescriptor& aDesc);
 154
 155   already_AddRefed<CommandEncoder> CreateCommandEncoder(
 156       const dom::GPUCommandEncoderDescriptor& aDesc);
 157   already_AddRefed<RenderBundleEncoder> CreateRenderBundleEncoder(
 158       const dom::GPURenderBundleEncoderDescriptor& aDesc);
 159
 160   already_AddRefed<BindGroupLayout> CreateBindGroupLayout(
 161       const dom::GPUBindGroupLayoutDescriptor& aDesc);
 162   already_AddRefed<PipelineLayout> CreatePipelineLayout(
 163       const dom::GPUPipelineLayoutDescriptor& aDesc);
 164   already_AddRefed<BindGroup> CreateBindGroup(
 165       const dom::GPUBindGroupDescriptor& aDesc);
 166
 167   MOZ_CAN_RUN_SCRIPT already_AddRefed<ShaderModule> CreateShaderModule(
 168       JSContext* aCx, const dom::GPUShaderModuleDescriptor& aDesc,
 169       ErrorResult& aRv);
 170   already_AddRefed<ComputePipeline> CreateComputePipeline(
 171       const dom::GPUComputePipelineDescriptor& aDesc);
 172   already_AddRefed<RenderPipeline> CreateRenderPipeline(
 173       const dom::GPURenderPipelineDescriptor& aDesc);
 174   already_AddRefed<dom::Promise> CreateComputePipelineAsync(
 175       const dom::GPUComputePipelineDescriptor& aDesc, ErrorResult& aRv);
 176   already_AddRefed<dom::Promise> CreateRenderPipelineAsync(
 177       const dom::GPURenderPipelineDescriptor& aDesc, ErrorResult& aRv);
 178
 179   void PushErrorScope(const dom::GPUErrorFilter& aFilter);
 180   already_AddRefed<dom::Promise> PopErrorScope(ErrorResult& aRv);
 181
 182   void Destroy();
 183
 184   IMPL_EVENT_HANDLER(uncapturederror)
 185 };
 186
 187 }  // namespace webgpu
 188 }  // namespace mozilla
 189
 190 #endif  // GPU_DEVICE_H_