kc3-lang/angle/src/libANGLE/renderer/wgpu/DisplayWgpu.h

• Show log

  Commit

• Hash : 00845fd6
  Author :
  Date : 2025-05-06T14:13:18
  

  WebGPU: Do not reuse windows with multiple surfaces
  
  Multiple Dawn backends do not handle re-creating a surface for a native
  window. Instead of working around this by caching in the display, rework
  our test runner to recreate the OS window and surface instead of just
  the surface.
  
  Release all resources in DisplayWgpu::Terminate. Otherwise they wont be
  deleted until the display is reinitialized or the test executable
  terminates.
  
  Bug: angleproject:342213844
  Change-Id: Ic31264a5e646a54c988ef47ca664d8575fda94eb
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6515886
  Reviewed-by: Liza Burakova <liza@chromium.org>
  Reviewed-by: Matthew Denton <mpdenton@chromium.org>
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/renderer/wgpu/DisplayWgpu.h

• //
  // Copyright 2024 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // DisplayWgpu.h:
  //    Defines the class interface for DisplayWgpu, implementing DisplayImpl.
  //
  
  #ifndef LIBANGLE_RENDERER_WGPU_DISPLAYWGPU_H_
  #define LIBANGLE_RENDERER_WGPU_DISPLAYWGPU_H_
  
  #include <dawn/native/DawnNative.h>
  #include <dawn/webgpu_cpp.h>
  
  #include "libANGLE/renderer/DisplayImpl.h"
  #include "libANGLE/renderer/ShareGroupImpl.h"
  #include "libANGLE/renderer/wgpu/wgpu_format_utils.h"
  
  namespace rx
  {
  class ShareGroupWgpu : public ShareGroupImpl
  {
    public:
      ShareGroupWgpu(const egl::ShareGroupState &state) : ShareGroupImpl(state) {}
  };
  
  class AllocationTrackerWgpu;
  
  class DisplayWgpu : public DisplayImpl
  {
    public:
      DisplayWgpu(const egl::DisplayState &state);
      ~DisplayWgpu() override;
  
      egl::Error initialize(egl::Display *display) override;
      void terminate() override;
  
      egl::Error makeCurrent(egl::Display *display,
                             egl::Surface *drawSurface,
                             egl::Surface *readSurface,
                             gl::Context *context) override;
  
      egl::ConfigSet generateConfigs() override;
  
      bool testDeviceLost() override;
      egl::Error restoreLostDevice(const egl::Display *display) override;
  
      bool isValidNativeWindow(EGLNativeWindowType window) const override;
  
      std::string getRendererDescription() override;
      std::string getVendorString() override;
      std::string getVersionString(bool includeFullVersion) override;
  
      DeviceImpl *createDevice() override;
  
      egl::Error waitClient(const gl::Context *context) override;
      egl::Error waitNative(const gl::Context *context, EGLint engine) override;
      gl::Version getMaxSupportedESVersion() const override;
      gl::Version getMaxConformantESVersion() const override;
  
      SurfaceImpl *createWindowSurface(const egl::SurfaceState &state,
                                       EGLNativeWindowType window,
                                       const egl::AttributeMap &attribs) override;
      SurfaceImpl *createPbufferSurface(const egl::SurfaceState &state,
                                        const egl::AttributeMap &attribs) override;
      SurfaceImpl *createPbufferFromClientBuffer(const egl::SurfaceState &state,
                                                 EGLenum buftype,
                                                 EGLClientBuffer buffer,
                                                 const egl::AttributeMap &attribs) override;
      SurfaceImpl *createPixmapSurface(const egl::SurfaceState &state,
                                       NativePixmapType nativePixmap,
                                       const egl::AttributeMap &attribs) override;
  
      ImageImpl *createImage(const egl::ImageState &state,
                             const gl::Context *context,
                             EGLenum target,
                             const egl::AttributeMap &attribs) override;
  
      ContextImpl *createContext(const gl::State &state,
                                 gl::ErrorSet *errorSet,
                                 const egl::Config *configuration,
                                 const gl::Context *shareContext,
                                 const egl::AttributeMap &attribs) override;
  
      StreamProducerImpl *createStreamProducerD3DTexture(egl::Stream::ConsumerType consumerType,
                                                         const egl::AttributeMap &attribs) override;
  
      ShareGroupImpl *createShareGroup(const egl::ShareGroupState &state) override;
  
      void populateFeatureList(angle::FeatureList *features) override {}
  
      angle::NativeWindowSystem getWindowSystem() const override;
  
      wgpu::Adapter &getAdapter() { return mAdapter; }
      wgpu::Device &getDevice() { return mDevice; }
      wgpu::Queue &getQueue() { return mQueue; }
      wgpu::Instance &getInstance() { return mInstance; }
  
      const wgpu::Limits getLimitsWgpu() const { return mLimitsWgpu; }
  
      const gl::Caps &getGLCaps() const { return mGLCaps; }
      const gl::TextureCapsMap &getGLTextureCaps() const { return mGLTextureCaps; }
      const gl::Extensions &getGLExtensions() const { return mGLExtensions; }
      const gl::Limitations &getGLLimitations() const { return mGLLimitations; }
      const ShPixelLocalStorageOptions &getPLSOptions() const { return mPLSOptions; }
  
      const webgpu::Format &getFormat(GLenum internalFormat) const
      {
          return mFormatTable[internalFormat];
      }
  
    private:
      void generateExtensions(egl::DisplayExtensions *outExtensions) const override;
      void generateCaps(egl::Caps *outCaps) const override;
  
      egl::Error createWgpuDevice();
  
      wgpu::Adapter mAdapter;
      wgpu::Instance mInstance;
      wgpu::Device mDevice;
      wgpu::Queue mQueue;
  
      wgpu::Limits mLimitsWgpu;
  
      gl::Caps mGLCaps;
      gl::TextureCapsMap mGLTextureCaps;
      gl::Extensions mGLExtensions;
      gl::Limitations mGLLimitations;
      egl::Caps mEGLCaps;
      egl::DisplayExtensions mEGLExtensions;
      gl::Version mMaxSupportedClientVersion;
      ShPixelLocalStorageOptions mPLSOptions;
  
      webgpu::FormatTable mFormatTable;
  };
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_WGPU_DISPLAYWGPU_H_
  

Download