DisplayWgpu.cpp

Show log
Commit

Hash : 4eb4165b
Author :
Date : 2025-03-07T10:24:05

Roll third_party/dawn/ 8119dbd27..7a8946456 (244 commits; 3 trivial rolls)

Need
https://dawn-review.googlesource.com/c/dawn/+/229494
to roll
https://chromium-review.googlesource.com/c/angle/angle/+/6334483
vulkan_platform.h:152:9: error: 'VK_USE_PLATFORM_XLIB_KHR' macro redefined

https://dawn.googlesource.com/dawn.git/+log/8119dbd27471..7a8946456d49

$ git log 8119dbd27..7a8946456 --date=short --no-merges --format='%ad %ae %s'
2025-03-07 cwallez [tint] Add support for binding_array to the IR validator
2025-03-07 hitawala [stream] Check for size invalidity before reserving in Stream::Read
2025-03-07 cwallez Reland "[dawn] Fix detection of __builtin_assume for DAWN_ASSERT"
2025-03-06 dawn-autoroll Roll ANGLE from 99ebd28ad246 to 0cdbc7814e59 (4 revisions)
2025-03-06 jiawei.shao Remove the redefinition of dawn::native::Vulkan::ClampFragDepthArgs
2025-03-06 jiawei.shao Vulkan: Implement PreferNotUsingMappableOrUniformBufferAsStorage()
2025-03-06 rharrison [tint][ir][fuzz] Re-enable SubgroupMatrix in IR binary
2025-03-06 shrekshao [Compat] Remove suppressions for ReadOnlyDepthStencilAttachmentTests
2025-03-06 thomasanderson [X11] Don't redefine VK_USE_PLATFORM_XLIB_KHR
2025-03-06 lokokung [dawn][emscripten] Fix Emscripten bindings for compilation messages.
2025-03-06 lokokung [dawn][native] Add validation for Infinities.
2025-03-06 lokokung [dawn][headers] Update wgpu::Surface APIs to match upstream.
2025-03-06 bsheedy [tools] Convert glob to use dependency injection
2025-03-06 cwallez [dawn][native] Track the set of BGLInternal separately from BGL.
2025-03-06 amaiorano tint: make PreventInfiniteLoops count down from uint32::highest() down to 0
2025-03-06 dsinclair Revert "Vulkan: Allow setting multiple `MemoryKind` bits"
2025-03-06 ynovikov Reland "Roll reclient, siso; update related DEPS to match Chromium"
2025-03-06 dawn-autoroll Roll ANGLE from 1a0c9db3748a to 99ebd28ad246 (8 revisions)
2025-03-06 cwallez Revert "[dawn] Fix detection of __builtin_assume for DAWN_ASSERT"
2025-03-05 zhaoming.jiang Dawn: Remove adapter from shader compilation request
2025-03-05 jiawei.shao Skip the test CreateBufferOOMWithValidationError when no validation
2025-03-05 lokokung [dawn][native] Make error scopes thread local.
2025-03-05 dawn-autoroll Roll ANGLE from 6b10ae3386b7 to 1a0c9db3748a (3 revisions)
2025-03-05 mohamedkhairy0101 tint: Improve error message for module-scope function calls
2025-03-05 mohammedashraf4599 add BOM error message
2025-03-05 cwallez [dawn] Fix detection of __builtin_assume for DAWN_ASSERT
2025-03-05 cwallez [tint] Add binding_array indexing to the resolver.
2025-03-05 kylechar Add SlabAllocator::DeleteEmptySlabs()
2025-03-05 dawn-autoroll Roll ANGLE from 73992d71f9d1 to 6b10ae3386b7 (7 revisions)
2025-03-05 shrekshao Remove enabling core-features-and-limits in backends
2025-03-04 lokokung [dawn][headers] Removes default UTF16 support.
2025-03-04 lokokung Reland "[dawn][headers] Remove obsolete ifdefs."
2025-03-04 jwata build: GN builds use Siso without Reclient in tools/setup-build script
2025-03-04 jrprice [vulkan] Fix subgroup matrix config gathering
2025-03-04 dawn-autoroll Roll ANGLE from bd8bc1055ecd to 73992d71f9d1 (1 revision)
2025-03-04 chrome-branch-day Activate dawn M135
2025-03-04 beaufort.francois Remove maxInterStageShaderComponents limit
2025-03-04 beaufort.francois Refactor Bindgroup constructors
2025-03-04 cwallez [tint] Add binding_array to the resolver
2025-03-04 cwallez Revert "[dawn][headers] Remove obsolete ifdefs."
2025-03-04 lokokung [dawn][headers] Remove obsolete ifdefs.
2025-03-03 zhaoming.jiang Dawn: Cache limits in AdapterBase
2025-03-03 dawn-autoroll Roll ANGLE from 19b35fcbff31 to bd8bc1055ecd (5 revisions)
2025-03-03 lokokung [dawn][headers] Adds extension support for UTF-16 in compilation message.
2025-03-03 jrprice [spirv] Only add explicit layout decorations on types that need them
2025-03-03 kainino [emscripten] Add emsdk to DEPS for Wasm builds
2025-03-03 lokokung [dawn][wire] Adds Dawn wire invalid extension struct and handling.
2025-03-03 jrprice [dawn] Validate workgroup size for subgroup matrix
2025-03-03 jrprice [inspector] Reflect the use of a subgroup matrix
2025-03-03 jrprice [tint] Reject non-compute shaders that use subgroup matrices
(...)
2025-02-18 zhjiang Dawn: Tighten the scope of ScopedTintICEHandler
2025-02-18 dawn-autoroll Roll DirectX Shader Compiler from 6b68f3b5832c to fcbd2a184294 (2 revisions)
2025-02-18 jiawei.shao Replace `PipelineCompatibilityToken(0)` with `kExplicitPCT`
2025-02-18 yulong.fs fix memory address value passed to emwgpuDelete()
2025-02-18 dsinclair [spirv-reader][ir] Implement OpConvertFToU
2025-02-18 kainino dawn::DynamicLib: Leak all DLLs on Windows ASan builds
2025-02-18 dsinclair [spirv-reader][ir] Implement ConvertFToS
2025-02-18 petermcneeley Fix for assignment outside the range of representable type
2025-02-18 kainino Refactor TINT_ASAN_ENABLED into common DAWN_ASAN_ENABLED()
2025-02-18 gman Add a trace option to the Metal Backend
2025-02-18 dawn-autoroll Roll ANGLE from ba3dcfa4670d to 8dda514cb833 (3 revisions)
2025-02-18 dsinclair Mark function unused.
2025-02-18 dawn-autoroll Roll DirectX Shader Compiler from 20950d662f4d to 6b68f3b5832c (1 revision)
2025-02-17 dawn-autoroll Roll ANGLE from e0332c861004 to ba3dcfa4670d (1 revision)
2025-02-17 dawn-autoroll Roll vulkan-deps from 2a09ac22553e to 5d08bc0b0e23 (6 revisions)
2025-02-17 yulong.fs fix buffer destroy
2025-02-17 dawn-autoroll Roll ANGLE from 51d2561b5a6b to e0332c861004 (1 revision)
2025-02-17 lehoangquyen D3D: remove dead code used by the old external image API
2025-02-16 dawn-autoroll Roll Depot Tools from 77a800d7294d to 7a0dbd207449 (59 revisions)
2025-02-16 jiawei.shao Enable creating pipeline layout with null bind group layout by default
2025-02-16 dawn-autoroll Roll vulkan-deps from 2365826a66b2 to 2a09ac22553e (1 revision)
2025-02-15 dawn-autoroll Roll vulkan-deps from cc6490ed63e7 to 2365826a66b2 (5 revisions)
2025-02-15 dawn-autoroll Roll ANGLE from bef478f54e6e to 51d2561b5a6b (2 revisions)
2025-02-15 jie.a.chen Fix CooperativeMatrix extension index
2025-02-14 dawn-autoroll Roll ANGLE from 7afa2345f8d2 to bef478f54e6e (3 revisions)
2025-02-14 dsinclair [spirv-reader][ir] Register names instead of using new
2025-02-14 dsinclair [spirv-reader][ir] Support OpBranchConditional after OpSelectionMerge
2025-02-14 dawn-autoroll Roll vulkan-deps from 5cc3a63e8fdb to cc6490ed63e7 (5 revisions)
2025-02-14 gman Emit WGSL errors as part of GPUValidationError
2025-02-14 jimblackler [Kotlin] Update template now WGPUChainedStructOut has been removed.
2025-02-14 dawn-autoroll Roll ANGLE from cd7f92e1ed57 to 7afa2345f8d2 (6 revisions)
2025-02-13 petermcneeley Substitute overrides in IR (vk)
2025-02-13 shaoboyan [Spirv] Remove clamp_frag_depth attribute in Options
2025-02-13 dsinclair [spirv-reader][ir] Handle OpBranch instruction
2025-02-13 jrprice [ir] Add builtin struct support to the protobuf
2025-02-13 rharrison [tint][ir][val] Check Samplers & Textures address space
2025-02-13 jrprice [tint] Add flag for WGSL internal structures
2025-02-13 rharrison [tint] Replace unsafe casting with shift & mask in eval.cc
2025-02-13 rharrison [tint] Narrow warning suppression in table_data.h
2025-02-13 bajones Loosen Viewport validation requirements
2025-02-13 shrekshao [Compat] Add compat-min-es31 tags in expectations
2025-02-13 gman Remove old subgroups from dawn.node
2025-02-13 dawn-autoroll Roll ANGLE from 19c5293e1347 to cd7f92e1ed57 (9 revisions)
2025-02-13 dsinclair [spirv-reader][ir] Add names for functions and function parameters.
2025-02-13 dsinclair [spirv-reader][ir] Support names.
2025-02-13 dsinclair [spirv-reader][ir] Fixup mixed sign binary methods.
2025-02-13 dawn-autoroll Roll vulkan-deps from a88fd25a6a0d to 5cc3a63e8fdb (17 revisions)
2025-02-13 dsinclair Add suppressions for compat failures.
2025-02-13 jrprice [spirv] Emit Matrix*SignedComponents operands
2025-02-13 jrprice [tint] Subgroup matrix component types do not have to match

