| // Copyright 2017 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/samples/SampleUtils.h" | |
| #include <algorithm> | |
| #include <cstring> | |
| #include <memory> | |
| #include <string> | |
| #include <string_view> | |
| #include <vector> | |
| #include "GLFW/glfw3.h" | |
| #include "dawn/common/Assert.h" | |
| #include "dawn/common/Log.h" | |
| #include "dawn/common/Platform.h" | |
| #include "dawn/common/SystemUtils.h" | |
| #include "dawn/dawn_proc.h" | |
| #include "dawn/native/DawnNative.h" | |
| #include "dawn/utils/TerribleCommandBuffer.h" | |
| #include "dawn/wire/WireClient.h" | |
| #include "dawn/wire/WireServer.h" | |
| #include "webgpu/webgpu_glfw.h" | |
| void PrintDeviceError(WGPUErrorType errorType, const char* message, void*) { | |
| const char* errorTypeName = ""; | |
| switch (errorType) { | |
| case WGPUErrorType_Validation: | |
| errorTypeName = "Validation"; | |
| break; | |
| case WGPUErrorType_OutOfMemory: | |
| errorTypeName = "Out of memory"; | |
| break; | |
| case WGPUErrorType_Unknown: | |
| errorTypeName = "Unknown"; | |
| break; | |
| case WGPUErrorType_DeviceLost: | |
| errorTypeName = "Device lost"; | |
| break; | |
| default: | |
| DAWN_UNREACHABLE(); | |
| return; | |
| } | |
| dawn::ErrorLog() << errorTypeName << " error: " << message; | |
| } | |
| void DeviceLostCallback(WGPUDeviceLostReason reason, const char* message, void*) { | |
| dawn::ErrorLog() << "Device lost: " << message; | |
| } | |
| void PrintGLFWError(int code, const char* message) { | |
| dawn::ErrorLog() << "GLFW error: " << code << " - " << message; | |
| } | |
| void DeviceLogCallback(WGPULoggingType type, const char* message, void*) { | |
| dawn::ErrorLog() << "Device log: " << message; | |
| } | |
| enum class CmdBufType { | |
| None, | |
| Terrible, | |
| // TODO(cwallez@chromium.org): double terrible cmdbuf | |
| }; | |
| // Default to D3D12, Metal, Vulkan, OpenGL in that order as D3D12 and Metal are the preferred on | |
| // their respective platforms, and Vulkan is preferred to OpenGL | |
| #if defined(DAWN_ENABLE_BACKEND_D3D12) | |
| static wgpu::BackendType backendType = wgpu::BackendType::D3D12; | |
| #elif defined(DAWN_ENABLE_BACKEND_D3D11) | |
| static wgpu::BackendType backendType = wgpu::BackendType::D3D11; | |
| #elif defined(DAWN_ENABLE_BACKEND_METAL) | |
| static wgpu::BackendType backendType = wgpu::BackendType::Metal; | |
| #elif defined(DAWN_ENABLE_BACKEND_VULKAN) | |
| static wgpu::BackendType backendType = wgpu::BackendType::Vulkan; | |
| #elif defined(DAWN_ENABLE_BACKEND_OPENGLES) | |
| static wgpu::BackendType backendType = wgpu::BackendType::OpenGLES; | |
| #elif defined(DAWN_ENABLE_BACKEND_DESKTOP_GL) | |
| static wgpu::BackendType backendType = wgpu::BackendType::OpenGL; | |
| #else | |
| #error | |
| #endif | |
| static wgpu::AdapterType adapterType = wgpu::AdapterType::Unknown; | |
| static std::vector<std::string> enableToggles; | |
| static std::vector<std::string> disableToggles; | |
| static CmdBufType cmdBufType = CmdBufType::Terrible; | |
| static std::unique_ptr<dawn::native::Instance> instance; | |
| static wgpu::SwapChain swapChain; | |
| static GLFWwindow* window = nullptr; | |
| static dawn::wire::WireServer* wireServer = nullptr; | |
| static dawn::wire::WireClient* wireClient = nullptr; | |
| static dawn::utils::TerribleCommandBuffer* c2sBuf = nullptr; | |
| static dawn::utils::TerribleCommandBuffer* s2cBuf = nullptr; | |
| static constexpr uint32_t kWidth = 640; | |
| static constexpr uint32_t kHeight = 480; | |
| wgpu::Device CreateCppDawnDevice() { | |
| dawn::ScopedEnvironmentVar angleDefaultPlatform; | |
| if (dawn::GetEnvironmentVar("ANGLE_DEFAULT_PLATFORM").first.empty()) { | |
| angleDefaultPlatform.Set("ANGLE_DEFAULT_PLATFORM", "swiftshader"); | |
| } | |
| glfwSetErrorCallback(PrintGLFWError); | |
| if (!glfwInit()) { | |
| return wgpu::Device(); | |
| } | |
| // Create the test window with no client API. | |
| glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); | |
| glfwWindowHint(GLFW_COCOA_RETINA_FRAMEBUFFER, GLFW_FALSE); | |
| window = glfwCreateWindow(kWidth, kHeight, "Dawn window", nullptr, nullptr); | |
| if (!window) { | |
| return wgpu::Device(); | |
| } | |
| WGPUInstanceDescriptor instanceDescriptor{}; | |
| instanceDescriptor.features.timedWaitAnyEnable = true; | |
| instance = std::make_unique<dawn::native::Instance>(&instanceDescriptor); | |
| wgpu::RequestAdapterOptions options = {}; | |
| options.backendType = backendType; | |
| // Get an adapter for the backend to use, and create the device. | |
| auto adapters = instance->EnumerateAdapters(&options); | |
| wgpu::DawnAdapterPropertiesPowerPreference power_props{}; | |
| wgpu::AdapterProperties adapterProperties{}; | |
| adapterProperties.nextInChain = &power_props; | |
| // Find the first adapter which satisfies the adapterType requirement. | |
| auto isAdapterType = [&adapterProperties](const auto& adapter) -> bool { | |
| // picks the first adapter when adapterType is unknown. | |
| if (adapterType == wgpu::AdapterType::Unknown) { | |
| return true; | |
| } | |
| adapter.GetProperties(&adapterProperties); | |
| return adapterProperties.adapterType == adapterType; | |
| }; | |
| auto preferredAdapter = std::find_if(adapters.begin(), adapters.end(), isAdapterType); | |
| if (preferredAdapter == adapters.end()) { | |
| fprintf(stderr, "Failed to find an adapter! Please try another adapter type.\n"); | |
| return wgpu::Device(); | |
| } | |
| std::vector<const char*> enableToggleNames; | |
| std::vector<const char*> disabledToggleNames; | |
| for (const std::string& toggle : enableToggles) { | |
| enableToggleNames.push_back(toggle.c_str()); | |
| } | |
| for (const std::string& toggle : disableToggles) { | |
| disabledToggleNames.push_back(toggle.c_str()); | |
| } | |
| WGPUDawnTogglesDescriptor toggles; | |
| toggles.chain.sType = WGPUSType_DawnTogglesDescriptor; | |
| toggles.chain.next = nullptr; | |
| toggles.enabledToggles = enableToggleNames.data(); | |
| toggles.enabledToggleCount = enableToggleNames.size(); | |
| toggles.disabledToggles = disabledToggleNames.data(); | |
| toggles.disabledToggleCount = disabledToggleNames.size(); | |
| WGPUDeviceDescriptor deviceDesc = {}; | |
| deviceDesc.nextInChain = reinterpret_cast<WGPUChainedStruct*>(&toggles); | |
| WGPUDevice backendDevice = preferredAdapter->CreateDevice(&deviceDesc); | |
| DawnProcTable backendProcs = dawn::native::GetProcs(); | |
| // Create the swapchain | |
| auto surfaceChainedDesc = wgpu::glfw::SetupWindowAndGetSurfaceDescriptor(window); | |
| WGPUSurfaceDescriptor surfaceDesc; | |
| surfaceDesc.nextInChain = reinterpret_cast<WGPUChainedStruct*>(surfaceChainedDesc.get()); | |
| WGPUSurface surface = backendProcs.instanceCreateSurface(instance->Get(), &surfaceDesc); | |
| WGPUSwapChainDescriptor swapChainDesc = {}; | |
| swapChainDesc.usage = WGPUTextureUsage_RenderAttachment; | |
| swapChainDesc.format = static_cast<WGPUTextureFormat>(GetPreferredSwapChainTextureFormat()); | |
| swapChainDesc.width = kWidth; | |
| swapChainDesc.height = kHeight; | |
| swapChainDesc.presentMode = WGPUPresentMode_Mailbox; | |
| WGPUSwapChain backendSwapChain = | |
| backendProcs.deviceCreateSwapChain(backendDevice, surface, &swapChainDesc); | |
| // Choose whether to use the backend procs and devices/swapchains directly, or set up the wire. | |
| WGPUDevice cDevice = nullptr; | |
| DawnProcTable procs; | |
| switch (cmdBufType) { | |
| case CmdBufType::None: | |
| procs = backendProcs; | |
| cDevice = backendDevice; | |
| swapChain = wgpu::SwapChain::Acquire(backendSwapChain); | |
| break; | |
| case CmdBufType::Terrible: { | |
| c2sBuf = new dawn::utils::TerribleCommandBuffer(); | |
| s2cBuf = new dawn::utils::TerribleCommandBuffer(); | |
| dawn::wire::WireServerDescriptor serverDesc = {}; | |
| serverDesc.procs = &backendProcs; | |
| serverDesc.serializer = s2cBuf; | |
| wireServer = new dawn::wire::WireServer(serverDesc); | |
| c2sBuf->SetHandler(wireServer); | |
| dawn::wire::WireClientDescriptor clientDesc = {}; | |
| clientDesc.serializer = c2sBuf; | |
| wireClient = new dawn::wire::WireClient(clientDesc); | |
| procs = dawn::wire::client::GetProcs(); | |
| s2cBuf->SetHandler(wireClient); | |
| auto deviceReservation = wireClient->ReserveDevice(); | |
| wireServer->InjectDevice(backendDevice, deviceReservation.id, | |
| deviceReservation.generation); | |
| cDevice = deviceReservation.device; | |
| auto swapChainReservation = wireClient->ReserveSwapChain(cDevice, &swapChainDesc); | |
| wireServer->InjectSwapChain(backendSwapChain, swapChainReservation.id, | |
| swapChainReservation.generation, deviceReservation.id, | |
| deviceReservation.generation); | |
| swapChain = wgpu::SwapChain::Acquire(swapChainReservation.swapchain); | |
| } break; | |
| } | |
| dawnProcSetProcs(&procs); | |
| procs.deviceSetUncapturedErrorCallback(cDevice, PrintDeviceError, nullptr); | |
| procs.deviceSetDeviceLostCallback(cDevice, DeviceLostCallback, nullptr); | |
| procs.deviceSetLoggingCallback(cDevice, DeviceLogCallback, nullptr); | |
| return wgpu::Device::Acquire(cDevice); | |
| } | |
| wgpu::TextureFormat GetPreferredSwapChainTextureFormat() { | |
| // TODO(dawn:1362): Return the adapter's preferred format when implemented. | |
| return wgpu::TextureFormat::BGRA8Unorm; | |
| } | |
| wgpu::SwapChain GetSwapChain() { | |
| return swapChain; | |
| } | |
| wgpu::TextureView CreateDefaultDepthStencilView(const wgpu::Device& device) { | |
| wgpu::TextureDescriptor descriptor; | |
| descriptor.dimension = wgpu::TextureDimension::e2D; | |
| descriptor.size.width = kWidth; | |
| descriptor.size.height = kHeight; | |
| descriptor.size.depthOrArrayLayers = 1; | |
| descriptor.sampleCount = 1; | |
| descriptor.format = wgpu::TextureFormat::Depth24PlusStencil8; | |
| descriptor.mipLevelCount = 1; | |
| descriptor.usage = wgpu::TextureUsage::RenderAttachment; | |
| auto depthStencilTexture = device.CreateTexture(&descriptor); | |
| return depthStencilTexture.CreateView(); | |
| } | |
| bool InitSample(int argc, const char** argv) { | |
| for (int i = 1; i < argc; i++) { | |
| std::string_view arg(argv[i]); | |
| std::string_view opt, value; | |
| static constexpr struct Option { | |
| const char* shortOpt; | |
| const char* longOpt; | |
| bool hasValue; | |
| } options[] = { | |
| {"-b", "--backend=", true}, {"-c", "--cmd-buf=", true}, | |
| {"-e", "--enable-toggle=", true}, {"-d", "--disable-toggle=", true}, | |
| {"-a", "--adapter-type=", true}, {"-h", "--help", false}, | |
| }; | |
| for (const Option& option : options) { | |
| if (!option.hasValue) { | |
| if (arg == option.shortOpt || arg == option.longOpt) { | |
| opt = option.shortOpt; | |
| break; | |
| } | |
| continue; | |
| } | |
| if (arg == option.shortOpt) { | |
| opt = option.shortOpt; | |
| if (++i < argc) { | |
| value = argv[i]; | |
| } | |
| break; | |
| } | |
| if (arg.rfind(option.longOpt, 0) == 0) { | |
| opt = option.shortOpt; | |
| if (option.hasValue) { | |
| value = arg.substr(strlen(option.longOpt)); | |
| } | |
| break; | |
| } | |
| } | |
| if (opt == "-b") { | |
| if (value == "d3d11") { | |
| backendType = wgpu::BackendType::D3D11; | |
| continue; | |
| } | |
| if (value == "d3d12") { | |
| backendType = wgpu::BackendType::D3D12; | |
| continue; | |
| } | |
| if (value == "metal") { | |
| backendType = wgpu::BackendType::Metal; | |
| continue; | |
| } | |
| if (value == "null") { | |
| backendType = wgpu::BackendType::Null; | |
| continue; | |
| } | |
| if (value == "opengl") { | |
| backendType = wgpu::BackendType::OpenGL; | |
| continue; | |
| } | |
| if (value == "opengles") { | |
| backendType = wgpu::BackendType::OpenGLES; | |
| continue; | |
| } | |
| if (value == "vulkan") { | |
| backendType = wgpu::BackendType::Vulkan; | |
| continue; | |
| } | |
| fprintf(stderr, | |
| "--backend expects a backend name (opengl, opengles, metal, d3d12, null, " | |
| "vulkan)\n"); | |
| return false; | |
| } | |
| if (opt == "-c") { | |
| if (value == "none") { | |
| cmdBufType = CmdBufType::None; | |
| continue; | |
| } | |
| if (value == "terrible") { | |
| cmdBufType = CmdBufType::Terrible; | |
| continue; | |
| } | |
| fprintf(stderr, "--command-buffer expects a command buffer name (none, terrible)\n"); | |
| return false; | |
| } | |
| if (opt == "-e") { | |
| enableToggles.push_back(std::string(value)); | |
| continue; | |
| } | |
| if (opt == "-d") { | |
| disableToggles.push_back(std::string(value)); | |
| continue; | |
| } | |
| if (opt == "-a") { | |
| if (value == "discrete") { | |
| adapterType = wgpu::AdapterType::DiscreteGPU; | |
| continue; | |
| } | |
| if (value == "integrated") { | |
| adapterType = wgpu::AdapterType::IntegratedGPU; | |
| continue; | |
| } | |
| if (value == "cpu") { | |
| adapterType = wgpu::AdapterType::CPU; | |
| continue; | |
| } | |
| fprintf(stderr, "--adapter-type expects an adapter type (discrete, integrated, cpu)\n"); | |
| return false; | |
| } | |
| if (opt == "-h") { | |
| printf( | |
| "Usage: %s [-b BACKEND] [-c COMMAND_BUFFER] [-e TOGGLE] [-d TOGGLE] [-a " | |
| "ADAPTER]\n", | |
| argv[0]); | |
| printf(" BACKEND is one of: d3d12, metal, null, opengl, opengles, vulkan\n"); | |
| printf(" COMMAND_BUFFER is one of: none, terrible\n"); | |
| printf(" TOGGLE is device toggle name to enable or disable\n"); | |
| printf(" ADAPTER is one of: discrete, integrated, cpu\n"); | |
| return false; | |
| } | |
| } | |
| // TODO(dawn:810): Reenable once the OpenGL(ES) backend is able to create its own context such | |
| // that it can use surface-based swapchains. | |
| if (backendType == wgpu::BackendType::OpenGL || backendType == wgpu::BackendType::OpenGLES) { | |
| fprintf(stderr, | |
| "The OpenGL(ES) backend is temporarily not supported for samples. See " | |
| "https://crbug.com/dawn/810"); | |
| return false; | |
| } | |
| return true; | |
| } | |
| void DoFlush() { | |
| if (cmdBufType == CmdBufType::Terrible) { | |
| bool c2sSuccess = c2sBuf->Flush(); | |
| bool s2cSuccess = s2cBuf->Flush(); | |
| DAWN_ASSERT(c2sSuccess && s2cSuccess); | |
| } | |
| glfwPollEvents(); | |
| } | |
| bool ShouldQuit() { | |
| return glfwWindowShouldClose(window); | |
| } | |
| GLFWwindow* GetGLFWWindow() { | |
| return window; | |
| } | |
| void ProcessEvents() { | |
| dawn::native::InstanceProcessEvents(instance->Get()); | |
| } |