Update WebGPU

.clang-tidy

@@ -163,7 +163,7 @@ Checks: >
 # keep-sorted end
 WarningsAsErrors: '*'
 HeaderFilterRegex: '.*'
-ExcludeHeaderFilterRegex: '\.fbs\.h|common/cmdline\.h|/mini_\w*\.h'
+ExcludeHeaderFilterRegex: '\.fbs\.h|common/cmdline\.h|mini_[^/]*\.h'
 FormatStyle: 'file'
 CheckOptions:
     -   key: modernize-use-default-member-init.UseAssignment

Makefile

@@ -904,7 +904,8 @@ RUNTIME_CPP_COMPONENTS = \
   tracing \
   vulkan \
   wasm_cpu_features \
-  webgpu_dawn \
+  webgpu_dawn_arm \
+  webgpu_dawn_x86 \
   webgpu_emscripten \
   windows_aarch64_cpu_features_arm \
   windows_clock \
@@ -1104,6 +1105,8 @@ RUNTIME_TRIPLE_WIN_GENERIC_64 = "x86_64-unknown-windows-unknown"
 
 RUNTIME_TRIPLE_WEBGPU_32 = "wasm32-unknown-unknown-unknown"
 RUNTIME_TRIPLE_WEBGPU_64 = "wasm64-unknown-unknown-unknown"
+RUNTIME_TRIPLE_WEBGPU_ARM_64 = "aarch64-unknown-unknown-unknown"
+RUNTIME_TRIPLE_WEBGPU_X86_64 = "x86_64-unknown-unknown-unknown"
 
 # `-fno-threadsafe-statics` is very important here (note that it allows us to use a 'modern' C++
 # standard but still skip threadsafe guards for static initialization in our runtime code)
@@ -1157,6 +1160,22 @@ $(BUILD_DIR)/initmod.windows_%_64.ll: $(SRC_DIR)/runtime/windows_%.cpp
 	@mkdir -p $(@D)
 	$(CLANG) $(CXX_WARNING_FLAGS) $(RUNTIME_CXX_FLAGS) -m64 -target $(RUNTIME_TRIPLE_WIN_GENERIC_64) -fshort-wchar -DCOMPILING_HALIDE_RUNTIME -DBITS_64 -emit-llvm -S $(SRC_DIR)/runtime/windows_$*.cpp -o $@ -MMD -MP -MF $(BUILD_DIR)/initmod.windows_$*_64.d
 
