From b6a449d8e3ac3e1745874b4379f09253d51e2c67 Mon Sep 17 00:00:00 2001 From: Dynamitos Date: Tue, 7 Apr 2026 22:25:13 +0200 Subject: [PATCH] More windowing changes for renderdoc --- src/Engine/Graphics/Vulkan/Graphics.cpp | 114 ++++++++++++++--- src/Engine/Graphics/Vulkan/Window.cpp | 157 +++++++++++++++++------- src/Engine/Graphics/slang-compile.cpp | 74 ++++++++++- 3 files changed, 283 insertions(+), 62 deletions(-) diff --git a/src/Engine/Graphics/Vulkan/Graphics.cpp b/src/Engine/Graphics/Vulkan/Graphics.cpp index ea118a1..ef2e251 100644 --- a/src/Engine/Graphics/Vulkan/Graphics.cpp +++ b/src/Engine/Graphics/Vulkan/Graphics.cpp @@ -16,10 +16,12 @@ #include "RenderPass.h" #include "Shader.h" #include "Window.h" +#include +#include +#include #include #include #include -#include #include #define VMA_IMPLEMENTATION @@ -28,6 +30,63 @@ using namespace Seele; using namespace Seele::Vulkan; +namespace { +std::vector enumerateInstanceExtensions() { + uint32_t extensionCount = 0; + VK_CHECK(vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr)); + std::vector extensions(extensionCount); + if (extensionCount > 0) { + VK_CHECK(vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensions.data())); + } + return extensions; +} + +bool hasInstanceExtension(const std::vector& extensions, const char* extensionName) { + for (const auto& extension : extensions) { + if (std::strcmp(extension.extensionName, extensionName) == 0) { + return true; + } + } + return false; +} + +void applyCommonGlfwInitHints() { +#if defined(GLFW_WAYLAND_LIBDECOR) && defined(GLFW_WAYLAND_DISABLE_LIBDECOR) + glfwInitHint(GLFW_WAYLAND_LIBDECOR, GLFW_WAYLAND_DISABLE_LIBDECOR); +#endif +} + +void initializeGlfwForVulkan() { + applyCommonGlfwInitHints(); + if (!glfwInit()) { + throw std::runtime_error("Failed to initialize GLFW"); + } + if (!glfwVulkanSupported()) { + throw std::runtime_error("GLFW: Vulkan not supported"); + } + +#if defined(GLFW_PLATFORM_WAYLAND) && defined(GLFW_PLATFORM_X11) + const auto availableExtensions = enumerateInstanceExtensions(); + const bool hasWaylandSurface = hasInstanceExtension(availableExtensions, "VK_KHR_wayland_surface"); + const bool hasXlibSurface = hasInstanceExtension(availableExtensions, "VK_KHR_xlib_surface"); + const bool hasXcbSurface = hasInstanceExtension(availableExtensions, "VK_KHR_xcb_surface"); + + if (glfwGetPlatform() == GLFW_PLATFORM_WAYLAND && !hasWaylandSurface && (hasXlibSurface || hasXcbSurface)) { + std::cerr << "Warning: Vulkan loader does not expose VK_KHR_wayland_surface on this run. Reinitializing GLFW on X11 backend." << std::endl; + glfwTerminate(); + applyCommonGlfwInitHints(); + glfwInitHint(GLFW_PLATFORM, GLFW_PLATFORM_X11); + if (!glfwInit()) { + throw std::runtime_error("Failed to reinitialize GLFW on X11 backend"); + } + if (!glfwVulkanSupported()) { + throw std::runtime_error("GLFW: Vulkan not supported after switching to X11 backend"); + } + } +#endif +} +} + thread_local PCommandPool Seele::Vulkan::Graphics::graphicsCommands = nullptr; thread_local PCommandPool Seele::Vulkan::Graphics::computeCommands = nullptr; thread_local PCommandPool Seele::Vulkan::Graphics::transferCommands = nullptr; @@ -675,31 +734,46 @@ Array Graphics::getRequiredExtensions() { message += ": "; message += glfwError; } - extensions.add(VK_KHR_SURFACE_EXTENSION_NAME); - extensions.add(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME); - std::cerr << "Warning: " << message << ". Falling back to a default set of extensions." << std::endl; + std::cerr << "Warning: " << message << ". Falling back to platform-specific surface extensions." << std::endl; + + extensions.addUnique(VK_KHR_SURFACE_EXTENSION_NAME); + +#if defined(GLFW_PLATFORM_WAYLAND) && defined(GLFW_PLATFORM_X11) + const int platform = glfwGetPlatform(); + if (platform == GLFW_PLATFORM_WAYLAND) { + extensions.addUnique("VK_KHR_wayland_surface"); + } else if (platform == GLFW_PLATFORM_X11) { + extensions.addUnique("VK_KHR_xlib_surface"); + extensions.addUnique("VK_KHR_xcb_surface"); + } else { + extensions.addUnique("VK_KHR_wayland_surface"); + extensions.addUnique("VK_KHR_xlib_surface"); + extensions.addUnique("VK_KHR_xcb_surface"); + } +#else + bool isWayland = std::getenv("WAYLAND_DISPLAY") != nullptr; + if (isWayland) { + extensions.addUnique("VK_KHR_wayland_surface"); + } else { + extensions.addUnique("VK_KHR_xlib_surface"); + extensions.addUnique("VK_KHR_xcb_surface"); + } +#endif + } else { + // GLFW successfully reported extensions + for (unsigned int i = 0; i < glfwExtensionCount; i++) { + extensions.addUnique(glfwExtensions[i]); + } } - for (unsigned int i = 0; i < glfwExtensionCount; i++) { - extensions.add(glfwExtensions[i]); - } #ifdef ENABLE_VALIDATION - extensions.add(VK_EXT_DEBUG_UTILS_EXTENSION_NAME); + extensions.addUnique(VK_EXT_DEBUG_UTILS_EXTENSION_NAME); #endif return extensions; } void Graphics::initInstance(GraphicsInitializer initInfo) { -#if defined(GLFW_WAYLAND_LIBDECOR) && defined(GLFW_WAYLAND_DISABLE_LIBDECOR) - // Work around libdecor runtime regressions on some Wayland stacks. - glfwInitHint(GLFW_WAYLAND_LIBDECOR, GLFW_WAYLAND_DISABLE_LIBDECOR); -#endif - if (!glfwInit()) { - throw std::runtime_error("Failed to initialize GLFW"); - } - if (!glfwVulkanSupported()) { - throw std::runtime_error("GLFW: Vulkan not supported"); - } + initializeGlfwForVulkan(); VkApplicationInfo appInfo = { .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, .pNext = nullptr, @@ -712,10 +786,10 @@ void Graphics::initInstance(GraphicsInitializer initInfo) { Array extensions = getRequiredExtensions(); for (uint32 i = 0; i < initInfo.instanceExtensions.size(); ++i) { - extensions.add(initInfo.instanceExtensions[i]); + extensions.addUnique(initInfo.instanceExtensions[i]); } #ifdef __APPLE__ - extensions.add("VK_KHR_portability_enumeration"); + extensions.addUnique("VK_KHR_portability_enumeration"); #endif Array layers = initInfo.layers; VkInstanceCreateInfo info = { diff --git a/src/Engine/Graphics/Vulkan/Window.cpp b/src/Engine/Graphics/Vulkan/Window.cpp index 8c5b9ee..edae673 100644 --- a/src/Engine/Graphics/Vulkan/Window.cpp +++ b/src/Engine/Graphics/Vulkan/Window.cpp @@ -3,12 +3,79 @@ #include "Enums.h" #include "Graphics.h" #include "Resources.h" +#define GLFW_EXPOSE_NATIVE_WAYLAND +#define GLFW_EXPOSE_NATIVE_X11 #include +#include +#include #include +#include +#include using namespace Seele; using namespace Seele::Vulkan; +namespace { +VkResult createSurfaceFromNativeHandles(VkInstance instance, GLFWwindow* handle, VkSurfaceKHR* surface, std::string& reason) { +#if defined(GLFW_PLATFORM_WAYLAND) + if (glfwGetPlatform() == GLFW_PLATFORM_WAYLAND) { + auto createWaylandSurface = reinterpret_cast( + vkGetInstanceProcAddr(instance, "vkCreateWaylandSurfaceKHR")); + if (createWaylandSurface == nullptr) { + reason = "vkCreateWaylandSurfaceKHR is unavailable on the Vulkan instance"; + return VK_ERROR_EXTENSION_NOT_PRESENT; + } + + wl_display* display = glfwGetWaylandDisplay(); + wl_surface* waylandSurface = glfwGetWaylandWindow(handle); + if (display == nullptr || waylandSurface == nullptr) { + reason = "GLFW did not provide valid Wayland native handles"; + return VK_ERROR_INITIALIZATION_FAILED; + } + + VkWaylandSurfaceCreateInfoKHR createInfo = { + .sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR, + .pNext = nullptr, + .flags = 0, + .display = display, + .surface = waylandSurface, + }; + return createWaylandSurface(instance, &createInfo, nullptr, surface); + } +#endif + +#if defined(GLFW_PLATFORM_X11) + if (glfwGetPlatform() == GLFW_PLATFORM_X11) { + auto createXlibSurface = reinterpret_cast( + vkGetInstanceProcAddr(instance, "vkCreateXlibSurfaceKHR")); + if (createXlibSurface == nullptr) { + reason = "vkCreateXlibSurfaceKHR is unavailable on the Vulkan instance"; + return VK_ERROR_EXTENSION_NOT_PRESENT; + } + + Display* display = glfwGetX11Display(); + ::Window x11Window = glfwGetX11Window(handle); + if (display == nullptr || x11Window == 0) { + reason = "GLFW did not provide valid X11 native handles"; + return VK_ERROR_INITIALIZATION_FAILED; + } + + VkXlibSurfaceCreateInfoKHR createInfo = { + .sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, + .pNext = nullptr, + .flags = 0, + .dpy = display, + .window = x11Window, + }; + return createXlibSurface(instance, &createInfo, nullptr, surface); + } +#endif + + reason = "Unsupported GLFW platform for manual Vulkan surface creation"; + return VK_ERROR_EXTENSION_NOT_PRESENT; +} +} + double currentFrameDelta = 0; double Gfx::getCurrentFrameDelta() { return currentFrameDelta; } @@ -23,41 +90,41 @@ void glfwKeyCallback(GLFWwindow* handle, int key, int, int action, int modifier) if (key == -1) { return; } - Window* window = (Window*)glfwGetWindowUserPointer(handle); - window->keyPress((KeyCode)key, (InputAction)action, (KeyModifier)modifier); + auto* window = static_cast(glfwGetWindowUserPointer(handle)); + window->keyPress(static_cast(key), static_cast(action), static_cast(modifier)); } void glfwMouseMoveCallback(GLFWwindow* handle, double xpos, double ypos) { - Window* window = (Window*)glfwGetWindowUserPointer(handle); + auto* window = static_cast(glfwGetWindowUserPointer(handle)); window->mouseMove(xpos, ypos); } void glfwMouseButtonCallback(GLFWwindow* handle, int button, int action, int modifier) { - Window* window = (Window*)glfwGetWindowUserPointer(handle); - window->mouseButton((MouseButton)button, (InputAction)action, (KeyModifier)modifier); + auto* window = static_cast(glfwGetWindowUserPointer(handle)); + window->mouseButton(static_cast(button), static_cast(action), static_cast(modifier)); } void glfwScrollCallback(GLFWwindow* handle, double xoffset, double yoffset) { - Window* window = (Window*)glfwGetWindowUserPointer(handle); + auto* window = static_cast(glfwGetWindowUserPointer(handle)); window->scroll(xoffset, yoffset); } void glfwFileCallback(GLFWwindow* handle, int count, const char** paths) { - Window* window = (Window*)glfwGetWindowUserPointer(handle); + auto* window = static_cast(glfwGetWindowUserPointer(handle)); window->fileDrop(count, paths); } void glfwCloseCallback(GLFWwindow* handle) { - Window* window = (Window*)glfwGetWindowUserPointer(handle); + auto* window = static_cast(glfwGetWindowUserPointer(handle)); window->close(); } void glfwFramebufferResizeCallback(GLFWwindow* handle, int width, int height) { - Window* window = (Window*)glfwGetWindowUserPointer(handle); + auto* window = static_cast(glfwGetWindowUserPointer(handle)); window->resize(width, height); } -Window::Window(PGraphics graphics, const WindowCreateInfo& createInfo) +Seele::Vulkan::Window::Window(PGraphics graphics, const WindowCreateInfo& createInfo) : graphics(graphics), preferences(createInfo), instance(graphics->getInstance()), swapchain(VK_NULL_HANDLE) { glfwGetMonitorContentScale(glfwGetPrimaryMonitor(), &contentScaleX, &contentScaleY); glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); @@ -90,12 +157,20 @@ Window::Window(PGraphics graphics, const WindowCreateInfo& createInfo) if (surfaceResult != VK_SUCCESS || surface == VK_NULL_HANDLE) { const char* glfwError = nullptr; glfwGetError(&glfwError); - std::ostringstream oss; - oss << "Failed to create Vulkan surface via GLFW (VkResult=" << surfaceResult << ")"; - if (glfwError != nullptr) { - oss << ": " << glfwError; + + std::string nativeReason; + surfaceResult = createSurfaceFromNativeHandles(instance, handle, &surface, nativeReason); + if (surfaceResult != VK_SUCCESS || surface == VK_NULL_HANDLE) { + std::ostringstream oss; + oss << "Failed to create Vulkan surface via GLFW (VkResult=" << surfaceResult << ")"; + if (glfwError != nullptr) { + oss << ": " << glfwError; + } + if (!nativeReason.empty()) { + oss << ". Native fallback failed: " << nativeReason; + } + throw std::runtime_error(oss.str()); } - throw std::runtime_error(oss.str()); } querySurface(); @@ -108,17 +183,17 @@ Window::Window(PGraphics graphics, const WindowCreateInfo& createInfo) createSwapChain(); } -Window::~Window() { +Seele::Vulkan::Window::~Window() { vkDestroySwapchainKHR(graphics->getDevice(), swapchain, nullptr); vkDestroySurfaceKHR(instance, surface, nullptr); glfwDestroyWindow(static_cast(windowHandle)); } -void Window::pollInput() { glfwPollEvents(); } +void Seele::Vulkan::Window::pollInput() { glfwPollEvents(); } -void Window::show() { glfwShowWindow(static_cast(windowHandle)); } +void Seele::Vulkan::Window::show() { glfwShowWindow(static_cast(windowHandle)); } -void Window::beginFrame() { +void Seele::Vulkan::Window::beginFrame() { imageAvailableFences[currentSemaphoreIndex]->reset(); imageAvailableSemaphores[currentSemaphoreIndex]->resolveSignal(); imageAvailableSemaphores[currentSemaphoreIndex]->rotateSemaphore(); @@ -139,7 +214,7 @@ void Window::beginFrame() { start = end; } -void Window::endFrame() { +void Seele::Vulkan::Window::endFrame() { swapChainTextures[currentImageIndex]->changeLayout(Gfx::SE_IMAGE_LAYOUT_PRESENT_SRC_KHR, Gfx::SE_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, Gfx::SE_ACCESS_MEMORY_READ_BIT, Gfx::SE_PIPELINE_STAGE_TOP_OF_PIPE_BIT); @@ -169,39 +244,39 @@ void Window::endFrame() { // graphics->waitDeviceIdle(); } -bool Window::shouldClose() const { +bool Seele::Vulkan::Window::shouldClose() const { return glfwWindowShouldClose((GLFWwindow*)windowHandle); } -Gfx::PTexture2D Window::getBackBuffer() const { return PTexture2D(swapChainTextures[currentImageIndex]); } +Gfx::PTexture2D Seele::Vulkan::Window::getBackBuffer() const { return PTexture2D(swapChainTextures[currentImageIndex]); } -void Window::setKeyCallback(std::function callback) { keyCallback = callback; } +void Seele::Vulkan::Window::setKeyCallback(std::function callback) { keyCallback = callback; } -void Window::setMouseMoveCallback(std::function callback) { mouseMoveCallback = callback; } +void Seele::Vulkan::Window::setMouseMoveCallback(std::function callback) { mouseMoveCallback = callback; } -void Window::setMouseButtonCallback(std::function callback) { mouseButtonCallback = callback; } +void Seele::Vulkan::Window::setMouseButtonCallback(std::function callback) { mouseButtonCallback = callback; } -void Window::setScrollCallback(std::function callback) { scrollCallback = callback; } +void Seele::Vulkan::Window::setScrollCallback(std::function callback) { scrollCallback = callback; } -void Window::setFileCallback(std::function callback) { fileCallback = callback; } +void Seele::Vulkan::Window::setFileCallback(std::function callback) { fileCallback = callback; } -void Window::setCloseCallback(std::function callback) { closeCallback = callback; } +void Seele::Vulkan::Window::setCloseCallback(std::function callback) { closeCallback = callback; } -void Window::setResizeCallback(std::function callback) { resizeCallback = callback; } +void Seele::Vulkan::Window::setResizeCallback(std::function callback) { resizeCallback = callback; } -void Window::keyPress(KeyCode code, InputAction action, KeyModifier modifier) { keyCallback(code, action, modifier); } +void Seele::Vulkan::Window::keyPress(Seele::KeyCode code, InputAction action, KeyModifier modifier) { keyCallback(code, action, modifier); } -void Window::mouseMove(double x, double y) { mouseMoveCallback(x, y); } +void Seele::Vulkan::Window::mouseMove(double x, double y) { mouseMoveCallback(x, y); } -void Window::mouseButton(MouseButton button, InputAction action, KeyModifier modifier) { mouseButtonCallback(button, action, modifier); } +void Seele::Vulkan::Window::mouseButton(MouseButton button, InputAction action, KeyModifier modifier) { mouseButtonCallback(button, action, modifier); } -void Window::scroll(double x, double y) { scrollCallback(x, y); } +void Seele::Vulkan::Window::scroll(double x, double y) { scrollCallback(x, y); } -void Window::fileDrop(int num, const char** files) { fileCallback(num, files); } +void Seele::Vulkan::Window::fileDrop(int num, const char** files) { fileCallback(num, files); } -void Window::close() { closeCallback(); } +void Seele::Vulkan::Window::close() { closeCallback(); } -void Window::resize(int width, int height) { +void Seele::Vulkan::Window::resize(int width, int height) { if (width == 0 || height == 0) { paused = true; return; @@ -218,7 +293,7 @@ void Window::resize(int width, int height) { resizeCallback(width, height); } -void Window::querySurface() { +void Seele::Vulkan::Window::querySurface() { vkGetPhysicalDeviceSurfaceCapabilitiesKHR(graphics->getPhysicalDevice(), surface, &capabilities); uint32 numFormats; @@ -232,7 +307,7 @@ void Window::querySurface() { vkGetPhysicalDeviceSurfacePresentModesKHR(graphics->getPhysicalDevice(), surface, &numPresentModes, supportedPresentModes.data()); } -void Window::chooseSwapSurfaceFormat() { +void Seele::Vulkan::Window::chooseSwapSurfaceFormat() { for (const auto& supportedFormat : supportedFormats) { if (supportedFormat.format == cast(preferences.preferredFormat)) { format = supportedFormat; @@ -248,7 +323,7 @@ void Window::chooseSwapSurfaceFormat() { format = supportedFormats[0]; } -void Window::chooseSwapPresentMode() { +void Seele::Vulkan::Window::chooseSwapPresentMode() { for (const auto& supportedPresentMode : supportedPresentModes) { if (supportedPresentMode == VK_PRESENT_MODE_MAILBOX_KHR) { presentMode = supportedPresentMode; @@ -258,7 +333,7 @@ void Window::chooseSwapPresentMode() { presentMode = VK_PRESENT_MODE_FIFO_KHR; } -void Window::chooseSwapExtent() { +void Seele::Vulkan::Window::chooseSwapExtent() { if (capabilities.currentExtent.width != std::numeric_limits::max()) { extent = capabilities.currentExtent; return; @@ -274,7 +349,7 @@ void Window::chooseSwapExtent() { extent.height = std::clamp(extent.height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height); } -void Window::createSwapChain() { +void Seele::Vulkan::Window::createSwapChain() { graphics->waitDeviceIdle(); uint32 imageCount = Gfx::numFramesBuffered; VkSwapchainCreateInfoKHR createInfo = { diff --git a/src/Engine/Graphics/slang-compile.cpp b/src/Engine/Graphics/slang-compile.cpp index 0c28b26..07ca6e6 100644 --- a/src/Engine/Graphics/slang-compile.cpp +++ b/src/Engine/Graphics/slang-compile.cpp @@ -1,6 +1,7 @@ #include "slang-compile.h" #include "Containers/Array.h" #include "Graphics/Descriptor.h" +#include #include #include #include @@ -27,9 +28,56 @@ thread_local Slang::ComPtr specializedComponent; thread_local Slang::ComPtr session; thread_local Array entryPoints; +namespace { +std::filesystem::path getExecutableDirectory() { + std::error_code error; + auto exePath = std::filesystem::read_symlink("/proc/self/exe", error); + if (!error) { + return exePath.parent_path(); + } + return std::filesystem::current_path(); +} + +std::filesystem::path findExistingDirectory(std::initializer_list candidates) { + for (const auto& candidate : candidates) { + std::error_code error; + if (std::filesystem::exists(candidate, error) && std::filesystem::is_directory(candidate, error)) { + return candidate; + } + } + return {}; +} + +void configureDownstreamCompilers(slang::IGlobalSession* session) { + const auto executableDirectory = getExecutableDirectory(); + const auto currentDirectory = std::filesystem::current_path(); + const auto glslangDirectory = findExistingDirectory({ + executableDirectory / "Seele", + executableDirectory / "vcpkg_installed" / "x64-linux" / "lib", + currentDirectory / "Seele", + currentDirectory / "vcpkg_installed" / "x64-linux" / "lib", + }); + + if (!glslangDirectory.empty()) { + const std::string path = glslangDirectory.string(); + session->setDownstreamCompilerPath(SLANG_PASS_THROUGH_GLSLANG, path.c_str()); + session->setDownstreamCompilerPath(SLANG_PASS_THROUGH_SPIRV_OPT, path.c_str()); + session->setDownstreamCompilerPath(SLANG_PASS_THROUGH_SPIRV_DIS, path.c_str()); + } + + // Avoid optional SPIR-V downstream tools that are often unavailable in RenderDoc launch environments. + session->setDefaultDownstreamCompiler(SLANG_SOURCE_LANGUAGE_SPIRV, SLANG_PASS_THROUGH_NONE); + session->setDownstreamCompilerForTransition(SLANG_SPIRV, SLANG_SPIRV, SLANG_PASS_THROUGH_NONE); + session->setDownstreamCompilerForTransition(SLANG_SPIRV, SLANG_SPIRV_ASM, SLANG_PASS_THROUGH_NONE); +} +} + void Seele::beginCompilation(const ShaderCompilationInfo& info, SlangCompileTarget target, Gfx::PPipelineLayout layout) { if (!globalSession) { - slang::createGlobalSession(globalSession.writeRef()); + SlangGlobalSessionDesc sessionDesc = {}; + sessionDesc.enableGLSL = true; + slang::createGlobalSession(&sessionDesc, globalSession.writeRef()); + configureDownstreamCompilers(globalSession); } slang::SessionDesc sessionDesc; sessionDesc.flags = 0; @@ -42,6 +90,30 @@ void Seele::beginCompilation(const ShaderCompilationInfo& info, SlangCompileTarg .intValue0 = info.dumpIntermediate, }, }, + { + .name = slang::CompilerOptionName::Optimization, + .value = + { + .kind = slang::CompilerOptionValueKind::Int, + .intValue0 = SLANG_OPTIMIZATION_LEVEL_NONE, + }, + }, + { + .name = slang::CompilerOptionName::SkipSPIRVValidation, + .value = + { + .kind = slang::CompilerOptionValueKind::Int, + .intValue0 = 1, + }, + }, + { + .name = slang::CompilerOptionName::SkipDownstreamLinking, + .value = + { + .kind = slang::CompilerOptionValueKind::Int, + .intValue0 = 1, + }, + }, }; sessionDesc.compilerOptionEntries = option.data();