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

• Show log

  Commit

• Hash : 84e54d88
  Author :
  Date : 2024-07-22T14:39:22
  

  WebGPU: Add command buffers and renderpass management
  
  Add a CommandBuffer class to serialize and replay WebGPU commands. Only
  Draw and SetPipeline are implemented in this patch.
  
  Manage render pass begin and end events due to framebuffer changes and
  swapping.
  
  Handle the color mask dirty bits so that a non-zero color mask will be
  used.
  
  All togther, this is enough to draw a triangle using a hard-coded
  shader without inputs.
  
  Bug: angleproject:0
  Change-Id: I0fbf0296563c02c7f0774ad4197b83f4c93c22bb
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5731594
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Liza Burakova <liza@chromium.org>
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/renderer/wgpu/SurfaceWgpu.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.
  //
  // SurfaceWgpu.h:
  //    Defines the class interface for SurfaceWgpu, implementing SurfaceImpl.
  //
  
  #ifndef LIBANGLE_RENDERER_WGPU_SURFACEWGPU_H_
  #define LIBANGLE_RENDERER_WGPU_SURFACEWGPU_H_
  
  #include "libANGLE/renderer/SurfaceImpl.h"
  
  #include "libANGLE/renderer/wgpu/RenderTargetWgpu.h"
  #include "libANGLE/renderer/wgpu/wgpu_helpers.h"
  
  #include <dawn/webgpu_cpp.h>
  
  namespace rx
  {
  
  class SurfaceWgpu : public SurfaceImpl
  {
    public:
      SurfaceWgpu(const egl::SurfaceState &surfaceState);
      ~SurfaceWgpu() override;
  
    protected:
      struct AttachmentImage
      {
          webgpu::ImageHelper texture;
          RenderTargetWgpu renderTarget;
      };
  };
  
  class OffscreenSurfaceWgpu : public SurfaceWgpu
  {
    public:
      OffscreenSurfaceWgpu(const egl::SurfaceState &surfaceState);
      ~OffscreenSurfaceWgpu() override;
  
      egl::Error initialize(const egl::Display *display) override;
      egl::Error swap(const gl::Context *context) override;
      egl::Error bindTexImage(const gl::Context *context,
                              gl::Texture *texture,
                              EGLint buffer) override;
      egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
      void setSwapInterval(EGLint interval) override;
  
      // width and height can change with client window resizing
      EGLint getWidth() const override;
      EGLint getHeight() const override;
  
      EGLint getSwapBehavior() const override;
  
      angle::Result initializeContents(const gl::Context *context,
                                       GLenum binding,
                                       const gl::ImageIndex &imageIndex) override;
  
      egl::Error attachToFramebuffer(const gl::Context *context,
                                     gl::Framebuffer *framebuffer) override;
      egl::Error detachFromFramebuffer(const gl::Context *context,
                                       gl::Framebuffer *framebuffer) override;
  
      angle::Result getAttachmentRenderTarget(const gl::Context *context,
                                              GLenum binding,
                                              const gl::ImageIndex &imageIndex,
                                              GLsizei samples,
                                              FramebufferAttachmentRenderTarget **rtOut) override;
  
    private:
      angle::Result initializeImpl(const egl::Display *display);
  
      EGLint mWidth;
      EGLint mHeight;
  
      AttachmentImage mColorAttachment;
      AttachmentImage mDepthStencilAttachment;
  };
  
  class WindowSurfaceWgpu : public SurfaceWgpu
  {
    public:
      WindowSurfaceWgpu(const egl::SurfaceState &surfaceState, EGLNativeWindowType window);
      ~WindowSurfaceWgpu() override;
  
      egl::Error initialize(const egl::Display *display) override;
      void destroy(const egl::Display *display) override;
      egl::Error swap(const gl::Context *context) override;
      egl::Error bindTexImage(const gl::Context *context,
                              gl::Texture *texture,
                              EGLint buffer) override;
      egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
      void setSwapInterval(EGLint interval) override;
  
      // width and height can change with client window resizing
      EGLint getWidth() const override;
      EGLint getHeight() const override;
  
      EGLint getSwapBehavior() const override;
  
      angle::Result initializeContents(const gl::Context *context,
                                       GLenum binding,
                                       const gl::ImageIndex &imageIndex) override;
  
      egl::Error attachToFramebuffer(const gl::Context *context,
                                     gl::Framebuffer *framebuffer) override;
      egl::Error detachFromFramebuffer(const gl::Context *context,
                                       gl::Framebuffer *framebuffer) override;
  
      angle::Result getAttachmentRenderTarget(const gl::Context *context,
                                              GLenum binding,
                                              const gl::ImageIndex &imageIndex,
                                              GLsizei samples,
                                              FramebufferAttachmentRenderTarget **rtOut) override;
  
    protected:
      EGLNativeWindowType getNativeWindow() const { return mNativeWindow; }
  
    private:
      angle::Result initializeImpl(const egl::Display *display);
  
      angle::Result swapImpl(const gl::Context *context);
  
      angle::Result updateCurrentTexture(const egl::Display *display);
  
      virtual angle::Result createWgpuSurface(const egl::Display *display,
                                              wgpu::Surface *outSurface) = 0;
      virtual angle::Result getCurrentWindowSize(const egl::Display *display,
                                                 gl::Extents *outSize)   = 0;
  
      EGLNativeWindowType mNativeWindow;
      wgpu::Surface mSurface;
      wgpu::SwapChain mSwapChain;
  
      gl::Extents mCurrentSwapChainSize;
  
      AttachmentImage mColorAttachment;
      AttachmentImage mDepthStencilAttachment;
  };
  
  WindowSurfaceWgpu *CreateWgpuWindowSurface(const egl::SurfaceState &surfaceState,
                                             EGLNativeWindowType window);
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_WGPU_SURFACEWGPU_H_
  

Download