+$(BUILD_DIR)/initmod.webgpu_dawn_arm_32.ll: $(SRC_DIR)/runtime/webgpu_dawn_arm.cpp
+	@mkdir -p $(@D)
+	$(CLANG) $(CXX_WARNING_FLAGS) $(RUNTIME_CXX_FLAGS) -m32 -target $(RUNTIME_TRIPLE_32) -DCOMPILING_HALIDE_RUNTIME -DBITS_32 -emit-llvm -S $(SRC_DIR)/runtime/webgpu_dawn_arm.cpp -o $@ -MMD -MP -MF $(BUILD_DIR)/initmod.webgpu_dawn_arm_32.d
+
+$(BUILD_DIR)/initmod.webgpu_dawn_arm_64.ll: $(SRC_DIR)/runtime/webgpu_dawn_arm.cpp
+	@mkdir -p $(@D)
+	$(CLANG) $(CXX_WARNING_FLAGS) $(RUNTIME_CXX_FLAGS) -m64 -target $(RUNTIME_TRIPLE_WEBGPU_ARM_64) -DCOMPILING_HALIDE_RUNTIME -DBITS_64 -emit-llvm -S $(SRC_DIR)/runtime/webgpu_dawn_arm.cpp -o $@ -MMD -MP -MF $(BUILD_DIR)/initmod.webgpu_dawn_arm_64.d
+
+$(BUILD_DIR)/initmod.webgpu_dawn_x86_32.ll: $(SRC_DIR)/runtime/webgpu_dawn_x86.cpp
+	@mkdir -p $(@D)
+	$(CLANG) $(CXX_WARNING_FLAGS) $(RUNTIME_CXX_FLAGS) -m32 -target $(RUNTIME_TRIPLE_32) -DCOMPILING_HALIDE_RUNTIME -DBITS_32 -emit-llvm -S $(SRC_DIR)/runtime/webgpu_dawn_x86.cpp -o $@ -MMD -MP -MF $(BUILD_DIR)/initmod.webgpu_dawn_x86_32.d
+
+$(BUILD_DIR)/initmod.webgpu_dawn_x86_64.ll: $(SRC_DIR)/runtime/webgpu_dawn_x86.cpp
+	@mkdir -p $(@D)
+	$(CLANG) $(CXX_WARNING_FLAGS) $(RUNTIME_CXX_FLAGS) -m64 -target $(RUNTIME_TRIPLE_WEBGPU_X86_64) -DCOMPILING_HALIDE_RUNTIME -DBITS_64 -emit-llvm -S $(SRC_DIR)/runtime/webgpu_dawn_x86.cpp -o $@ -MMD -MP -MF $(BUILD_DIR)/initmod.webgpu_dawn_x86_64.d
+
 $(BUILD_DIR)/initmod.webgpu_%_32.ll: $(SRC_DIR)/runtime/webgpu_%.cpp
 	@mkdir -p $(@D)
 	$(CLANG) $(CXX_WARNING_FLAGS) $(RUNTIME_CXX_FLAGS) -m32 -target $(RUNTIME_TRIPLE_WEBGPU_32) -DCOMPILING_HALIDE_RUNTIME -DBITS_32 -emit-llvm -S $(SRC_DIR)/runtime/webgpu_$*.cpp -o $@ -MMD -MP -MF $(BUILD_DIR)/initmod.webgpu_$*_32.d
@@ -1165,6 +1184,22 @@ $(BUILD_DIR)/initmod.webgpu_%_64.ll: $(SRC_DIR)/runtime/webgpu_%.cpp
 	@mkdir -p $(@D)
 	$(CLANG) $(CXX_WARNING_FLAGS) $(RUNTIME_CXX_FLAGS) -m64 -target $(RUNTIME_TRIPLE_WEBGPU_64) -DCOMPILING_HALIDE_RUNTIME -DBITS_64 -emit-llvm -S $(SRC_DIR)/runtime/webgpu_$*.cpp -o $@ -MMD -MP -MF $(BUILD_DIR)/initmod.webgpu_$*_64.d
 
