src/libANGLE/renderer/wgpu/SurfaceWgpu.cpp - third_party/angle - Git at Google

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