268 lines
9.2 KiB
C++
268 lines
9.2 KiB
C++
// 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 "SampleUtils.h"
|
|
|
|
#include "common/Assert.h"
|
|
#include "common/Log.h"
|
|
#include "common/Platform.h"
|
|
#include "utils/BackendBinding.h"
|
|
#include "utils/GLFWUtils.h"
|
|
#include "utils/TerribleCommandBuffer.h"
|
|
|
|
#include <dawn/dawn_proc.h>
|
|
#include <dawn/dawn_wsi.h>
|
|
#include <dawn_native/DawnNative.h>
|
|
#include <dawn_wire/WireClient.h>
|
|
#include <dawn_wire/WireServer.h>
|
|
#include "GLFW/glfw3.h"
|
|
|
|
#include <algorithm>
|
|
#include <cstring>
|
|
|
|
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:
|
|
UNREACHABLE();
|
|
return;
|
|
}
|
|
dawn::ErrorLog() << errorTypeName << " error: " << message;
|
|
}
|
|
|
|
void PrintGLFWError(int code, const char* message) {
|
|
dawn::ErrorLog() << "GLFW error: " << code << " - " << 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_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_OPENGL)
|
|
static wgpu::BackendType backendType = wgpu::BackendType::OpenGL;
|
|
#else
|
|
#error
|
|
#endif
|
|
|
|
static CmdBufType cmdBufType = CmdBufType::Terrible;
|
|
static std::unique_ptr<dawn_native::Instance> instance;
|
|
static utils::BackendBinding* binding = nullptr;
|
|
|
|
static GLFWwindow* window = nullptr;
|
|
|
|
static dawn_wire::WireServer* wireServer = nullptr;
|
|
static dawn_wire::WireClient* wireClient = nullptr;
|
|
static utils::TerribleCommandBuffer* c2sBuf = nullptr;
|
|
static utils::TerribleCommandBuffer* s2cBuf = nullptr;
|
|
|
|
wgpu::Device CreateCppDawnDevice() {
|
|
glfwSetErrorCallback(PrintGLFWError);
|
|
if (!glfwInit()) {
|
|
return wgpu::Device();
|
|
}
|
|
|
|
// Create the test window and discover adapters using it (esp. for OpenGL)
|
|
utils::SetupGLFWWindowHintsForBackend(backendType);
|
|
window = glfwCreateWindow(640, 480, "Dawn window", nullptr, nullptr);
|
|
if (!window) {
|
|
return wgpu::Device();
|
|
}
|
|
|
|
instance = std::make_unique<dawn_native::Instance>();
|
|
utils::DiscoverAdapter(instance.get(), window, backendType);
|
|
|
|
// Get an adapter for the backend to use, and create the device.
|
|
dawn_native::Adapter backendAdapter;
|
|
{
|
|
std::vector<dawn_native::Adapter> adapters = instance->GetAdapters();
|
|
auto adapterIt = std::find_if(adapters.begin(), adapters.end(),
|
|
[](const dawn_native::Adapter adapter) -> bool {
|
|
wgpu::AdapterProperties properties;
|
|
adapter.GetProperties(&properties);
|
|
return properties.backendType == backendType;
|
|
});
|
|
ASSERT(adapterIt != adapters.end());
|
|
backendAdapter = *adapterIt;
|
|
}
|
|
|
|
WGPUDevice backendDevice = backendAdapter.CreateDevice();
|
|
DawnProcTable backendProcs = dawn_native::GetProcs();
|
|
|
|
binding = utils::CreateBinding(backendType, window, backendDevice);
|
|
if (binding == nullptr) {
|
|
return wgpu::Device();
|
|
}
|
|
|
|
// Choose whether to use the backend procs and devices directly, or set up the wire.
|
|
WGPUDevice cDevice = nullptr;
|
|
DawnProcTable procs;
|
|
|
|
switch (cmdBufType) {
|
|
case CmdBufType::None:
|
|
procs = backendProcs;
|
|
cDevice = backendDevice;
|
|
break;
|
|
|
|
case CmdBufType::Terrible:
|
|
{
|
|
c2sBuf = new utils::TerribleCommandBuffer();
|
|
s2cBuf = new utils::TerribleCommandBuffer();
|
|
|
|
dawn_wire::WireServerDescriptor serverDesc = {};
|
|
serverDesc.device = backendDevice;
|
|
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);
|
|
WGPUDevice clientDevice = wireClient->GetDevice();
|
|
DawnProcTable clientProcs = dawn_wire::WireClient::GetProcs();
|
|
s2cBuf->SetHandler(wireClient);
|
|
|
|
procs = clientProcs;
|
|
cDevice = clientDevice;
|
|
}
|
|
break;
|
|
}
|
|
|
|
dawnProcSetProcs(&procs);
|
|
procs.deviceSetUncapturedErrorCallback(cDevice, PrintDeviceError, nullptr);
|
|
return wgpu::Device::Acquire(cDevice);
|
|
}
|
|
|
|
uint64_t GetSwapChainImplementation() {
|
|
return binding->GetSwapChainImplementation();
|
|
}
|
|
|
|
wgpu::TextureFormat GetPreferredSwapChainTextureFormat() {
|
|
DoFlush();
|
|
return static_cast<wgpu::TextureFormat>(binding->GetPreferredSwapChainTextureFormat());
|
|
}
|
|
|
|
wgpu::SwapChain GetSwapChain(const wgpu::Device& device) {
|
|
wgpu::SwapChainDescriptor swapChainDesc;
|
|
swapChainDesc.implementation = GetSwapChainImplementation();
|
|
return device.CreateSwapChain(nullptr, &swapChainDesc);
|
|
}
|
|
|
|
wgpu::TextureView CreateDefaultDepthStencilView(const wgpu::Device& device) {
|
|
wgpu::TextureDescriptor descriptor;
|
|
descriptor.dimension = wgpu::TextureDimension::e2D;
|
|
descriptor.size.width = 640;
|
|
descriptor.size.height = 480;
|
|
descriptor.size.depth = 1;
|
|
descriptor.arrayLayerCount = 1;
|
|
descriptor.sampleCount = 1;
|
|
descriptor.format = wgpu::TextureFormat::Depth24PlusStencil8;
|
|
descriptor.mipLevelCount = 1;
|
|
descriptor.usage = wgpu::TextureUsage::OutputAttachment;
|
|
auto depthStencilTexture = device.CreateTexture(&descriptor);
|
|
return depthStencilTexture.CreateView();
|
|
}
|
|
|
|
bool InitSample(int argc, const char** argv) {
|
|
for (int i = 1; i < argc; i++) {
|
|
if (std::string("-b") == argv[i] || std::string("--backend") == argv[i]) {
|
|
i++;
|
|
if (i < argc && std::string("d3d12") == argv[i]) {
|
|
backendType = wgpu::BackendType::D3D12;
|
|
continue;
|
|
}
|
|
if (i < argc && std::string("metal") == argv[i]) {
|
|
backendType = wgpu::BackendType::Metal;
|
|
continue;
|
|
}
|
|
if (i < argc && std::string("null") == argv[i]) {
|
|
backendType = wgpu::BackendType::Null;
|
|
continue;
|
|
}
|
|
if (i < argc && std::string("opengl") == argv[i]) {
|
|
backendType = wgpu::BackendType::OpenGL;
|
|
continue;
|
|
}
|
|
if (i < argc && std::string("vulkan") == argv[i]) {
|
|
backendType = wgpu::BackendType::Vulkan;
|
|
continue;
|
|
}
|
|
fprintf(stderr, "--backend expects a backend name (opengl, metal, d3d12, null, vulkan)\n");
|
|
return false;
|
|
}
|
|
if (std::string("-c") == argv[i] || std::string("--command-buffer") == argv[i]) {
|
|
i++;
|
|
if (i < argc && std::string("none") == argv[i]) {
|
|
cmdBufType = CmdBufType::None;
|
|
continue;
|
|
}
|
|
if (i < argc && std::string("terrible") == argv[i]) {
|
|
cmdBufType = CmdBufType::Terrible;
|
|
continue;
|
|
}
|
|
fprintf(stderr, "--command-buffer expects a command buffer name (none, terrible)\n");
|
|
return false;
|
|
}
|
|
if (std::string("-h") == argv[i] || std::string("--help") == argv[i]) {
|
|
printf("Usage: %s [-b BACKEND] [-c COMMAND_BUFFER]\n", argv[0]);
|
|
printf(" BACKEND is one of: d3d12, metal, null, opengl, vulkan\n");
|
|
printf(" COMMAND_BUFFER is one of: none, terrible\n");
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void DoFlush() {
|
|
if (cmdBufType == CmdBufType::Terrible) {
|
|
bool c2sSuccess = c2sBuf->Flush();
|
|
bool s2cSuccess = s2cBuf->Flush();
|
|
|
|
ASSERT(c2sSuccess && s2cSuccess);
|
|
}
|
|
glfwPollEvents();
|
|
}
|
|
|
|
bool ShouldQuit() {
|
|
return glfwWindowShouldClose(window);
|
|
}
|
|
|
|
GLFWwindow* GetGLFWWindow() {
|
|
return window;
|
|
}
|