+$(BUILD_DIR)/initmod.webgpu_dawn_arm_32_debug.ll: $(SRC_DIR)/runtime/webgpu_dawn_arm.cpp
+	@mkdir -p $(@D)
+	$(CLANG) $(CXX_WARNING_FLAGS) -g -DDEBUG_RUNTIME $(RUNTIME_CXX_FLAGS) -m32 -target $(RUNTIME_TRIPLE_32) -DCOMPILING_HALIDE_RUNTIME -DBITS_32 -emit-llvm -S $(SRC_DIR)/runtime/webgpu_dawn_arm.cpp -o $@ -MMD -MP -MF $(BUILD_DIR)/initmod.webgpu_dawn_arm_32_debug.d
+
+$(BUILD_DIR)/initmod.webgpu_dawn_arm_64_debug.ll: $(SRC_DIR)/runtime/webgpu_dawn_arm.cpp
+	@mkdir -p $(@D)
+	$(CLANG) $(CXX_WARNING_FLAGS) -g -DDEBUG_RUNTIME $(RUNTIME_CXX_FLAGS) -m64 -target $(RUNTIME_TRIPLE_WEBGPU_ARM_64) -DCOMPILING_HALIDE_RUNTIME -DBITS_64 -emit-llvm -S $(SRC_DIR)/runtime/webgpu_dawn_arm.cpp -o $@ -MMD -MP -MF $(BUILD_DIR)/initmod.webgpu_dawn_arm_64_debug.d
+
+$(BUILD_DIR)/initmod.webgpu_dawn_x86_32_debug.ll: $(SRC_DIR)/runtime/webgpu_dawn_x86.cpp
+	@mkdir -p $(@D)
+	$(CLANG) $(CXX_WARNING_FLAGS) -g -DDEBUG_RUNTIME $(RUNTIME_CXX_FLAGS) -m32 -target $(RUNTIME_TRIPLE_32) -DCOMPILING_HALIDE_RUNTIME -DBITS_32 -emit-llvm -S $(SRC_DIR)/runtime/webgpu_dawn_x86.cpp -o $@ -MMD -MP -MF $(BUILD_DIR)/initmod.webgpu_dawn_x86_32_debug.d
+
+$(BUILD_DIR)/initmod.webgpu_dawn_x86_64_debug.ll: $(SRC_DIR)/runtime/webgpu_dawn_x86.cpp
+	@mkdir -p $(@D)
+	$(CLANG) $(CXX_WARNING_FLAGS) -g -DDEBUG_RUNTIME $(RUNTIME_CXX_FLAGS) -m64 -target $(RUNTIME_TRIPLE_WEBGPU_X86_64) -DCOMPILING_HALIDE_RUNTIME -DBITS_64 -emit-llvm -S $(SRC_DIR)/runtime/webgpu_dawn_x86.cpp -o $@ -MMD -MP -MF $(BUILD_DIR)/initmod.webgpu_dawn_x86_64_debug.d
+
 $(BUILD_DIR)/initmod.webgpu_%_32_debug.ll: $(SRC_DIR)/runtime/webgpu_%.cpp
 	@mkdir -p $(@D)
 	$(CLANG) $(CXX_WARNING_FLAGS) -g -DDEBUG_RUNTIME $(RUNTIME_CXX_FLAGS) -m32 -target $(RUNTIME_TRIPLE_WEBGPU_32) -DCOMPILING_HALIDE_RUNTIME -DBITS_32 -emit-llvm -S $(SRC_DIR)/runtime/webgpu_$*.cpp -o $@ -MMD -MP -MF $(BUILD_DIR)/initmod.webgpu_$*_32_debug.d

cmake/FindHalide_WebGPU.cmake

@@ -8,20 +8,66 @@ if (EXISTS "$ENV{HL_WEBGPU_NATIVE_LIB}")
       CACHE FILEPATH "")
 endif ()
 