Created with:
  roll-dep third_party/dawn

Bug: chromium:345261080
Change-Id: I9ee360934bcbd838d682ffabe5029cc7baecec9b
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6333617
Commit-Queue: Yuly Novikov <ynovikov@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>

Download

src/libANGLE/renderer/wgpu/DisplayWgpu.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.
//
// DisplayWgpu.cpp:
//    Implements the class methods for DisplayWgpu.
//

#include "libANGLE/renderer/wgpu/DisplayWgpu.h"

#include <dawn/dawn_proc.h>

#include "common/debug.h"
#include "common/platform.h"

#include "libANGLE/Display.h"
#include "libANGLE/renderer/wgpu/ContextWgpu.h"
#include "libANGLE/renderer/wgpu/DeviceWgpu.h"
#include "libANGLE/renderer/wgpu/DisplayWgpu_api.h"
#include "libANGLE/renderer/wgpu/ImageWgpu.h"
#include "libANGLE/renderer/wgpu/SurfaceWgpu.h"

namespace rx
{

DisplayWgpu::DisplayWgpu(const egl::DisplayState &state) : DisplayImpl(state) {}

DisplayWgpu::~DisplayWgpu() {}

egl::Error DisplayWgpu::initialize(egl::Display *display)
{
    ANGLE_TRY(createWgpuDevice());

    mQueue = mDevice.GetQueue();
    mFormatTable.initialize();

    mDevice.GetLimits(&mLimitsWgpu);

    webgpu::GenerateCaps(mLimitsWgpu, &mGLCaps, &mGLTextureCaps, &mGLExtensions, &mGLLimitations,
                         &mEGLCaps, &mEGLExtensions, &mMaxSupportedClientVersion);

    return egl::NoError();
}

void DisplayWgpu::terminate() {}

egl::Error DisplayWgpu::makeCurrent(egl::Display *display,
                                    egl::Surface *drawSurface,
                                    egl::Surface *readSurface,
                                    gl::Context *context)
{
    // Ensure that the correct global DebugAnnotator is installed when the end2end tests change
    // the ANGLE back-end (done frequently).
    display->setGlobalDebugAnnotator();

    return egl::NoError();
}

egl::ConfigSet DisplayWgpu::generateConfigs()
{
    egl::Config config;
    config.renderTargetFormat    = GL_BGRA8_EXT;
    config.depthStencilFormat    = GL_DEPTH24_STENCIL8;
    config.bufferSize            = 32;
    config.redSize               = 8;
    config.greenSize             = 8;
    config.blueSize              = 8;
    config.alphaSize             = 8;
    config.alphaMaskSize         = 0;
    config.bindToTextureRGB      = EGL_TRUE;
    config.bindToTextureRGBA     = EGL_TRUE;
    config.colorBufferType       = EGL_RGB_BUFFER;
    config.configCaveat          = EGL_NONE;
    config.conformant            = EGL_OPENGL_ES2_BIT | EGL_OPENGL_ES3_BIT;
    config.depthSize             = 24;
    config.level                 = 0;
    config.matchNativePixmap     = EGL_NONE;
    config.maxPBufferWidth       = 0;
    config.maxPBufferHeight      = 0;
    config.maxPBufferPixels      = 0;
    config.maxSwapInterval       = 1;
    config.minSwapInterval       = 1;
    config.nativeRenderable      = EGL_TRUE;
    config.nativeVisualID        = 0;
    config.nativeVisualType      = EGL_NONE;
    config.renderableType        = EGL_OPENGL_ES2_BIT | EGL_OPENGL_ES3_BIT;
    config.sampleBuffers         = 0;
    config.samples               = 0;
    config.stencilSize           = 8;
    config.surfaceType           = EGL_WINDOW_BIT | EGL_PBUFFER_BIT;
    config.optimalOrientation    = 0;
    config.transparentType       = EGL_NONE;
    config.transparentRedValue   = 0;
    config.transparentGreenValue = 0;
    config.transparentBlueValue  = 0;

    egl::ConfigSet configSet;
    configSet.add(config);
    return configSet;
}

bool DisplayWgpu::testDeviceLost()
{
    return false;
}

egl::Error DisplayWgpu::restoreLostDevice(const egl::Display *display)
{
    return egl::NoError();
}

bool DisplayWgpu::isValidNativeWindow(EGLNativeWindowType window) const
{
    return true;
}

std::string DisplayWgpu::getRendererDescription()
{
    return "Wgpu";
}

std::string DisplayWgpu::getVendorString()
{
    return "Wgpu";
}

std::string DisplayWgpu::getVersionString(bool includeFullVersion)
{
    return std::string();
}

DeviceImpl *DisplayWgpu::createDevice()
{
    return new DeviceWgpu();
}

egl::Error DisplayWgpu::waitClient(const gl::Context *context)
{
    return egl::NoError();
}

egl::Error DisplayWgpu::waitNative(const gl::Context *context, EGLint engine)
{
    return egl::NoError();
}

gl::Version DisplayWgpu::getMaxSupportedESVersion() const
{
    return mMaxSupportedClientVersion;
}

gl::Version DisplayWgpu::getMaxConformantESVersion() const
{
    return mMaxSupportedClientVersion;
}

SurfaceImpl *DisplayWgpu::createWindowSurface(const egl::SurfaceState &state,
                                              EGLNativeWindowType window,
                                              const egl::AttributeMap &attribs)
{
    return CreateWgpuWindowSurface(state, window);
}

SurfaceImpl *DisplayWgpu::createPbufferSurface(const egl::SurfaceState &state,
                                               const egl::AttributeMap &attribs)
{
    return new OffscreenSurfaceWgpu(state);
}

SurfaceImpl *DisplayWgpu::createPbufferFromClientBuffer(const egl::SurfaceState &state,
                                                        EGLenum buftype,
                                                        EGLClientBuffer buffer,
                                                        const egl::AttributeMap &attribs)
{
    UNIMPLEMENTED();
    return nullptr;
}

SurfaceImpl *DisplayWgpu::createPixmapSurface(const egl::SurfaceState &state,
                                              NativePixmapType nativePixmap,
                                              const egl::AttributeMap &attribs)
{
    UNIMPLEMENTED();
    return nullptr;
}

ImageImpl *DisplayWgpu::createImage(const egl::ImageState &state,
                                    const gl::Context *context,
                                    EGLenum target,
                                    const egl::AttributeMap &attribs)
{
    return new ImageWgpu(state);
}

rx::ContextImpl *DisplayWgpu::createContext(const gl::State &state,
                                            gl::ErrorSet *errorSet,
                                            const egl::Config *configuration,
                                            const gl::Context *shareContext,
                                            const egl::AttributeMap &attribs)
{
    return new ContextWgpu(state, errorSet, this);
}

StreamProducerImpl *DisplayWgpu::createStreamProducerD3DTexture(
    egl::Stream::ConsumerType consumerType,
    const egl::AttributeMap &attribs)
{
    UNIMPLEMENTED();
    return nullptr;
}

ShareGroupImpl *DisplayWgpu::createShareGroup(const egl::ShareGroupState &state)
{
    return new ShareGroupWgpu(state);
}

angle::NativeWindowSystem DisplayWgpu::getWindowSystem() const
{
#if defined(ANGLE_PLATFORM_LINUX)
#    if defined(ANGLE_USE_X11)
    return angle::NativeWindowSystem::X11;
#    elif defined(ANGLE_USE_WAYLAND)
    return angle::NativeWindowSystem::Wayland;
#    endif
#else
    return angle::NativeWindowSystem::Other;
#endif
}

void DisplayWgpu::generateExtensions(egl::DisplayExtensions *outExtensions) const
{
    *outExtensions = mEGLExtensions;
}

void DisplayWgpu::generateCaps(egl::Caps *outCaps) const
{
    *outCaps = mEGLCaps;
}

egl::Error DisplayWgpu::createWgpuDevice()
{
    dawnProcSetProcs(&dawn::native::GetProcs());

    dawn::native::DawnInstanceDescriptor dawnInstanceDescriptor;

    wgpu::InstanceDescriptor instanceDescriptor;
    instanceDescriptor.capabilities.timedWaitAnyEnable = true;
    instanceDescriptor.nextInChain                 = &dawnInstanceDescriptor;
    mInstance                                      = wgpu::CreateInstance(&instanceDescriptor);

    struct RequestAdapterResult
    {
        wgpu::RequestAdapterStatus status;
        wgpu::Adapter adapter;
        std::string message;
    };
    RequestAdapterResult adapterResult;

    wgpu::RequestAdapterOptions requestAdapterOptions;

    wgpu::RequestAdapterCallback<RequestAdapterResult *> *requestAdapterCallback =
        [](wgpu::RequestAdapterStatus status, wgpu::Adapter adapter, wgpu::StringView message,
           RequestAdapterResult *result) {
            result->status  = status;
            result->adapter = adapter;
            result->message = message;
        };
    wgpu::FutureWaitInfo futureWaitInfo;
    futureWaitInfo.future =
        mInstance.RequestAdapter(&requestAdapterOptions, wgpu::CallbackMode::WaitAnyOnly,
                                 requestAdapterCallback, &adapterResult);

    wgpu::WaitStatus status = mInstance.WaitAny(1, &futureWaitInfo, -1);
    if (webgpu::IsWgpuError(status))
    {
        std::ostringstream err;
        err << "Failed to get WebGPU adapter: " << adapterResult.message;
        return egl::Error(EGL_BAD_ALLOC, err.str());
    }

    mAdapter = adapterResult.adapter;

    std::vector<wgpu::FeatureName> requiredFeatures;  // empty for now

    wgpu::DeviceDescriptor deviceDesc;
    deviceDesc.requiredFeatureCount = requiredFeatures.size();
    deviceDesc.requiredFeatures     = requiredFeatures.data();
    deviceDesc.SetUncapturedErrorCallback(
        [](const wgpu::Device &device, wgpu::ErrorType type, wgpu::StringView message) {
            ERR() << "Error: " << static_cast<std::underlying_type<wgpu::ErrorType>::type>(type)
                  << " - message: " << std::string(message);
        });

    mDevice = mAdapter.CreateDevice(&deviceDesc);
    return egl::NoError();
}

DisplayImpl *CreateWgpuDisplay(const egl::DisplayState &state)
{
    return new DisplayWgpu(state);
}

}  // namespace rx

Download