From 9434949241843187fe55ad51f897dcb23b5cd67c Mon Sep 17 00:00:00 2001 From: Stephen White Date: Wed, 29 Jun 2022 15:29:41 +0000 Subject: [PATCH] GL: implement EGL context creation in Dawn native. An abstract base class (Device::Context) is used to avoid adding dependencies to Device, with ContextEGL derived from it. This also leaves open the possibility of supporting other native GL contexts in the future (e.g., glX). One temporary EGLContext is created by opengl::Backend during Adapter discovery, then one is created for and owned by each Device. Contexts for the desktop GL backend are also managed via EGL, which works for most modern drivers. This also means that GLFW is now always used in GLFW_NO_API mode. Since contexts are now per-device, all of the default GL state setting and debug output setup was moved from Adapter to Device. Bug: dawn:810 Change-Id: Idfe30939f155d026fcad549787fc167cc43aa3cb Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/93981 Commit-Queue: Stephen White Reviewed-by: Austin Eng Kokoro: Kokoro --- CMakeLists.txt | 1 + include/dawn/native/OpenGLBackend.h | 7 +- src/dawn/native/BUILD.gn | 5 + src/dawn/native/CMakeLists.txt | 5 + src/dawn/native/opengl/AdapterGL.cpp | 118 ++--------------- src/dawn/native/opengl/AdapterGL.h | 2 + src/dawn/native/opengl/BackendGL.cpp | 56 +++++++- src/dawn/native/opengl/BackendGL.h | 2 + src/dawn/native/opengl/ContextEGL.cpp | 78 +++++++++++ src/dawn/native/opengl/ContextEGL.h | 44 ++++++ src/dawn/native/opengl/DeviceGL.cpp | 125 +++++++++++++++++- src/dawn/native/opengl/DeviceGL.h | 17 ++- src/dawn/native/opengl/EGLFunctions.cpp | 42 ++++++ src/dawn/native/opengl/EGLFunctions.h | 42 ++++++ src/dawn/native/opengl/OpenGLBackend.cpp | 6 +- src/dawn/native/opengl/OpenGLVersion.cpp | 8 +- src/dawn/samples/SampleUtils.cpp | 4 +- src/dawn/tests/DawnTest.cpp | 65 +-------- src/dawn/tests/DawnTest.h | 2 - .../tests/end2end/AdapterDiscoveryTests.cpp | 75 ----------- src/dawn/tests/end2end/SwapChainTests.cpp | 5 +- .../end2end/SwapChainValidationTests.cpp | 5 +- src/dawn/tests/end2end/WindowSurfaceTests.cpp | 4 +- src/dawn/utils/BackendBinding.cpp | 29 ---- src/dawn/utils/GLFWUtils.cpp | 20 --- src/dawn/utils/GLFWUtils.h | 4 - 26 files changed, 438 insertions(+), 333 deletions(-) create mode 100644 src/dawn/native/opengl/ContextEGL.cpp create mode 100644 src/dawn/native/opengl/ContextEGL.h create mode 100644 src/dawn/native/opengl/EGLFunctions.cpp create mode 100644 src/dawn/native/opengl/EGLFunctions.h diff --git a/CMakeLists.txt b/CMakeLists.txt index ad25ae035d..62d3a935fa 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -174,6 +174,7 @@ set_if_not_defined(DAWN_THIRD_PARTY_DIR "${Dawn_SOURCE_DIR}/third_party" "Direct set_if_not_defined(DAWN_ABSEIL_DIR "${DAWN_THIRD_PARTY_DIR}/abseil-cpp" "Directory in which to find Abseil") set_if_not_defined(DAWN_GLFW_DIR "${DAWN_THIRD_PARTY_DIR}/glfw" "Directory in which to find GLFW") set_if_not_defined(DAWN_JINJA2_DIR "${DAWN_THIRD_PARTY_DIR}/jinja2" "Directory in which to find Jinja2") +set_if_not_defined(DAWN_KHRONOS_DIR "${DAWN_THIRD_PARTY_DIR}/khronos" "Directory in which to find Khronos GL headers") set_if_not_defined(DAWN_SPIRV_HEADERS_DIR "${DAWN_THIRD_PARTY_DIR}/vulkan-deps/spirv-headers/src" "Directory in which to find SPIRV-Headers") set_if_not_defined(DAWN_SPIRV_TOOLS_DIR "${DAWN_THIRD_PARTY_DIR}/vulkan-deps/spirv-tools/src" "Directory in which to find SPIRV-Tools") set_if_not_defined(DAWN_SWIFTSHADER_DIR "${DAWN_THIRD_PARTY_DIR}/swiftshader" "Directory in which to find swiftshader") diff --git a/include/dawn/native/OpenGLBackend.h b/include/dawn/native/OpenGLBackend.h index bee9daeae9..cceaab85e7 100644 --- a/include/dawn/native/OpenGLBackend.h +++ b/include/dawn/native/OpenGLBackend.h @@ -23,15 +23,14 @@ typedef void* EGLImage; namespace dawn::native::opengl { struct DAWN_NATIVE_EXPORT AdapterDiscoveryOptions : public AdapterDiscoveryOptionsBase { - AdapterDiscoveryOptions(); + explicit AdapterDiscoveryOptions(WGPUBackendType type); void* (*getProc)(const char*); }; -struct DAWN_NATIVE_EXPORT AdapterDiscoveryOptionsES : public AdapterDiscoveryOptionsBase { +// TODO(crbug.com/dawn/810): This struct can be removed once Chrome is no longer using it. +struct DAWN_NATIVE_EXPORT AdapterDiscoveryOptionsES : public AdapterDiscoveryOptions { AdapterDiscoveryOptionsES(); - - void* (*getProc)(const char*); }; using PresentCallback = void (*)(void*); diff --git a/src/dawn/native/BUILD.gn b/src/dawn/native/BUILD.gn index 137ce1b2dd..8f9f059d8e 100644 --- a/src/dawn/native/BUILD.gn +++ b/src/dawn/native/BUILD.gn @@ -540,8 +540,12 @@ source_set("sources") { "opengl/CommandBufferGL.h", "opengl/ComputePipelineGL.cpp", "opengl/ComputePipelineGL.h", + "opengl/ContextEGL.cpp", + "opengl/ContextEGL.h", "opengl/DeviceGL.cpp", "opengl/DeviceGL.h", + "opengl/EGLFunctions.cpp", + "opengl/EGLFunctions.h", "opengl/Forward.h", "opengl/GLFormat.cpp", "opengl/GLFormat.h", @@ -575,6 +579,7 @@ source_set("sources") { "opengl/UtilsGL.h", "opengl/opengl_platform.h", ] + include_dirs = [ "//third_party/khronos" ] } if (dawn_enable_vulkan) { diff --git a/src/dawn/native/CMakeLists.txt b/src/dawn/native/CMakeLists.txt index 8542b337e9..a523393e2b 100644 --- a/src/dawn/native/CMakeLists.txt +++ b/src/dawn/native/CMakeLists.txt @@ -418,8 +418,12 @@ if (DAWN_ENABLE_OPENGL) "opengl/CommandBufferGL.h" "opengl/ComputePipelineGL.cpp" "opengl/ComputePipelineGL.h" + "opengl/ContextEGL.cpp" + "opengl/ContextEGL.h" "opengl/DeviceGL.cpp" "opengl/DeviceGL.h" + "opengl/EGLFunctions.cpp" + "opengl/EGLFunctions.h" "opengl/Forward.h" "opengl/GLFormat.cpp" "opengl/GLFormat.h" @@ -454,6 +458,7 @@ if (DAWN_ENABLE_OPENGL) "opengl/opengl_platform.h" ) + target_include_directories(dawn_native PRIVATE ${DAWN_KHRONOS_DIR}) target_link_libraries(dawn_native PRIVATE dawn_khronos_platform) endif() diff --git a/src/dawn/native/opengl/AdapterGL.cpp b/src/dawn/native/opengl/AdapterGL.cpp index eca46c1ed5..9f9d4ba4d5 100644 --- a/src/dawn/native/opengl/AdapterGL.cpp +++ b/src/dawn/native/opengl/AdapterGL.cpp @@ -14,11 +14,13 @@ #include "dawn/native/opengl/AdapterGL.h" +#include #include +#include #include "dawn/common/GPUInfo.h" -#include "dawn/common/Log.h" #include "dawn/native/Instance.h" +#include "dawn/native/opengl/ContextEGL.h" #include "dawn/native/opengl/DeviceGL.h" namespace dawn::native::opengl { @@ -49,69 +51,6 @@ uint32_t GetVendorIdFromVendors(const char* vendor) { return vendorId; } -void KHRONOS_APIENTRY OnGLDebugMessage(GLenum source, - GLenum type, - GLuint id, - GLenum severity, - GLsizei length, - const GLchar* message, - const void* userParam) { - const char* sourceText; - switch (source) { - case GL_DEBUG_SOURCE_API: - sourceText = "OpenGL"; - break; - case GL_DEBUG_SOURCE_WINDOW_SYSTEM: - sourceText = "Window System"; - break; - case GL_DEBUG_SOURCE_SHADER_COMPILER: - sourceText = "Shader Compiler"; - break; - case GL_DEBUG_SOURCE_THIRD_PARTY: - sourceText = "Third Party"; - break; - case GL_DEBUG_SOURCE_APPLICATION: - sourceText = "Application"; - break; - case GL_DEBUG_SOURCE_OTHER: - sourceText = "Other"; - break; - default: - sourceText = "UNKNOWN"; - break; - } - - const char* severityText; - switch (severity) { - case GL_DEBUG_SEVERITY_HIGH: - severityText = "High"; - break; - case GL_DEBUG_SEVERITY_MEDIUM: - severityText = "Medium"; - break; - case GL_DEBUG_SEVERITY_LOW: - severityText = "Low"; - break; - case GL_DEBUG_SEVERITY_NOTIFICATION: - severityText = "Notification"; - break; - default: - severityText = "UNKNOWN"; - break; - } - - if (type == GL_DEBUG_TYPE_ERROR) { - dawn::WarningLog() << "OpenGL error:" - << "\n Source: " << sourceText // - << "\n ID: " << id // - << "\n Severity: " << severityText // - << "\n Message: " << message; - - // Abort on an error when in Debug mode. - UNREACHABLE(); - } -} - } // anonymous namespace Adapter::Adapter(InstanceBase* instance, wgpu::BackendType backendType) @@ -119,6 +58,7 @@ Adapter::Adapter(InstanceBase* instance, wgpu::BackendType backendType) MaybeError Adapter::InitializeGLFunctions(void* (*getProc)(const char*)) { // Use getProc to populate the dispatch table + mEGLFunctions.Init(getProc); return mFunctions.Initialize(getProc); } @@ -134,47 +74,6 @@ MaybeError Adapter::InitializeImpl() { ASSERT(GetBackendType() == wgpu::BackendType::OpenGL); } - // Use the debug output functionality to get notified about GL errors - // TODO(cwallez@chromium.org): add support for the KHR_debug and ARB_debug_output - // extensions - bool hasDebugOutput = mFunctions.IsAtLeastGL(4, 3) || mFunctions.IsAtLeastGLES(3, 2); - - if (GetInstance()->IsBackendValidationEnabled() && hasDebugOutput) { - mFunctions.Enable(GL_DEBUG_OUTPUT); - mFunctions.Enable(GL_DEBUG_OUTPUT_SYNCHRONOUS); - - // Any GL error; dangerous undefined behavior; any shader compiler and linker errors - mFunctions.DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_HIGH, 0, - nullptr, GL_TRUE); - - // Severe performance warnings; GLSL or other shader compiler and linker warnings; - // use of currently deprecated behavior - mFunctions.DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_MEDIUM, 0, - nullptr, GL_TRUE); - - // Performance warnings from redundant state changes; trivial undefined behavior - // This is disabled because we do an incredible amount of redundant state changes. - mFunctions.DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_LOW, 0, - nullptr, GL_FALSE); - - // Any message which is not an error or performance concern - mFunctions.DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, - 0, nullptr, GL_FALSE); - mFunctions.DebugMessageCallback(&OnGLDebugMessage, nullptr); - } - - // Set state that never changes between devices. - mFunctions.Enable(GL_DEPTH_TEST); - mFunctions.Enable(GL_SCISSOR_TEST); - mFunctions.Enable(GL_PRIMITIVE_RESTART_FIXED_INDEX); - if (mFunctions.GetVersion().IsDesktop()) { - // These are not necessary on GLES. The functionality is enabled by default, and - // works by specifying sample counts and SRGB textures, respectively. - mFunctions.Enable(GL_MULTISAMPLE); - mFunctions.Enable(GL_FRAMEBUFFER_SRGB); - } - mFunctions.Enable(GL_SAMPLE_MASK); - mName = reinterpret_cast(mFunctions.GetString(GL_RENDERER)); // Workaroud to find vendor id from vendor name @@ -251,9 +150,12 @@ MaybeError Adapter::InitializeSupportedLimitsImpl(CombinedLimits* limits) { } ResultOrError> Adapter::CreateDeviceImpl(const DeviceDescriptor* descriptor) { - // There is no limit on the number of devices created from this adapter because they can - // all share the same backing OpenGL context. - return Device::Create(this, descriptor, mFunctions); + EGLenum api = + GetBackendType() == wgpu::BackendType::OpenGL ? EGL_OPENGL_API : EGL_OPENGL_ES_API; + + std::unique_ptr context = ContextEGL::Create(mEGLFunctions, api); + + return Device::Create(this, descriptor, mFunctions, std::move(context)); } } // namespace dawn::native::opengl diff --git a/src/dawn/native/opengl/AdapterGL.h b/src/dawn/native/opengl/AdapterGL.h index 41018872d7..6e354b2d03 100644 --- a/src/dawn/native/opengl/AdapterGL.h +++ b/src/dawn/native/opengl/AdapterGL.h @@ -16,6 +16,7 @@ #define SRC_DAWN_NATIVE_OPENGL_ADAPTERGL_H_ #include "dawn/native/Adapter.h" +#include "dawn/native/opengl/EGLFunctions.h" #include "dawn/native/opengl/OpenGLFunctions.h" namespace dawn::native::opengl { @@ -38,6 +39,7 @@ class Adapter : public AdapterBase { ResultOrError> CreateDeviceImpl(const DeviceDescriptor* descriptor) override; OpenGLFunctions mFunctions; + EGLFunctions mEGLFunctions; }; } // namespace dawn::native::opengl diff --git a/src/dawn/native/opengl/BackendGL.cpp b/src/dawn/native/opengl/BackendGL.cpp index c4b877667a..3fad08f5b3 100644 --- a/src/dawn/native/opengl/BackendGL.cpp +++ b/src/dawn/native/opengl/BackendGL.cpp @@ -14,10 +14,17 @@ #include "dawn/native/opengl/BackendGL.h" +#include + +#include #include +#include "dawn/common/SystemUtils.h" +#include "dawn/native/Instance.h" #include "dawn/native/OpenGLBackend.h" #include "dawn/native/opengl/AdapterGL.h" +#include "dawn/native/opengl/ContextEGL.h" +#include "dawn/native/opengl/EGLFunctions.h" namespace dawn::native::opengl { @@ -27,8 +34,53 @@ Backend::Backend(InstanceBase* instance, wgpu::BackendType backendType) : BackendConnection(instance, backendType) {} std::vector> Backend::DiscoverDefaultAdapters() { - // The OpenGL backend needs at least "getProcAddress" to discover an adapter. - return {}; + std::vector> adapters; +#if DAWN_PLATFORM_IS(WINDOWS) + const char* eglLib = "libEGL.dll"; +#elif DAWN_PLATFORM_IS(MACOS) + const char* eglLib = "libEGL.dylib"; +#else + const char* eglLib = "libEGL.so"; +#endif + if (!mLibEGL.Valid() && !mLibEGL.Open(eglLib)) { + return {}; + } + + AdapterDiscoveryOptions options(ToAPI(GetType())); + options.getProc = + reinterpret_cast(mLibEGL.GetProc("eglGetProcAddress")); + if (!options.getProc) { + return {}; + } + + EGLFunctions egl; + egl.Init(options.getProc); + + EGLenum api = GetType() == wgpu::BackendType::OpenGLES ? EGL_OPENGL_ES_API : EGL_OPENGL_API; + std::unique_ptr context = ContextEGL::Create(egl, api); + if (!context) { + return {}; + } + + EGLDisplay prevDisplay = egl.GetCurrentDisplay(); + EGLContext prevDrawSurface = egl.GetCurrentSurface(EGL_DRAW); + EGLContext prevReadSurface = egl.GetCurrentSurface(EGL_READ); + EGLContext prevContext = egl.GetCurrentContext(); + + context->MakeCurrent(); + + auto result = DiscoverAdapters(&options); + + if (result.IsError()) { + GetInstance()->ConsumedError(result.AcquireError()); + } else { + auto value = result.AcquireSuccess(); + adapters.insert(adapters.end(), value.begin(), value.end()); + } + + egl.MakeCurrent(prevDisplay, prevDrawSurface, prevReadSurface, prevContext); + + return adapters; } ResultOrError>> Backend::DiscoverAdapters( diff --git a/src/dawn/native/opengl/BackendGL.h b/src/dawn/native/opengl/BackendGL.h index 591672809e..dc8fea5d6c 100644 --- a/src/dawn/native/opengl/BackendGL.h +++ b/src/dawn/native/opengl/BackendGL.h @@ -17,6 +17,7 @@ #include +#include "dawn/common/DynamicLib.h" #include "dawn/native/BackendConnection.h" namespace dawn::native::opengl { @@ -31,6 +32,7 @@ class Backend : public BackendConnection { private: bool mCreatedAdapter = false; + DynamicLib mLibEGL; }; } // namespace dawn::native::opengl diff --git a/src/dawn/native/opengl/ContextEGL.cpp b/src/dawn/native/opengl/ContextEGL.cpp new file mode 100644 index 0000000000..795b3c0178 --- /dev/null +++ b/src/dawn/native/opengl/ContextEGL.cpp @@ -0,0 +1,78 @@ +// Copyright 2022 The Dawn Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "dawn/native/opengl/ContextEGL.h" + +#include +#include + +namespace dawn::native::opengl { + +std::unique_ptr ContextEGL::Create(const EGLFunctions& egl, EGLenum api) { + EGLDisplay display = egl.GetCurrentDisplay(); + + if (display == EGL_NO_DISPLAY) { + display = egl.GetDisplay(EGL_DEFAULT_DISPLAY); + } + + if (display == EGL_NO_DISPLAY) { + return nullptr; + } + + EGLint renderableType = api == EGL_OPENGL_ES_API ? EGL_OPENGL_ES3_BIT : EGL_OPENGL_BIT; + + egl.Initialize(display, nullptr, nullptr); + + // Since we're creating a surfaceless context, the only thing we really care + // about is the RENDERABLE_TYPE. + EGLint config_attribs[] = {EGL_RENDERABLE_TYPE, renderableType, EGL_NONE}; + + EGLint num_config; + EGLConfig config; + if (egl.ChooseConfig(display, config_attribs, &config, 1, &num_config) == EGL_FALSE) { + return nullptr; + } + + if (!egl.BindAPI(api)) { + return nullptr; + } + + EGLint major, minor; + if (api == EGL_OPENGL_ES_API) { + major = 3; + minor = 1; + } else { + major = 4; + minor = 4; + } + EGLint attrib_list[] = { + EGL_CONTEXT_MAJOR_VERSION, major, EGL_CONTEXT_MINOR_VERSION, minor, EGL_NONE, EGL_NONE, + }; + EGLContext context = egl.CreateContext(display, config, EGL_NO_CONTEXT, attrib_list); + if (!context) { + return nullptr; + } + + return std::unique_ptr(new ContextEGL(egl, display, context)); +} + +void ContextEGL::MakeCurrent() { + egl.MakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, mContext); +} + +ContextEGL::~ContextEGL() { + egl.DestroyContext(mDisplay, mContext); +} + +} // namespace dawn::native::opengl diff --git a/src/dawn/native/opengl/ContextEGL.h b/src/dawn/native/opengl/ContextEGL.h new file mode 100644 index 0000000000..df5a146457 --- /dev/null +++ b/src/dawn/native/opengl/ContextEGL.h @@ -0,0 +1,44 @@ +// Copyright 2022 The Dawn Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef SRC_DAWN_NATIVE_OPENGL_CONTEXTEGL_H_ +#define SRC_DAWN_NATIVE_OPENGL_CONTEXTEGL_H_ + +#include + +#include + +#include "dawn/native/opengl/DeviceGL.h" +#include "dawn/native/opengl/EGLFunctions.h" + +namespace dawn::native::opengl { + +class ContextEGL : public Device::Context { + public: + static std::unique_ptr Create(const EGLFunctions& functions, EGLenum api); + void MakeCurrent() override; + ~ContextEGL() override; + + private: + ContextEGL(const EGLFunctions& functions, EGLDisplay display, EGLContext context) + : egl(functions), mDisplay(display), mContext(context) {} + + const EGLFunctions egl; + EGLDisplay mDisplay; + EGLContext mContext; +}; + +} // namespace dawn::native::opengl + +#endif // SRC_DAWN_NATIVE_OPENGL_CONTEXTEGL_H_ diff --git a/src/dawn/native/opengl/DeviceGL.cpp b/src/dawn/native/opengl/DeviceGL.cpp index fbceac9108..35ff4efd73 100644 --- a/src/dawn/native/opengl/DeviceGL.cpp +++ b/src/dawn/native/opengl/DeviceGL.cpp @@ -14,9 +14,12 @@ #include "dawn/native/opengl/DeviceGL.h" +#include "dawn/common/Log.h" + #include "dawn/native/BackendConnection.h" #include "dawn/native/BindGroupLayout.h" #include "dawn/native/ErrorData.h" +#include "dawn/native/Instance.h" #include "dawn/native/StagingBuffer.h" #include "dawn/native/opengl/BindGroupGL.h" #include "dawn/native/opengl/BindGroupLayoutGL.h" @@ -32,30 +35,141 @@ #include "dawn/native/opengl/SwapChainGL.h" #include "dawn/native/opengl/TextureGL.h" +namespace { + +void KHRONOS_APIENTRY OnGLDebugMessage(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar* message, + const void* userParam) { + const char* sourceText; + switch (source) { + case GL_DEBUG_SOURCE_API: + sourceText = "OpenGL"; + break; + case GL_DEBUG_SOURCE_WINDOW_SYSTEM: + sourceText = "Window System"; + break; + case GL_DEBUG_SOURCE_SHADER_COMPILER: + sourceText = "Shader Compiler"; + break; + case GL_DEBUG_SOURCE_THIRD_PARTY: + sourceText = "Third Party"; + break; + case GL_DEBUG_SOURCE_APPLICATION: + sourceText = "Application"; + break; + case GL_DEBUG_SOURCE_OTHER: + sourceText = "Other"; + break; + default: + sourceText = "UNKNOWN"; + break; + } + + const char* severityText; + switch (severity) { + case GL_DEBUG_SEVERITY_HIGH: + severityText = "High"; + break; + case GL_DEBUG_SEVERITY_MEDIUM: + severityText = "Medium"; + break; + case GL_DEBUG_SEVERITY_LOW: + severityText = "Low"; + break; + case GL_DEBUG_SEVERITY_NOTIFICATION: + severityText = "Notification"; + break; + default: + severityText = "UNKNOWN"; + break; + } + + if (type == GL_DEBUG_TYPE_ERROR) { + dawn::WarningLog() << "OpenGL error:" + << "\n Source: " << sourceText // + << "\n ID: " << id // + << "\n Severity: " << severityText // + << "\n Message: " << message; + + // Abort on an error when in Debug mode. + UNREACHABLE(); + } +} + +} // anonymous namespace + namespace dawn::native::opengl { // static ResultOrError> Device::Create(AdapterBase* adapter, const DeviceDescriptor* descriptor, - const OpenGLFunctions& functions) { - Ref device = AcquireRef(new Device(adapter, descriptor, functions)); + const OpenGLFunctions& functions, + std::unique_ptr context) { + Ref device = AcquireRef(new Device(adapter, descriptor, functions, std::move(context))); DAWN_TRY(device->Initialize(descriptor)); return device; } Device::Device(AdapterBase* adapter, const DeviceDescriptor* descriptor, - const OpenGLFunctions& functions) - : DeviceBase(adapter, descriptor), mGL(functions) {} + const OpenGLFunctions& functions, + std::unique_ptr context) + : DeviceBase(adapter, descriptor), mGL(functions), mContext(std::move(context)) {} Device::~Device() { Destroy(); } MaybeError Device::Initialize(const DeviceDescriptor* descriptor) { + const OpenGLFunctions& gl = GetGL(); InitTogglesFromDriver(); mFormatTable = BuildGLFormatTable(GetBGRAInternalFormat()); + // Use the debug output functionality to get notified about GL errors + // TODO(crbug.com/dawn/1475): add support for the KHR_debug and ARB_debug_output + // extensions + bool hasDebugOutput = gl.IsAtLeastGL(4, 3) || gl.IsAtLeastGLES(3, 2); + + if (GetAdapter()->GetInstance()->IsBackendValidationEnabled() && hasDebugOutput) { + gl.Enable(GL_DEBUG_OUTPUT); + gl.Enable(GL_DEBUG_OUTPUT_SYNCHRONOUS); + + // Any GL error; dangerous undefined behavior; any shader compiler and linker errors + gl.DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_HIGH, 0, nullptr, + GL_TRUE); + + // Severe performance warnings; GLSL or other shader compiler and linker warnings; + // use of currently deprecated behavior + gl.DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_MEDIUM, 0, nullptr, + GL_TRUE); + + // Performance warnings from redundant state changes; trivial undefined behavior + // This is disabled because we do an incredible amount of redundant state changes. + gl.DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_LOW, 0, nullptr, + GL_FALSE); + + // Any message which is not an error or performance concern + gl.DebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, 0, + nullptr, GL_FALSE); + gl.DebugMessageCallback(&OnGLDebugMessage, nullptr); + } + + // Set initial state. + gl.Enable(GL_DEPTH_TEST); + gl.Enable(GL_SCISSOR_TEST); + gl.Enable(GL_PRIMITIVE_RESTART_FIXED_INDEX); + if (gl.GetVersion().IsDesktop()) { + // These are not necessary on GLES. The functionality is enabled by default, and + // works by specifying sample counts and SRGB textures, respectively. + gl.Enable(GL_MULTISAMPLE); + gl.Enable(GL_FRAMEBUFFER_SRGB); + } + gl.Enable(GL_SAMPLE_MASK); + return DeviceBase::Initialize(AcquireRef(new Queue(this, &descriptor->defaultQueue))); } @@ -340,6 +454,9 @@ float Device::GetTimestampPeriodInNS() const { } const OpenGLFunctions& Device::GetGL() const { + if (mContext) { + mContext->MakeCurrent(); + } return mGL; } diff --git a/src/dawn/native/opengl/DeviceGL.h b/src/dawn/native/opengl/DeviceGL.h index b80439f1bc..78abf1147a 100644 --- a/src/dawn/native/opengl/DeviceGL.h +++ b/src/dawn/native/opengl/DeviceGL.h @@ -39,14 +39,17 @@ namespace dawn::native::opengl { class Device final : public DeviceBase { public: + class Context; static ResultOrError> Create(AdapterBase* adapter, const DeviceDescriptor* descriptor, - const OpenGLFunctions& functions); + const OpenGLFunctions& functions, + std::unique_ptr context); ~Device() override; MaybeError Initialize(const DeviceDescriptor* descriptor); - // Contains all the OpenGL entry points, glDoFoo is called via gl.DoFoo. + // Returns all the OpenGL entry points and ensures that the associated + // Context is current. const OpenGLFunctions& GetGL() const; const GLFormat& GetGLFormat(const Format& format); @@ -80,10 +83,17 @@ class Device final : public DeviceBase { float GetTimestampPeriodInNS() const override; + class Context { + public: + virtual ~Context() {} + virtual void MakeCurrent() = 0; + }; + private: Device(AdapterBase* adapter, const DeviceDescriptor* descriptor, - const OpenGLFunctions& functions); + const OpenGLFunctions& functions, + std::unique_ptr context); ResultOrError> CreateBindGroupImpl( const BindGroupDescriptor* descriptor) override; @@ -126,6 +136,7 @@ class Device final : public DeviceBase { std::queue> mFencesInFlight; GLFormatTable mFormatTable; + std::unique_ptr mContext = nullptr; }; } // namespace dawn::native::opengl diff --git a/src/dawn/native/opengl/EGLFunctions.cpp b/src/dawn/native/opengl/EGLFunctions.cpp new file mode 100644 index 0000000000..75fd25b457 --- /dev/null +++ b/src/dawn/native/opengl/EGLFunctions.cpp @@ -0,0 +1,42 @@ +// Copyright 2022 The Dawn Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "dawn/native/opengl/EGLFunctions.h" + +namespace dawn::native::opengl { + +void EGLFunctions::Init(void* (*getProc)(const char*)) { + GetProcAddress = reinterpret_cast(getProc); + BindAPI = reinterpret_cast(GetProcAddress("eglBindAPI")); + ChooseConfig = reinterpret_cast(GetProcAddress("eglChooseConfig")); + CreateContext = reinterpret_cast(GetProcAddress("eglCreateContext")); + CreatePbufferSurface = + reinterpret_cast(GetProcAddress("eglCreatePbufferSurface")); + CreatePlatformWindowSurface = reinterpret_cast( + GetProcAddress("eglCreatePlatformWindowSurface")); + DestroyContext = + reinterpret_cast(GetProcAddress("eglDestroyContext")); + GetConfigs = reinterpret_cast(GetProcAddress("eglGetConfigs")); + GetCurrentContext = + reinterpret_cast(GetProcAddress("eglGetCurrentContext")); + GetCurrentDisplay = + reinterpret_cast(GetProcAddress("eglGetCurrentDisplay")); + GetCurrentSurface = + reinterpret_cast(GetProcAddress("eglGetCurrentSurface")); + GetDisplay = reinterpret_cast(GetProcAddress("eglGetDisplay")); + Initialize = reinterpret_cast(GetProcAddress("eglInitialize")); + MakeCurrent = reinterpret_cast(GetProcAddress("eglMakeCurrent")); +} + +} // namespace dawn::native::opengl diff --git a/src/dawn/native/opengl/EGLFunctions.h b/src/dawn/native/opengl/EGLFunctions.h new file mode 100644 index 0000000000..e73e6e9f56 --- /dev/null +++ b/src/dawn/native/opengl/EGLFunctions.h @@ -0,0 +1,42 @@ +// Copyright 2022 The Dawn Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef SRC_DAWN_NATIVE_OPENGL_EGLFUNCTIONS_H_ +#define SRC_DAWN_NATIVE_OPENGL_EGLFUNCTIONS_H_ + +#include + +namespace dawn::native::opengl { + +struct EGLFunctions { + void Init(void* (*getProc)(const char*)); + PFNEGLBINDAPIPROC BindAPI; + PFNEGLCHOOSECONFIGPROC ChooseConfig; + PFNEGLCREATECONTEXTPROC CreateContext; + PFNEGLCREATEPLATFORMWINDOWSURFACEPROC CreatePlatformWindowSurface; + PFNEGLCREATEPBUFFERSURFACEPROC CreatePbufferSurface; + PFNEGLDESTROYCONTEXTPROC DestroyContext; + PFNEGLGETCONFIGSPROC GetConfigs; + PFNEGLGETCURRENTCONTEXTPROC GetCurrentContext; + PFNEGLGETCURRENTDISPLAYPROC GetCurrentDisplay; + PFNEGLGETCURRENTSURFACEPROC GetCurrentSurface; + PFNEGLGETDISPLAYPROC GetDisplay; + PFNEGLGETPROCADDRESSPROC GetProcAddress; + PFNEGLINITIALIZEPROC Initialize; + PFNEGLMAKECURRENTPROC MakeCurrent; +}; + +} // namespace dawn::native::opengl + +#endif // SRC_DAWN_NATIVE_OPENGL_EGLFUNCTIONS_H_ diff --git a/src/dawn/native/opengl/OpenGLBackend.cpp b/src/dawn/native/opengl/OpenGLBackend.cpp index c77c1d0f79..87cd37f765 100644 --- a/src/dawn/native/opengl/OpenGLBackend.cpp +++ b/src/dawn/native/opengl/OpenGLBackend.cpp @@ -23,11 +23,11 @@ namespace dawn::native::opengl { -AdapterDiscoveryOptions::AdapterDiscoveryOptions() - : AdapterDiscoveryOptionsBase(WGPUBackendType_OpenGL) {} +AdapterDiscoveryOptions::AdapterDiscoveryOptions(WGPUBackendType type) + : AdapterDiscoveryOptionsBase(type) {} AdapterDiscoveryOptionsES::AdapterDiscoveryOptionsES() - : AdapterDiscoveryOptionsBase(WGPUBackendType_OpenGLES) {} + : AdapterDiscoveryOptions(WGPUBackendType_OpenGLES) {} DawnSwapChainImplementation CreateNativeSwapChainImpl(WGPUDevice device, PresentCallback present, diff --git a/src/dawn/native/opengl/OpenGLVersion.cpp b/src/dawn/native/opengl/OpenGLVersion.cpp index 297b5fb7b6..2c3f0a981e 100644 --- a/src/dawn/native/opengl/OpenGLVersion.cpp +++ b/src/dawn/native/opengl/OpenGLVersion.cpp @@ -26,9 +26,9 @@ MaybeError OpenGLVersion::Initialize(GetProcAddress getProc) { return DAWN_INTERNAL_ERROR("Couldn't load glGetString"); } - std::string version = reinterpret_cast(getString(GL_VERSION)); + const char* version = reinterpret_cast(getString(GL_VERSION)); - if (version.find("OpenGL ES") != std::string::npos) { + if (strstr(version, "OpenGL ES") != nullptr) { // ES spec states that the GL_VERSION string will be in the following format: // "OpenGL ES N.M vendor-specific information" mStandard = Standard::ES; @@ -36,7 +36,7 @@ MaybeError OpenGLVersion::Initialize(GetProcAddress getProc) { mMinorVersion = version[12] - '0'; // The minor version shouldn't get to two digits. - ASSERT(version.size() <= 13 || !isdigit(version[13])); + ASSERT(strlen(version) <= 13 || !isdigit(version[13])); } else { // OpenGL spec states the GL_VERSION string will be in the following format: // @@ -48,7 +48,7 @@ MaybeError OpenGLVersion::Initialize(GetProcAddress getProc) { mMinorVersion = version[2] - '0'; // The minor version shouldn't get to two digits. - ASSERT(version.size() <= 3 || !isdigit(version[3])); + ASSERT(strlen(version) <= 3 || !isdigit(version[3])); } return {}; diff --git a/src/dawn/samples/SampleUtils.cpp b/src/dawn/samples/SampleUtils.cpp index ac102a67d6..c6036c7727 100644 --- a/src/dawn/samples/SampleUtils.cpp +++ b/src/dawn/samples/SampleUtils.cpp @@ -103,8 +103,8 @@ wgpu::Device CreateCppDawnDevice() { return wgpu::Device(); } - // Create the test window and discover adapters using it (esp. for OpenGL) - utils::SetupGLFWWindowHintsForBackend(backendType); + // Create the test window with no client API. + glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); glfwWindowHint(GLFW_COCOA_RETINA_FRAMEBUFFER, GLFW_FALSE); window = glfwCreateWindow(640, 480, "Dawn window", nullptr, nullptr); if (!window) { diff --git a/src/dawn/tests/DawnTest.cpp b/src/dawn/tests/DawnTest.cpp index dfd2c54bf4..605ced5c5d 100644 --- a/src/dawn/tests/DawnTest.cpp +++ b/src/dawn/tests/DawnTest.cpp @@ -422,31 +422,8 @@ std::unique_ptr DawnTestEnvironment::CreateInstanceAndDi auto instance = std::make_unique(); instance->EnableBeginCaptureOnStartup(mBeginCaptureOnStartup); instance->SetBackendValidationLevel(mBackendValidationLevel); - instance->DiscoverDefaultAdapters(); - -#ifdef DAWN_ENABLE_BACKEND_DESKTOP_GL - if (!glfwInit()) { - return instance; - } - glfwDefaultWindowHints(); - glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); - glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 4); - glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE); - glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); - glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); - - mOpenGLWindow = glfwCreateWindow(400, 400, "Dawn OpenGL test window", nullptr, nullptr); - if (mOpenGLWindow != nullptr) { - glfwMakeContextCurrent(mOpenGLWindow); - dawn::native::opengl::AdapterDiscoveryOptions adapterOptions; - adapterOptions.getProc = reinterpret_cast(glfwGetProcAddress); - instance->DiscoverAdapters(&adapterOptions); - } -#endif // DAWN_ENABLE_BACKEND_DESKTOP_GL #ifdef DAWN_ENABLE_BACKEND_OPENGLES - - ScopedEnvironmentVar angleDefaultPlatform; if (GetEnvironmentVar("ANGLE_DEFAULT_PLATFORM").first.empty()) { const char* platform; if (!mANGLEBackend.empty()) { @@ -458,40 +435,15 @@ std::unique_ptr DawnTestEnvironment::CreateInstanceAndDi platform = "swiftshader"; #endif } - angleDefaultPlatform.Set("ANGLE_DEFAULT_PLATFORM", platform); - } - - if (!glfwInit()) { - return instance; - } - glfwDefaultWindowHints(); - glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); - glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1); - glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API); - glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API); - glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); - - mOpenGLESWindow = glfwCreateWindow(400, 400, "Dawn OpenGLES test window", nullptr, nullptr); - if (mOpenGLESWindow != nullptr) { - glfwMakeContextCurrent(mOpenGLESWindow); - dawn::native::opengl::AdapterDiscoveryOptionsES adapterOptionsES; - adapterOptionsES.getProc = reinterpret_cast(glfwGetProcAddress); - instance->DiscoverAdapters(&adapterOptionsES); - glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE); + SetEnvironmentVar("ANGLE_DEFAULT_PLATFORM", platform); } #endif // DAWN_ENABLE_BACKEND_OPENGLES + instance->DiscoverDefaultAdapters(); + return instance; } -GLFWwindow* DawnTestEnvironment::GetOpenGLWindow() const { - return mOpenGLWindow; -} - -GLFWwindow* DawnTestEnvironment::GetOpenGLESWindow() const { - return mOpenGLESWindow; -} - void DawnTestEnvironment::SelectPreferredAdapterProperties(const dawn::native::Instance* instance) { // Get the first available preferred device type. wgpu::AdapterType preferredDeviceType = static_cast(-1); @@ -1129,17 +1081,6 @@ void DawnTestBase::SetUp() { ASSERT(device); queue = device.GetQueue(); - -#if defined(DAWN_ENABLE_BACKEND_DESKTOP_GL) - if (IsOpenGL()) { - glfwMakeContextCurrent(gTestEnv->GetOpenGLWindow()); - } -#endif // defined(DAWN_ENABLE_BACKEND_DESKTOP_GL) -#if defined(DAWN_ENABLE_BACKEND_OPENGLES) - if (IsOpenGLES()) { - glfwMakeContextCurrent(gTestEnv->GetOpenGLESWindow()); - } -#endif // defined(DAWN_ENABLE_BACKEND_OPENGLES) } void DawnTestBase::TearDown() { diff --git a/src/dawn/tests/DawnTest.h b/src/dawn/tests/DawnTest.h index e54ff74774..6cbbfe8765 100644 --- a/src/dawn/tests/DawnTest.h +++ b/src/dawn/tests/DawnTest.h @@ -273,8 +273,6 @@ class DawnTestEnvironment : public testing::Environment { std::vector mAdapterProperties; std::unique_ptr mPlatformDebugLogger; - GLFWwindow* mOpenGLWindow; - GLFWwindow* mOpenGLESWindow; }; class DawnTestBase { diff --git a/src/dawn/tests/end2end/AdapterDiscoveryTests.cpp b/src/dawn/tests/end2end/AdapterDiscoveryTests.cpp index 727290383e..7f3669a4fe 100644 --- a/src/dawn/tests/end2end/AdapterDiscoveryTests.cpp +++ b/src/dawn/tests/end2end/AdapterDiscoveryTests.cpp @@ -155,81 +155,6 @@ TEST(AdapterDiscoveryTests, OnlyMetal) { } #endif // defined(DAWN_ENABLE_BACKEND_METAL) -#if defined(DAWN_ENABLE_BACKEND_DESKTOP_GL) -// Test discovering only desktop OpenGL adapters -TEST(AdapterDiscoveryTests, OnlyDesktopGL) { - if (!glfwInit()) { - GTEST_SKIP() << "glfwInit() failed"; - } - glfwDefaultWindowHints(); - glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); - glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 4); - glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE); - glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); - glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); - - GLFWwindow* window = glfwCreateWindow(400, 400, "Dawn OpenGL test window", nullptr, nullptr); - glfwMakeContextCurrent(window); - - dawn::native::Instance instance; - - dawn::native::opengl::AdapterDiscoveryOptions options; - options.getProc = reinterpret_cast(glfwGetProcAddress); - instance.DiscoverAdapters(&options); - glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE); - - const auto& adapters = instance.GetAdapters(); - for (const auto& adapter : adapters) { - wgpu::AdapterProperties properties; - adapter.GetProperties(&properties); - - EXPECT_EQ(properties.backendType, wgpu::BackendType::OpenGL); - } - - glfwDestroyWindow(window); -} -#endif // defined(DAWN_ENABLE_BACKEND_DESKTOP_GL) - -#if defined(DAWN_ENABLE_BACKEND_OPENGLES) -// Test discovering only OpenGLES adapters -TEST(AdapterDiscoveryTests, OnlyOpenGLES) { - ScopedEnvironmentVar angleDefaultPlatform; - if (GetEnvironmentVar("ANGLE_DEFAULT_PLATFORM").first.empty()) { - angleDefaultPlatform.Set("ANGLE_DEFAULT_PLATFORM", "swiftshader"); - } - - if (!glfwInit()) { - GTEST_SKIP() << "glfwInit() failed"; - } - glfwDefaultWindowHints(); - glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); - glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1); - glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API); - glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API); - glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); - - GLFWwindow* window = glfwCreateWindow(400, 400, "Dawn OpenGLES test window", nullptr, nullptr); - glfwMakeContextCurrent(window); - - dawn::native::Instance instance; - - dawn::native::opengl::AdapterDiscoveryOptionsES options; - options.getProc = reinterpret_cast(glfwGetProcAddress); - instance.DiscoverAdapters(&options); - glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE); - - const auto& adapters = instance.GetAdapters(); - for (const auto& adapter : adapters) { - wgpu::AdapterProperties properties; - adapter.GetProperties(&properties); - - EXPECT_EQ(properties.backendType, wgpu::BackendType::OpenGLES); - } - - glfwDestroyWindow(window); -} -#endif // defined(DAWN_ENABLE_BACKEND_OPENGLES) - #if defined(DAWN_ENABLE_BACKEND_METAL) && defined(DAWN_ENABLE_BACKEND_VULKAN) // Test discovering the Metal backend, then the Vulkan backend // does not duplicate adapters. diff --git a/src/dawn/tests/end2end/SwapChainTests.cpp b/src/dawn/tests/end2end/SwapChainTests.cpp index c55330d7a2..a7c50e70ca 100644 --- a/src/dawn/tests/end2end/SwapChainTests.cpp +++ b/src/dawn/tests/end2end/SwapChainTests.cpp @@ -37,10 +37,7 @@ class SwapChainTests : public DawnTest { GTEST_SKIP(); } - // The SwapChainTests don't create OpenGL contexts so we don't need to call - // SetupGLFWWindowHintsForBackend. Set GLFW_NO_API anyway to avoid GLFW bringing up a GL - // context that we won't use. - ASSERT_TRUE(!IsOpenGL()); + // Set GLFW_NO_API to avoid GLFW bringing up a GL context that we won't use. glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); window = glfwCreateWindow(400, 400, "SwapChainValidationTests window", nullptr, nullptr); diff --git a/src/dawn/tests/end2end/SwapChainValidationTests.cpp b/src/dawn/tests/end2end/SwapChainValidationTests.cpp index b351be7325..f0a2ff725c 100644 --- a/src/dawn/tests/end2end/SwapChainValidationTests.cpp +++ b/src/dawn/tests/end2end/SwapChainValidationTests.cpp @@ -34,10 +34,7 @@ class SwapChainValidationTests : public DawnTest { }); DAWN_TEST_UNSUPPORTED_IF(!glfwInit()); - // The SwapChainValidationTests don't create devices so we don't need to call - // SetupGLFWWindowHintsForBackend. Set GLFW_NO_API anyway to avoid GLFW bringing up a GL - // context that we won't use. - ASSERT_TRUE(!IsOpenGL()); + // Set GLFW_NO_API to avoid GLFW bringing up a GL context that we won't use. glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); window = glfwCreateWindow(400, 400, "SwapChainValidationTests window", nullptr, nullptr); diff --git a/src/dawn/tests/end2end/WindowSurfaceTests.cpp b/src/dawn/tests/end2end/WindowSurfaceTests.cpp index b1680897b1..763f19ffa9 100644 --- a/src/dawn/tests/end2end/WindowSurfaceTests.cpp +++ b/src/dawn/tests/end2end/WindowSurfaceTests.cpp @@ -68,9 +68,7 @@ class WindowSurfaceInstanceTests : public testing::Test { } GLFWwindow* CreateWindow() { - // The WindowSurfaceInstance tests don't create devices so we don't need to call - // SetupGLFWWindowHintsForBackend. Set GLFW_NO_API anyway to avoid GLFW bringing up a GL - // context that we won't use. + // Set GLFW_NO_API to avoid GLFW bringing up a GL context that we won't use. glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); mWindow = glfwCreateWindow(400, 400, "WindowSurfaceInstanceTests window", nullptr, nullptr); return mWindow; diff --git a/src/dawn/utils/BackendBinding.cpp b/src/dawn/utils/BackendBinding.cpp index 17bea5f9ff..2aaa04798d 100644 --- a/src/dawn/utils/BackendBinding.cpp +++ b/src/dawn/utils/BackendBinding.cpp @@ -16,12 +16,6 @@ #include "dawn/common/Compiler.h" -#include "GLFW/glfw3.h" - -#if defined(DAWN_ENABLE_BACKEND_OPENGL) -#include "dawn/native/OpenGLBackend.h" -#endif // defined(DAWN_ENABLE_BACKEND_OPENGL) - namespace utils { #if defined(DAWN_ENABLE_BACKEND_D3D12) @@ -43,29 +37,6 @@ BackendBinding* CreateVulkanBinding(GLFWwindow* window, WGPUDevice device); BackendBinding::BackendBinding(GLFWwindow* window, WGPUDevice device) : mWindow(window), mDevice(device) {} -void DiscoverAdapter(dawn::native::Instance* instance, GLFWwindow* window, wgpu::BackendType type) { - DAWN_UNUSED(type); - DAWN_UNUSED(window); - - if (type == wgpu::BackendType::OpenGL || type == wgpu::BackendType::OpenGLES) { -#if defined(DAWN_ENABLE_BACKEND_OPENGL) - glfwMakeContextCurrent(window); - auto getProc = reinterpret_cast(glfwGetProcAddress); - if (type == wgpu::BackendType::OpenGL) { - dawn::native::opengl::AdapterDiscoveryOptions adapterOptions; - adapterOptions.getProc = getProc; - instance->DiscoverAdapters(&adapterOptions); - } else { - dawn::native::opengl::AdapterDiscoveryOptionsES adapterOptions; - adapterOptions.getProc = getProc; - instance->DiscoverAdapters(&adapterOptions); - } -#endif // defined(DAWN_ENABLE_BACKEND_OPENGL) - } else { - instance->DiscoverDefaultAdapters(); - } -} - BackendBinding* CreateBinding(wgpu::BackendType type, GLFWwindow* window, WGPUDevice device) { switch (type) { #if defined(DAWN_ENABLE_BACKEND_D3D12) diff --git a/src/dawn/utils/GLFWUtils.cpp b/src/dawn/utils/GLFWUtils.cpp index 3ba577f72c..c18ca525ee 100644 --- a/src/dawn/utils/GLFWUtils.cpp +++ b/src/dawn/utils/GLFWUtils.cpp @@ -32,26 +32,6 @@ namespace utils { -void SetupGLFWWindowHintsForBackend(wgpu::BackendType type) { - if (type == wgpu::BackendType::OpenGL) { - // Ask for OpenGL 4.4 which is what the GL backend requires for compute shaders and - // texture views. - glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); - glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 4); - glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE); - glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); - } else if (type == wgpu::BackendType::OpenGLES) { - glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); - glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1); - glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API); - glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API); - } else { - // Without this GLFW will initialize a GL context on the window, which prevents using - // the window with other APIs (by crashing in weird ways). - glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); - } -} - wgpu::Surface CreateSurfaceForWindow(const wgpu::Instance& instance, GLFWwindow* window) { std::unique_ptr chainedDescriptor = SetupWindowAndGetSurfaceDescriptor(window); diff --git a/src/dawn/utils/GLFWUtils.h b/src/dawn/utils/GLFWUtils.h index 2fe5b10ffd..f42446d2aa 100644 --- a/src/dawn/utils/GLFWUtils.h +++ b/src/dawn/utils/GLFWUtils.h @@ -23,10 +23,6 @@ struct GLFWwindow; namespace utils { -// Adds all the necessary glfwWindowHint calls for the next GLFWwindow created to be used with -// the specified backend. -void SetupGLFWWindowHintsForBackend(wgpu::BackendType type); - // Does the necessary setup on the GLFWwindow to allow creating a wgpu::Surface with it and // calls `instance.CreateSurface` with the correct descriptor for this window. // Returns a null wgpu::Surface on failure.