-find_library(Halide_WebGPU_NATIVE_LIB NAMES webgpu_dawn wgpu)
+# Try to find Dawn via vcpkg's CMake config first
+if (NOT TARGET Halide::WebGPU)
+  # Look for DawnConfig.cmake in vcpkg installed directory
+  if (DEFINED ENV{VCPKG_ROOT})
+    set(_dawn_cmake_path "$ENV{VCPKG_ROOT}/installed/${VCPKG_TARGET_TRIPLET}/share/dawn")
+    if (EXISTS "${_dawn_cmake_path}/DawnConfig.cmake")
+      # Use find_package to properly resolve dependencies
+      find_package(Dawn CONFIG QUIET)
+      if (TARGET dawn::webgpu_dawn AND NOT TARGET Halide::WebGPU)
+        add_library(Halide::WebGPU ALIAS dawn::webgpu_dawn)
+      elseif (TARGET dawn::dawn_public_config AND NOT TARGET Halide::WebGPU)
+        get_target_property(_dawn_loc dawn::dawn_public_config IMPORTED_LOCATION)
+        if (_dawn_loc)
+          add_library(Halide::WebGPU UNKNOWN IMPORTED)
+          set_target_properties(Halide::WebGPU PROPERTIES IMPORTED_LOCATION "${_dawn_loc}")
+          get_target_property(_dawn_link_deps dawn::dawn_public_config INTERFACE_LINK_LIBRARIES)
+          if (_dawn_link_deps)
+            set_target_properties(Halide::WebGPU PROPERTIES INTERFACE_LINK_LIBRARIES "${_dawn_link_deps}")
+          endif ()
+        endif ()
+      endif ()
+    elseif (EXISTS "${_dawn_cmake_path}/DawnTargets.cmake")
+      include("${_dawn_cmake_path}/DawnTargets.cmake")
+      if (TARGET dawn::webgpu_dawn AND NOT TARGET Halide::WebGPU)
+        add_library(Halide::WebGPU ALIAS dawn::webgpu_dawn)
+      endif ()
+    endif ()
+  endif ()
+endif ()
 
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(
-  Halide_WebGPU
-  REQUIRED_VARS Halide_WebGPU_NATIVE_LIB
-  HANDLE_COMPONENTS
-)
+# If Dawn wasn't found via vcpkg config, fall back to manual find
+if (NOT TARGET Halide::WebGPU)
+  # Prefer shared library for runtime loading (dlopen)
+  find_library(Halide_WebGPU_NATIVE_LIB NAMES webgpu_dawn wgpu PATHS "${CMAKE_CURRENT_LIST_DIR}/../vcpkg_installed/${VCPKG_TARGET_TRIPLET}/lib" NO_DEFAULT_PATH)
+  if (NOT Halide_WebGPU_NATIVE_LIB)
+    find_library(Halide_WebGPU_NATIVE_LIB NAMES webgpu_dawn wgpu)
+  endif ()
 
