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

• Show log

  Commit

• Hash : 25390156
  Author :
  Date : 2025-08-21T00:13:19
  

  Suppress unsafe buffers on a file-by-file basis in src/ [1 of N]
  
  In this CL, we suppress many files but stop short of actually
  enabling the warning by not removing the line from the
  unsafe_buffers_paths.txt file. That will happen in a follow-on
  CL, along with resolving any stragglers missed here.
  
  This is mostly a manual change so as to familiarize myself with
  the kinds of issues faced by the Angle codebase when applying buffer
  safety warnings.
  
  -- Re-generate affected hashes.
  -- Clang-format applied to all changed files.
  -- Add a few missing .reserve() calls to vectors as noticed.
  -- Fix some mismatches between file names and header comments.
  -- Be more consistent with header comment format (blank lines and
     trailing //-only lines when a filename comment adjoins license
     boilerplate).
  
  Bug: b/436880895
  Change-Id: I3bde5cc2059acbe8345057289214f1a26f1c34aa
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6869022
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/renderer/wgpu/SurfaceWgpu.cpp

• //
  // 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.cpp:
  //    Implements the class methods for SurfaceWgpu.
  //
  
  #ifdef UNSAFE_BUFFERS_BUILD
  #    pragma allow_unsafe_buffers
  #endif
  
  #include "libANGLE/renderer/wgpu/SurfaceWgpu.h"
  
  #include "common/debug.h"
  
  #include "libANGLE/Display.h"
  #include "libANGLE/Surface.h"
  #include "libANGLE/renderer/wgpu/DisplayWgpu.h"
  #include "libANGLE/renderer/wgpu/FramebufferWgpu.h"
  
  namespace rx
  {
  
  constexpr WGPUTextureUsage kSurfaceTextureUsage =
      WGPUTextureUsage_TextureBinding | WGPUTextureUsage_RenderAttachment | WGPUTextureUsage_CopySrc |
      WGPUTextureUsage_CopyDst;
  
  SurfaceWgpu::SurfaceWgpu(const egl::SurfaceState &surfaceState) : SurfaceImpl(surfaceState) {}
  
  SurfaceWgpu::~SurfaceWgpu() {}
  
  angle::Result SurfaceWgpu::createDepthStencilAttachment(const egl::Display *display,
                                                          uint32_t width,
                                                          uint32_t height,
                                                          const webgpu::Format &webgpuFormat,
                                                          webgpu::DeviceHandle device,
                                                          AttachmentImage *outDepthStencilAttachment)
  {
      const DisplayWgpu *displayWgpu = webgpu::GetImpl(display);
      const DawnProcTable *wgpu      = displayWgpu->getProcs();
  
      WGPUTextureDescriptor desc = outDepthStencilAttachment->texture.createTextureDescriptor(
          kSurfaceTextureUsage, WGPUTextureDimension_2D, {width, height, 1},
          webgpuFormat.getActualWgpuTextureFormat(), 1, 1);
  
      constexpr uint32_t level = 0;
      constexpr uint32_t layer = 0;
  
      ANGLE_TRY(outDepthStencilAttachment->texture.initImage(wgpu, webgpuFormat.getIntendedFormatID(),
                                                             webgpuFormat.getActualImageFormatID(),
                                                             device, gl::LevelIndex(level), desc));
  
      webgpu::TextureViewHandle view;
      ANGLE_TRY(outDepthStencilAttachment->texture.createTextureViewSingleLevel(gl::LevelIndex(level),
                                                                                layer, view));
      outDepthStencilAttachment->renderTarget.set(
          &outDepthStencilAttachment->texture, view, webgpu::LevelIndex(level), layer,
          outDepthStencilAttachment->texture.toWgpuTextureFormat());
      return angle::Result::Continue;
  }
  
  OffscreenSurfaceWgpu::OffscreenSurfaceWgpu(const egl::SurfaceState &surfaceState,
                                             EGLenum clientBufferType,
                                             EGLClientBuffer clientBuffer)
      : SurfaceWgpu(surfaceState),
        mWidth(surfaceState.attributes.getAsInt(EGL_WIDTH, 0)),
        mHeight(surfaceState.attributes.getAsInt(EGL_HEIGHT, 0)),
        mClientBufferType(clientBufferType),
        mClientBuffer(clientBuffer)
  {}
  
  OffscreenSurfaceWgpu::~OffscreenSurfaceWgpu() {}
  
  egl::Error OffscreenSurfaceWgpu::initialize(const egl::Display *display)
  {
      return angle::ResultToEGL(initializeImpl(display));
  }
  
  egl::Error OffscreenSurfaceWgpu::swap(const gl::Context *context, SurfaceSwapFeedback *feedback)
  {
      UNREACHABLE();
      return egl::NoError();
  }
  
  egl::Error OffscreenSurfaceWgpu::bindTexImage(const gl::Context *context,
                                                gl::Texture *texture,
                                                EGLint buffer)
  {
      UNIMPLEMENTED();
      return egl::NoError();
  }
  
  egl::Error OffscreenSurfaceWgpu::releaseTexImage(const gl::Context *context, EGLint buffer)
  {
      UNIMPLEMENTED();
      return egl::NoError();
  }
  
  void OffscreenSurfaceWgpu::setSwapInterval(const egl::Display *display, EGLint interval) {}
  
  gl::Extents OffscreenSurfaceWgpu::getSize() const
  {
      return gl::Extents(mWidth, mHeight, 1);
  }
  
  
  EGLint OffscreenSurfaceWgpu::getSwapBehavior() const
  {
      return EGL_BUFFER_DESTROYED;
  }
  
  angle::Result OffscreenSurfaceWgpu::initializeContents(const gl::Context *context,
                                                         GLenum binding,
                                                         const gl::ImageIndex &imageIndex)
  {
      UNIMPLEMENTED();
      return angle::Result::Continue;
  }
  
  egl::Error OffscreenSurfaceWgpu::attachToFramebuffer(const gl::Context *context,
                                                       gl::Framebuffer *framebuffer)
  {
      UNIMPLEMENTED();
      return egl::NoError();
  }
  
  egl::Error OffscreenSurfaceWgpu::detachFromFramebuffer(const gl::Context *context,
                                                         gl::Framebuffer *framebuffer)
  {
      UNIMPLEMENTED();
      return egl::NoError();
  }
  
  angle::Result OffscreenSurfaceWgpu::getAttachmentRenderTarget(
      const gl::Context *context,
      GLenum binding,
      const gl::ImageIndex &imageIndex,
      GLsizei samples,
      FramebufferAttachmentRenderTarget **rtOut)
  {
      if (binding == GL_BACK)
      {
          *rtOut = &mColorAttachment.renderTarget;
      }
      else
      {
          ASSERT(binding == GL_DEPTH || binding == GL_STENCIL || binding == GL_DEPTH_STENCIL);
          *rtOut = &mDepthStencilAttachment.renderTarget;
      }
  
      return angle::Result::Continue;
  }
  
  angle::Result OffscreenSurfaceWgpu::initializeImpl(const egl::Display *display)
  {
      DisplayWgpu *displayWgpu = webgpu::GetImpl(display);
      const DawnProcTable *wgpu   = displayWgpu->getProcs();
      webgpu::DeviceHandle device = displayWgpu->getDevice();
  
      if (mClientBufferType == EGL_WEBGPU_TEXTURE_ANGLE)
      {
          webgpu::TextureHandle externalTexture =
              webgpu::TextureHandle::Acquire(wgpu, reinterpret_cast<WGPUTexture>(mClientBuffer));
          ASSERT(externalTexture != nullptr);
  
          // Explicitly add-ref to hold on to the external reference
          wgpu->textureAddRef(externalTexture.get());
  
          const webgpu::Format *webgpuFormat = displayWgpu->getFormatForImportedTexture(
              mState.attributes, wgpu->textureGetFormat(externalTexture.get()));
          ASSERT(webgpuFormat);
          ANGLE_TRY(mColorAttachment.texture.initExternal(wgpu, webgpuFormat->getIntendedFormatID(),
                                                          webgpuFormat->getActualImageFormatID(),
                                                          externalTexture));
  
          webgpu::TextureViewHandle view;
          ANGLE_TRY(
              mColorAttachment.texture.createTextureViewSingleLevel(gl::LevelIndex(0), 0, view));
  
          mColorAttachment.renderTarget.set(&mColorAttachment.texture, view, webgpu::LevelIndex(0), 0,
                                            mColorAttachment.texture.toWgpuTextureFormat());
  
          mWidth  = mColorAttachment.texture.getSize().width;
          mHeight = mColorAttachment.texture.getSize().height;
      }
      else
      {
          const egl::Config *config = mState.config;
  
          if (config->renderTargetFormat != GL_NONE)
          {
              const webgpu::Format &webgpuFormat = displayWgpu->getFormat(config->renderTargetFormat);
              WGPUTextureDescriptor desc         = mColorAttachment.texture.createTextureDescriptor(
                  kSurfaceTextureUsage, WGPUTextureDimension_2D,
                  {static_cast<uint32_t>(mWidth), static_cast<uint32_t>(mHeight), 1},
                  webgpuFormat.getActualWgpuTextureFormat(), 1, 1);
  
              constexpr uint32_t level = 0;
              constexpr uint32_t layer = 0;
  
              ANGLE_TRY(mColorAttachment.texture.initImage(wgpu, webgpuFormat.getIntendedFormatID(),
                                                           webgpuFormat.getActualImageFormatID(),
                                                           device, gl::LevelIndex(level), desc));
  
              webgpu::TextureViewHandle view;
              ANGLE_TRY(mColorAttachment.texture.createTextureViewSingleLevel(gl::LevelIndex(level),
                                                                              layer, view));
              mColorAttachment.renderTarget.set(&mColorAttachment.texture, view,
                                                webgpu::LevelIndex(level), layer,
                                                mColorAttachment.texture.toWgpuTextureFormat());
          }
  
          if (config->depthStencilFormat != GL_NONE)
          {
              const webgpu::Format &webgpuFormat = displayWgpu->getFormat(config->depthStencilFormat);
              ANGLE_TRY(createDepthStencilAttachment(display, static_cast<uint32_t>(mWidth),
                                                     static_cast<uint32_t>(mHeight), webgpuFormat,
                                                     device, &mDepthStencilAttachment));
          }
      }
  
      return angle::Result::Continue;
  }
  
  WindowSurfaceWgpu::WindowSurfaceWgpu(const egl::SurfaceState &surfaceState,
                                       EGLNativeWindowType window)
      : SurfaceWgpu(surfaceState), mNativeWindow(window)
  {}
  
  WindowSurfaceWgpu::~WindowSurfaceWgpu() {}
  
  egl::Error WindowSurfaceWgpu::initialize(const egl::Display *display)
  {
      return angle::ResultToEGL(initializeImpl(display));
  }
  
  void WindowSurfaceWgpu::destroy(const egl::Display *display)
  {
      mSurface   = nullptr;
      mColorAttachment.renderTarget.reset();
      mColorAttachment.texture.resetImage();
      mDepthStencilAttachment.renderTarget.reset();
      mDepthStencilAttachment.texture.resetImage();
  }
  
  egl::Error WindowSurfaceWgpu::swap(const gl::Context *context, SurfaceSwapFeedback *feedback)
  {
      return angle::ResultToEGL(swapImpl(context));
  }
  
  egl::Error WindowSurfaceWgpu::bindTexImage(const gl::Context *context,
                                             gl::Texture *texture,
                                             EGLint buffer)
  {
      UNIMPLEMENTED();
      return egl::NoError();
  }
  
  egl::Error WindowSurfaceWgpu::releaseTexImage(const gl::Context *context, EGLint buffer)
  {
      UNIMPLEMENTED();
      return egl::NoError();
  }
  
  void WindowSurfaceWgpu::setSwapInterval(const egl::Display *display, EGLint interval)
  {
      UNIMPLEMENTED();
  }
  
  gl::Extents WindowSurfaceWgpu::getSize() const
  {
      return mCurrentSurfaceSize;
  }
  
  EGLint WindowSurfaceWgpu::getSwapBehavior() const
  {
      UNIMPLEMENTED();
      return 0;
  }
  
  angle::Result WindowSurfaceWgpu::initializeContents(const gl::Context *context,
                                                      GLenum binding,
                                                      const gl::ImageIndex &imageIndex)
  {
      UNIMPLEMENTED();
      return angle::Result::Continue;
  }
  
  egl::Error WindowSurfaceWgpu::attachToFramebuffer(const gl::Context *context,
                                                    gl::Framebuffer *framebuffer)
  {
      FramebufferWgpu *framebufferWgpu = GetImplAs<FramebufferWgpu>(framebuffer);
      framebufferWgpu->setFlipY(true);
      return egl::NoError();
  }
  
  egl::Error WindowSurfaceWgpu::detachFromFramebuffer(const gl::Context *context,
                                                      gl::Framebuffer *framebuffer)
  {
      FramebufferWgpu *framebufferWgpu = GetImplAs<FramebufferWgpu>(framebuffer);
      framebufferWgpu->setFlipY(false);
      return egl::NoError();
  }
  
  angle::Result WindowSurfaceWgpu::getAttachmentRenderTarget(
      const gl::Context *context,
      GLenum binding,
      const gl::ImageIndex &imageIndex,
      GLsizei samples,
      FramebufferAttachmentRenderTarget **rtOut)
  {
      if (binding == GL_BACK)
      {
          *rtOut = &mColorAttachment.renderTarget;
      }
      else
      {
          ASSERT(binding == GL_DEPTH || binding == GL_STENCIL || binding == GL_DEPTH_STENCIL);
          *rtOut = &mDepthStencilAttachment.renderTarget;
      }
  
      return angle::Result::Continue;
  }
  
  angle::Result WindowSurfaceWgpu::initializeImpl(const egl::Display *display)
  {
      DisplayWgpu *displayWgpu = webgpu::GetImpl(display);
      const DawnProcTable *wgpu     = displayWgpu->getProcs();
      webgpu::AdapterHandle adapter = displayWgpu->getAdapter();
  
      ANGLE_TRY(createWgpuSurface(display, &mSurface));
  
      gl::Extents size;
      ANGLE_TRY(getCurrentWindowSize(display, &size));
  
      WGPUSurfaceCapabilities surfaceCapabilities = WGPU_SURFACE_CAPABILITIES_INIT;
      WGPUStatus getCapabilitiesStatus =
          wgpu->surfaceGetCapabilities(mSurface.get(), adapter.get(), &surfaceCapabilities);
      if (getCapabilitiesStatus != WGPUStatus_Success)
      {
          ERR() << "wgpuSurfaceGetCapabilities failed: "
                << gl::FmtHex(static_cast<uint32_t>(getCapabilitiesStatus));
          return angle::Result::Stop;
      }
  
      const egl::Config *config = mState.config;
      ASSERT(config->renderTargetFormat != GL_NONE);
      mSurfaceTextureFormat = &displayWgpu->getFormat(config->renderTargetFormat);
      ASSERT(std::find(surfaceCapabilities.formats,
                       surfaceCapabilities.formats + surfaceCapabilities.formatCount,
                       mSurfaceTextureFormat->getActualWgpuTextureFormat()) !=
             (surfaceCapabilities.formats + surfaceCapabilities.formatCount));
  
      mSurfaceTextureUsage =
          WGPUTextureUsage_RenderAttachment | WGPUTextureUsage_CopySrc | WGPUTextureUsage_CopyDst;
      ASSERT((surfaceCapabilities.usages & mSurfaceTextureUsage) == mSurfaceTextureUsage);
  
      // Default to the always supported Fifo present mode. Use Mailbox if it's available.
      mPresentMode = WGPUPresentMode_Fifo;
      for (size_t i = 0; i < surfaceCapabilities.presentModeCount; i++)
      {
          if (surfaceCapabilities.presentModes[i] == WGPUPresentMode_Mailbox)
          {
              mPresentMode = WGPUPresentMode_Mailbox;
          }
      }
  
      if (config->depthStencilFormat != GL_NONE)
      {
          mDepthStencilFormat = &displayWgpu->getFormat(config->depthStencilFormat);
      }
      else
      {
          mDepthStencilFormat = nullptr;
      }
  
      ANGLE_TRY(configureSurface(display, size));
      ANGLE_TRY(updateCurrentTexture(display));
  
      return angle::Result::Continue;
  }
  
  angle::Result WindowSurfaceWgpu::swapImpl(const gl::Context *context)
  {
      const egl::Display *display = context->getDisplay();
      ContextWgpu *contextWgpu    = webgpu::GetImpl(context);
      const DawnProcTable *wgpu   = webgpu::GetProcs(contextWgpu);
  
      ANGLE_TRY(contextWgpu->flush(webgpu::RenderPassClosureReason::EGLSwapBuffers));
  
      wgpu->surfacePresent(mSurface.get());
  
      gl::Extents size;
      ANGLE_TRY(getCurrentWindowSize(display, &size));
      if (size != mCurrentSurfaceSize)
      {
          ANGLE_TRY(configureSurface(display, size));
      }
  
      ANGLE_TRY(updateCurrentTexture(display));
  
      return angle::Result::Continue;
  }
  
  angle::Result WindowSurfaceWgpu::configureSurface(const egl::Display *display,
                                                    const gl::Extents &size)
  {
      DisplayWgpu *displayWgpu = webgpu::GetImpl(display);
      const DawnProcTable *wgpu   = displayWgpu->getProcs();
      webgpu::DeviceHandle device = displayWgpu->getDevice();
  
      ASSERT(mSurfaceTextureFormat != nullptr);
  
      WGPUSurfaceConfiguration surfaceConfig   = WGPU_SURFACE_CONFIGURATION_INIT;
      surfaceConfig.device                     = device.get();
      surfaceConfig.format                     = mSurfaceTextureFormat->getActualWgpuTextureFormat();
      surfaceConfig.usage                      = mSurfaceTextureUsage;
      surfaceConfig.width                      = size.width;
      surfaceConfig.height                     = size.height;
      surfaceConfig.presentMode                = mPresentMode;
  
      wgpu->surfaceConfigure(mSurface.get(), &surfaceConfig);
  
      if (mDepthStencilFormat)
      {
          ANGLE_TRY(createDepthStencilAttachment(
              display, static_cast<uint32_t>(size.width), static_cast<uint32_t>(size.height),
              *mDepthStencilFormat, device, &mDepthStencilAttachment));
      }
  
      mCurrentSurfaceSize = size;
      return angle::Result::Continue;
  }
  
  angle::Result WindowSurfaceWgpu::updateCurrentTexture(const egl::Display *display)
  {
      DisplayWgpu *displayWgpu  = webgpu::GetImpl(display);
      const DawnProcTable *wgpu = displayWgpu->getProcs();
  
      WGPUSurfaceTexture surfaceTexture = WGPU_SURFACE_TEXTURE_INIT;
      wgpu->surfaceGetCurrentTexture(mSurface.get(), &surfaceTexture);
      webgpu::TextureHandle texture = webgpu::TextureHandle::Acquire(wgpu, surfaceTexture.texture);
      if (surfaceTexture.status != WGPUSurfaceGetCurrentTextureStatus_SuccessOptimal &&
          surfaceTexture.status != WGPUSurfaceGetCurrentTextureStatus_SuccessSuboptimal)
      {
          ERR() << "wgpuSurfaceGetCurrentTexture failed: "
                << gl::FmtHex(static_cast<uint32_t>(surfaceTexture.status));
          return angle::Result::Stop;
      }
  
      WGPUTextureFormat wgpuFormat   = wgpu->textureGetFormat(texture.get());
      angle::FormatID angleFormat    = webgpu::GetFormatIDFromWgpuTextureFormat(wgpuFormat);
  
      ANGLE_TRY(mColorAttachment.texture.initExternal(wgpu, angleFormat, angleFormat, texture));
  
      webgpu::TextureViewHandle view;
      ANGLE_TRY(mColorAttachment.texture.createTextureViewSingleLevel(gl::LevelIndex(0), 0, view));
  
      mColorAttachment.renderTarget.set(&mColorAttachment.texture, view, webgpu::LevelIndex(0), 0,
                                        wgpuFormat);
  
      return angle::Result::Continue;
  }
  
  }  // namespace rx
  

Download