SurfaceWgpu.cpp

Show log
Commit

Hash : ecc378cc
Author :
Date : 2025-03-03T16:43:33

Reland "Dont use Subject/Observer for SwapchainImageChanged"

This is reland of the following CL
https://chromium-review.googlesource.com/c/angle/angle/+/6319893

Because we do deferred ANI (VkAcquireNextImage) call until image is
needed, we need a way to force Context to go through
FramebufferVk::syncState call (FramebufferVk::syncState calls
WindowSurfaceVk::getAttachmentRenderTarget, which end up calling ANI.
Right now we uses subject/observer mechanism, by sending
angle::SubjectMessage::SwapchainImageChanged to all observers of
WindowSurfaceVk. In this case it is egl::Surface. Then eglSurface
redirects this message to its observers, which are all gl::Framebuffer's
attachments: color, depth, stencil. Even though only color attachment
needs to be notified, but because we don't have a separate list of
observers, depth/stencil attachment also receive the notification and
they early out. Then gl::Framebuffer sets
DIRTY_BIT_COLOR_BUFFER_CONTENTS_0 dirty bit and send the
angle::SubjectMessage::DirtyBitsFlagged to Context, which dirty DrawFBO
and ReadFBO and dirty cached state. Note that this is specific for swap
image changed case, there is no surface property change (surface
property change will still trigger the subject/observer message with
SubjectMessage::SubjectChanged message, but this occurs rarely). This
gets worse for apps that uses multiple contexts, for the example
pokemon_masters_ex has three contexts, each context has its own default
frame buffer that attach to the same surface, and we never remove
non-current context from the observer list. This end up with
egl::Surface has 12 observers and for every frame, it loop over the list
of 12 observers and send message (virtual function call) to each of
them. Color attachment also ends up sending two messages to Context, one
for Read FBO and another for Draw FBO. There are total 21 virtual
function calls. Even for single context usage, you have 6 virtual
function calls, for every frame.

EGL spec says "an EGLSurface must be current on only one thread at a
time", any other context must call EGLMakeCurrent in order to use this
surface, which will add all necessary dirty bits at that time. So we
really only need to notify current context. In this CL,
SwapchainImageChanged no longer uses subject/observer mechanism, so this
message is removed.

This CL still uses subject/observer mechanism to send DirtyBitsFlagged
from Framebuffer back to context. We could call setDrawFramebufferDirty
and setReadFramebufferDirty directly, but that will require to remove
the "const" decoration out of gl::Context which generates too much code
diff, so onStateChange(angle::SubjectMessage::DirtyBitsFlagged) is still
used.

Bug: angleproject:400711938
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6319893
Commit-Queue: Charlie Lao <cclao@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Change-Id: I017b0e8934b5194a520828fa5c4af1d6e3ef9aac
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6404621

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.
//

#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 wgpu::TextureUsage kSurfaceTextureUsage =
    wgpu::TextureUsage::TextureBinding | wgpu::TextureUsage::RenderAttachment |
    wgpu::TextureUsage::CopySrc | wgpu::TextureUsage::CopyDst;

SurfaceWgpu::SurfaceWgpu(const egl::SurfaceState &surfaceState) : SurfaceImpl(surfaceState) {}

SurfaceWgpu::~SurfaceWgpu() {}

angle::Result SurfaceWgpu::createDepthStencilAttachment(uint32_t width,
                                                        uint32_t height,
                                                        const webgpu::Format &webgpuFormat,
                                                        wgpu::Device &device,
                                                        AttachmentImage *outDepthStencilAttachment)
{
    wgpu::TextureDescriptor desc = outDepthStencilAttachment->texture.createTextureDescriptor(
        kSurfaceTextureUsage, wgpu::TextureDimension::e2D, {width, height, 1},
        webgpuFormat.getActualWgpuTextureFormat(), 1, 1);

    constexpr uint32_t level = 0;
    constexpr uint32_t layer = 0;

    ANGLE_TRY(outDepthStencilAttachment->texture.initImage(webgpuFormat.getIntendedFormatID(),
                                                           webgpuFormat.getActualImageFormatID(),
                                                           device, gl::LevelIndex(level), desc));

    wgpu::TextureView view;
    ANGLE_TRY(
        outDepthStencilAttachment->texture.createTextureView(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)
    : SurfaceWgpu(surfaceState),
      mWidth(surfaceState.attributes.getAsInt(EGL_WIDTH, 0)),
      mHeight(surfaceState.attributes.getAsInt(EGL_HEIGHT, 0))
{}

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) {}

EGLint OffscreenSurfaceWgpu::getWidth() const
{
    return mWidth;
}

EGLint OffscreenSurfaceWgpu::getHeight() const
{
    return mHeight;
}

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);
    wgpu::Device &device     = displayWgpu->getDevice();

    const egl::Config *config = mState.config;

    if (config->renderTargetFormat != GL_NONE)
    {
        const webgpu::Format &webgpuFormat = displayWgpu->getFormat(config->renderTargetFormat);
        wgpu::TextureDescriptor desc       = mColorAttachment.texture.createTextureDescriptor(
            kSurfaceTextureUsage, wgpu::TextureDimension::e2D,
            {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(webgpuFormat.getIntendedFormatID(),
                                                     webgpuFormat.getActualImageFormatID(), device,
                                                     gl::LevelIndex(level), desc));

        wgpu::TextureView view;
        ANGLE_TRY(mColorAttachment.texture.createTextureView(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(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();
}

EGLint WindowSurfaceWgpu::getWidth() const
{
    return mCurrentSurfaceSize.width;
}

EGLint WindowSurfaceWgpu::getHeight() const
{
    return mCurrentSurfaceSize.height;
}

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)
{
    return egl::NoError();
}

egl::Error WindowSurfaceWgpu::detachFromFramebuffer(const gl::Context *context,
                                                    gl::Framebuffer *framebuffer)
{
    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);
    wgpu::Adapter &adapter   = displayWgpu->getAdapter();

    ANGLE_TRY(createWgpuSurface(display, &mSurface));

    gl::Extents size;
    ANGLE_TRY(getCurrentWindowSize(display, &size));

    wgpu::SurfaceCapabilities surfaceCapabilities;
    wgpu::Status getCapabilitiesStatus = mSurface.GetCapabilities(adapter, &surfaceCapabilities);
    if (getCapabilitiesStatus != wgpu::Status::Success)
    {
        ERR() << "wgpu::Surface::GetCapabilities 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 = wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc |
                           wgpu::TextureUsage::CopyDst;
    ASSERT((surfaceCapabilities.usages & mSurfaceTextureUsage) == mSurfaceTextureUsage);

    // Default to the always supported Fifo present mode. Use Mailbox if it's available.
    mPresentMode = wgpu::PresentMode::Fifo;
    for (size_t i = 0; i < surfaceCapabilities.presentModeCount; i++)
    {
        if (surfaceCapabilities.presentModes[i] == wgpu::PresentMode::Mailbox)
        {
            mPresentMode = wgpu::PresentMode::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);

    ANGLE_TRY(contextWgpu->flush(webgpu::RenderPassClosureReason::EGLSwapBuffers));

    mSurface.Present();

    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);
    wgpu::Device &device     = displayWgpu->getDevice();

    ASSERT(mSurfaceTextureFormat != nullptr);

    wgpu::SurfaceConfiguration surfaceConfig = {};
    surfaceConfig.device                     = device;
    surfaceConfig.format                     = mSurfaceTextureFormat->getActualWgpuTextureFormat();
    surfaceConfig.usage                      = mSurfaceTextureUsage;
    surfaceConfig.width                      = size.width;
    surfaceConfig.height                     = size.height;
    surfaceConfig.presentMode                = mPresentMode;

    mSurface.Configure(&surfaceConfig);

    if (mDepthStencilFormat)
    {
        ANGLE_TRY(createDepthStencilAttachment(
            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)
{
    wgpu::SurfaceTexture texture;
    mSurface.GetCurrentTexture(&texture);
    if (texture.status != wgpu::SurfaceGetCurrentTextureStatus::SuccessOptimal &&
        texture.status != wgpu::SurfaceGetCurrentTextureStatus::SuccessSuboptimal)
    {
        ERR() << "wgpu::Surface::GetCurrentTexture failed: "
              << gl::FmtHex(static_cast<uint32_t>(texture.status));
        return angle::Result::Stop;
    }

    wgpu::TextureFormat wgpuFormat = texture.texture.GetFormat();
    angle::FormatID angleFormat    = webgpu::GetFormatIDFromWgpuTextureFormat(wgpuFormat);

    ANGLE_TRY(mColorAttachment.texture.initExternal(angleFormat, angleFormat, texture.texture));

    wgpu::TextureView view;
    ANGLE_TRY(mColorAttachment.texture.createTextureView(gl::LevelIndex(0), 0, view));

    mColorAttachment.renderTarget.set(&mColorAttachment.texture, view, webgpu::LevelIndex(0), 0,
                                      wgpuFormat);

    return angle::Result::Continue;
}

}  // namespace rx

Download