-if (Halide_WebGPU_NATIVE_LIB AND NOT TARGET Halide::WebGPU)
-  add_library(Halide::WebGPU UNKNOWN IMPORTED)
-  set_target_properties(
-    Halide::WebGPU
-    PROPERTIES
-    IMPORTED_LOCATION "${Halide_WebGPU_NATIVE_LIB}"
+  include(FindPackageHandleStandardArgs)
+  find_package_handle_standard_args(
+    Halide_WebGPU
+    REQUIRED_VARS Halide_WebGPU_NATIVE_LIB
+    HANDLE_COMPONENTS
   )
+
+  if (Halide_WebGPU_NATIVE_LIB)
+    add_library(Halide::WebGPU UNKNOWN IMPORTED)
+    set_target_properties(
+      Halide::WebGPU
+      PROPERTIES
+      IMPORTED_LOCATION "${Halide_WebGPU_NATIVE_LIB}"
+    )
+
+    if (APPLE)
+      set_target_properties(
+        Halide::WebGPU
+        PROPERTIES
+        INTERFACE_LINK_LIBRARIES
+          "-framework Cocoa;-framework IOKit;-framework Foundation;-framework IOSurface;-framework QuartzCore;-framework Metal"
+      )
+    endif ()
+  endif ()
 endif ()

cmake/vcpkg-ports/dawn/000-fix-emdawnwebgpu.patch

@@ -0,0 +1,19 @@
+diff --git a/emdawnwebgpu.port.py b/emdawnwebgpu.port.py
+index 4b90064..1956d0b 100644
+--- a/emdawnwebgpu.port.py
++++ b/emdawnwebgpu.port.py
+@@ -70,10 +70,10 @@ def _walk(path):
+             yield os.path.join(dirpath, filename)
+
+
+-_pkg_dir = os.path.dirname(os.path.realpath(__file__))
+-_c_include_dir = os.path.join(_pkg_dir, 'webgpu', 'include')
+-_cpp_include_dir = os.path.join(_pkg_dir, 'webgpu_cpp', 'include')
+-_src_dir = os.path.join(_pkg_dir, 'webgpu', 'src')
++_pkg_dir = os.path.dirname(os.path.realpath(os.path.join(__file__, '..', '..')))
++_c_include_dir = os.path.join(_pkg_dir, 'include')
++_cpp_include_dir = os.path.join(_pkg_dir, 'include')
++_src_dir = os.path.join(_pkg_dir, 'share', 'dawn', 'src')
+ _srcs = [
+     os.path.join(_src_dir, 'webgpu.cpp'),
+ ]

cmake/vcpkg-ports/dawn/001-fix-windows-build.patch

@@ -0,0 +1,14 @@
+diff --git a/src/cmake/DawnLibrary.cmake b/src/cmake/DawnLibrary.cmake
+index f80426804a..44f4535c63 100644
+--- a/src/cmake/DawnLibrary.cmake
++++ b/src/cmake/DawnLibrary.cmake
+@@ -184,9 +184,6 @@ function(dawn_install_target name)
+     get_target_property(target_type "${name}" TYPE)
+     # Only shared libraries and executables generate PDB files through the linker
+     # Static libraries are created by the archiver and don't generate PDB files
+-    if ((target_type STREQUAL "SHARED_LIBRARY") OR (target_type STREQUAL "EXECUTABLE"))
+-      install(FILES $<TARGET_PDB_FILE:${name}> DESTINATION ${CMAKE_INSTALL_BINDIR} OPTIONAL)
+-    endif()
+   endif (MSVC)
+
+   # Automatically determine where each header should go based on its subdirectory in the include dir.

cmake/vcpkg-ports/dawn/002-fix-uwp.patch

@@ -0,0 +1,19 @@
+diff --git a/src/dawn/native/d3d/PlatformFunctions.cpp b/src/dawn/native/d3d/PlatformFunctions.cpp
+index 12d65e0db5..d3abb05fb5 100644
+--- a/src/dawn/native/d3d/PlatformFunctions.cpp
++++ b/src/dawn/native/d3d/PlatformFunctions.cpp
+@@ -121,10 +121,14 @@ MaybeError PlatformFunctions::EnsureFXC(std::span<const std::string> searchPaths
+ }
+
+ void PlatformFunctions::InitWindowsVersion() {
++#if DAWN_PLATFORM_IS(WINUWP)
++    return;
++#else
+     // Currently we only care about the build number of Windows 10 and Windows 11.
+     if (!IsWindows10OrGreater()) {
+         return;
+     }
++#endif
+
+     // Referenced from base/win/windows_version.cc in Chromium
+     constexpr wchar_t kRegKeyWindowsNTCurrentVersion[] =

cmake/vcpkg-ports/dawn/003-fix-d3d11.patch

@@ -0,0 +1,26 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 2092a42fc6..596f55d5f2 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -222,6 +222,12 @@ else()
+   set(TINT_DEFAULT_GLSL OFF)
+ endif()
+
++if (DAWN_ENABLE_D3D11 OR DAWN_ENABLE_D3D12)
++  set(TINT_DEFAULT_HLSL ON)
++else()
++  set(TINT_DEFAULT_HLSL OFF)
++endif()
++
+ option(TINT_ENABLE_INSTALL "Enable install step for Tint libraries" OFF)
+ option(TINT_BUILD_CMD_TOOLS "Build the Tint command line tools" ON)
+
+@@ -235,7 +241,7 @@ option(TINT_BUILD_SPV_READER "Build the SPIR-V input reader" ${DAWN_ENABLE_VULKA
+ option(TINT_BUILD_WGSL_READER "Build the WGSL input reader" ON)
+ option(TINT_BUILD_GLSL_WRITER "Build the GLSL output writer" ${TINT_DEFAULT_GLSL})
+ option(TINT_BUILD_GLSL_VALIDATOR "Build the GLSL output validator" ON)
+-option(TINT_BUILD_HLSL_WRITER "Build the HLSL output writer" ${DAWN_ENABLE_D3D12})
++option(TINT_BUILD_HLSL_WRITER "Build the HLSL output writer" ${TINT_DEFAULT_HLSL})
+ option(TINT_BUILD_MSL_WRITER "Build the MSL output writer" ${DAWN_ENABLE_METAL})
+ option(TINT_BUILD_SPV_WRITER "Build the SPIR-V output writer" ${DAWN_ENABLE_VULKAN})
+ option(TINT_BUILD_WGSL_WRITER "Build the WGSL output writer" ON)

cmake/vcpkg-ports/dawn/004-deps.patch

@@ -0,0 +1,127 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 596f55d5f2..3ded3daa67 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -471,6 +471,11 @@ set(TINT_SPIRV_TOOLS_DIR   ${DAWN_SPIRV_TOOLS_DIR})
+ ################################################################################
+ # Run on all subdirectories
+ ################################################################################
++find_package(absl CONFIG REQUIRED)
++if (DAWN_ENABLE_VULKAN)
++    find_package(VulkanHeaders CONFIG REQUIRED)
++    find_package(VulkanUtilityLibraries CONFIG REQUIRED)
++endif()
+ add_subdirectory(third_party)
+
+ # TODO(crbug.com/tint/455): Tint does not currently build with CMake when
+diff --git a/src/cmake/BundleLibraries.cmake b/src/cmake/BundleLibraries.cmake
+index 682a73924c..1ec358c54c 100644
+--- a/src/cmake/BundleLibraries.cmake
++++ b/src/cmake/BundleLibraries.cmake
+@@ -92,7 +92,18 @@ function(bundle_libraries output_target library_type)
+
+   # Collect $<TARGET_OBJECTS:...> from STATIC and OBJECT library dependencies
+   set(all_objects "")
++  set(all_libraries "")
++  message(STATUS "all_dependencies: ${all_dependencies}")
+   foreach(dependency IN LISTS all_dependencies)
++    if("${dependency}" MATCHES "^absl::")
++      list(APPEND all_libraries ${dependency})
++      continue()
++    endif()
++    if("${dependency}" MATCHES "^Vulkan-Headers" OR "${dependency}" MATCHES "^VulkanUtility")
++      list(APPEND all_libraries ${dependency})
++      continue()
++    endif()
++
+     get_target_property(type ${dependency} TYPE)
+
+     # We only want object files from static or object libraries.
+@@ -112,6 +123,7 @@ function(bundle_libraries output_target library_type)
+   # Create the output library using the validated type and collected objects
+   # If all_objects is empty, add_library will still create an empty library of the specified type.
+   add_library(${output_target} ${library_type} ${all_objects})
++  target_link_libraries(${output_target} PRIVATE ${all_libraries})
+
+   # Add dependencies to ensure input targets are built before the bundled library.
+   # This handles the build order correctly.
+diff --git a/src/cmake/DawnConfig.cmake.in b/src/cmake/DawnConfig.cmake.in
+index 8bfeda55bc..a0f9858530 100644
+--- a/src/cmake/DawnConfig.cmake.in
++++ b/src/cmake/DawnConfig.cmake.in
+@@ -31,4 +31,9 @@
+ # 2. https://cmake.org/cmake/help/latest/guide/tutorial/Adding%20Export%20Configuration.html
+
+ @PACKAGE_INIT@
++
++include(CMakeFindDependencyMacro)
++
++find_dependency(absl CONFIG)
++
+ include ("${CMAKE_CURRENT_LIST_DIR}/DawnTargets.cmake")
+diff --git a/src/dawn/native/CMakeLists.txt b/src/dawn/native/CMakeLists.txt
+index c96d5a24d9..472a86d29f 100644
+--- a/src/dawn/native/CMakeLists.txt
++++ b/src/dawn/native/CMakeLists.txt
+@@ -650,11 +650,17 @@ if ((DAWN_ENABLE_OPENGL OR DAWN_ENABLE_VULKAN) AND DAWN_ENABLE_SPIRV_VALIDATION)
+ endif()
+
+ if (DAWN_ENABLE_OPENGL)
++    find_path(OPENGL_REGISTRY_INCLUDE_DIRS "GL/glcorearb.h")
++    find_file(
++            OPENGL_XML_FILE
++            NAMES "opengl/gl.xml"
++            PATHS "${OPENGL_REGISTRY_INCLUDE_DIRS}/../share"
++    )
+     DawnGenerator(
+         SCRIPT "${Dawn_SOURCE_DIR}/generator/opengl_loader_generator.py"
+         PRINT_NAME "OpenGL function loader"
+         EXTRA_PARAMETERS "--gl-xml"
+-             "${DAWN_OPENGL_REGISTRY_DIR}/xml/gl.xml"
++             "${OPENGL_XML_FILE}"
+              "--supported-extensions"
+              "${Dawn_SOURCE_DIR}/src/dawn/native/opengl/supported_extensions.json"
+         OUTPUT_HEADERS DAWN_NATIVE_OPENGL_AUTOGEN_HEADERS
+diff --git a/third_party/CMakeLists.txt b/third_party/CMakeLists.txt
+index f7812f211e..68644c04f6 100644
+--- a/third_party/CMakeLists.txt
++++ b/third_party/CMakeLists.txt
+@@ -41,6 +41,7 @@ if (DAWN_FETCH_DEPENDENCIES)
+     )
+ endif ()
+
++if(0)
+ set(ABSL_ROOT_DIR ${DAWN_ABSEIL_DIR})
+ if (NOT TARGET absl::strings)
+     # Recommended setting for compatibility with future abseil releases.
+@@ -62,6 +63,7 @@ if (NOT TARGET absl::strings)
+
+     add_subdirectory(${DAWN_ABSEIL_DIR} "${CMAKE_CURRENT_BINARY_DIR}/abseil")
+ endif()
++endif()
+
+ if (DAWN_BUILD_PROTOBUF AND EXISTS "${DAWN_PROTOBUF_DIR}/cmake")
+     if (("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") AND WIN32)
+@@ -183,10 +185,12 @@ endif()
+ if (DAWN_ENABLE_DESKTOP_GL OR DAWN_ENABLE_OPENGLES)
+     # Header-only library for khrplatform.h
+     add_library(dawn_khronos_platform INTERFACE)
+-    target_sources(dawn_khronos_platform INTERFACE "${DAWN_EGL_REGISTRY_DIR}/api/KHR/khrplatform.h")
+-    target_include_directories(dawn_khronos_platform INTERFACE "${DAWN_EGL_REGISTRY_DIR}/api")
++    find_path(EGL_REGISTRY_INCLUDE_DIRS "EGL/egl.h")
++    target_sources(dawn_khronos_platform INTERFACE "${EGL_REGISTRY_INCLUDE_DIRS}/KHR/khrplatform.h")
++    target_include_directories(dawn_khronos_platform INTERFACE "${EGL_REGISTRY_INCLUDE_DIRS}")
+ endif()
+
++if(0)
+ if (NOT TARGET Vulkan::Headers AND DAWN_ENABLE_VULKAN)
+     message(STATUS "Dawn: using Vulkan::Headers at ${DAWN_VULKAN_HEADERS_DIR}")
+
+@@ -198,6 +202,7 @@ if (NOT TARGET Vulkan::UtilityHeaders AND DAWN_ENABLE_VULKAN)
+     message(STATUS "Dawn: using VulkanUtilityLibraries at ${DAWN_VULKAN_UTILITY_LIBRARIES_DIR}")
+     add_subdirectory(${DAWN_VULKAN_UTILITY_LIBRARIES_DIR} "${CMAKE_CURRENT_BINARY_DIR}/vulkan-utility-libraries/src")
+ endif()
++endif()
+
+ if (DAWN_ENABLE_SWIFTSHADER AND NOT TARGET vk_swiftshader)
+     set(SWIFTSHADER_BUILD_TESTS OFF CACHE BOOL "" FORCE)