dawn-cmake/examples/SampleUtils.cpp

228 lines
7.5 KiB
C++
Raw Normal View History

// 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"
2018-06-21 01:54:18 +00:00
#include "common/Assert.h"
#include "common/Platform.h"
#include "utils/BackendBinding.h"
#include "utils/TerribleCommandBuffer.h"
2018-07-18 12:28:38 +00:00
#include <dawn/dawn.h>
#include <dawn/dawncpp.h>
#include <dawn/dawn_wsi.h>
#include "GLFW/glfw3.h"
#include <cstring>
#include <iostream>
2018-07-18 11:45:46 +00:00
void PrintDeviceError(const char* message, dawn::CallbackUserdata) {
std::cout << "Device error: " << message << std::endl;
}
void PrintGLFWError(int code, const char* message) {
std::cout << "GLFW error: " << code << " - " << message << std::endl;
}
enum class CmdBufType {
None,
Terrible,
2017-05-09 13:34:13 +00:00
//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 utils::BackendType backendType = utils::BackendType::D3D12;
#elif defined(DAWN_ENABLE_BACKEND_METAL)
static utils::BackendType backendType = utils::BackendType::Metal;
#elif defined(DAWN_ENABLE_BACKEND_OPENGL)
2017-07-28 01:30:57 +00:00
static utils::BackendType backendType = utils::BackendType::OpenGL;
#elif defined(DAWN_ENABLE_BACKEND_VULKAN)
static utils::BackendType backendType = utils::BackendType::Vulkan;
2017-06-05 21:08:55 +00:00
#else
#error
2017-06-05 21:08:55 +00:00
#endif
static CmdBufType cmdBufType = CmdBufType::Terrible;
static utils::BackendBinding* binding = nullptr;
static GLFWwindow* window = nullptr;
static dawn_wire::CommandHandler* wireServer = nullptr;
static dawn_wire::CommandHandler* wireClient = nullptr;
static utils::TerribleCommandBuffer* c2sBuf = nullptr;
static utils::TerribleCommandBuffer* s2cBuf = nullptr;
dawn::Device CreateCppDawnDevice() {
binding = utils::CreateBinding(backendType);
if (binding == nullptr) {
2018-07-18 11:45:46 +00:00
return dawn::Device();
}
glfwSetErrorCallback(PrintGLFWError);
if (!glfwInit()) {
2018-07-18 11:45:46 +00:00
return dawn::Device();
}
binding->SetupGLFWWindowHints();
2018-07-18 13:32:04 +00:00
window = glfwCreateWindow(640, 480, "Dawn window", nullptr, nullptr);
if (!window) {
2018-07-18 11:45:46 +00:00
return dawn::Device();
}
binding->SetWindow(window);
dawnDevice backendDevice;
dawnProcTable backendProcs;
binding->GetProcAndDevice(&backendProcs, &backendDevice);
dawnDevice 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();
2017-05-09 13:34:13 +00:00
wireServer = dawn_wire::NewServerCommandHandler(backendDevice, backendProcs, s2cBuf);
2017-05-09 13:34:13 +00:00
c2sBuf->SetHandler(wireServer);
dawnDevice clientDevice;
dawnProcTable clientProcs;
wireClient = dawn_wire::NewClientDevice(&clientProcs, &clientDevice, c2sBuf);
2017-05-09 13:34:13 +00:00
s2cBuf->SetHandler(wireClient);
procs = clientProcs;
cDevice = clientDevice;
}
break;
}
dawnSetProcs(&procs);
procs.deviceSetErrorCallback(cDevice, PrintDeviceError, 0);
2018-07-18 11:45:46 +00:00
return dawn::Device::Acquire(cDevice);
}
2017-07-28 01:30:57 +00:00
uint64_t GetSwapChainImplementation() {
return binding->GetSwapChainImplementation();
}
2018-07-18 11:45:46 +00:00
dawn::TextureFormat GetPreferredSwapChainTextureFormat() {
DoFlush();
2018-07-18 11:45:46 +00:00
return static_cast<dawn::TextureFormat>(binding->GetPreferredSwapChainTextureFormat());
}
2018-07-18 11:45:46 +00:00
dawn::SwapChain GetSwapChain(const dawn::Device &device) {
2017-07-28 01:30:57 +00:00
return device.CreateSwapChainBuilder()
.SetImplementation(GetSwapChainImplementation())
.GetResult();
}
2018-07-18 11:45:46 +00:00
dawn::TextureView CreateDefaultDepthStencilView(const dawn::Device& device) {
2017-07-28 01:30:57 +00:00
auto depthStencilTexture = device.CreateTextureBuilder()
2018-07-18 11:45:46 +00:00
.SetDimension(dawn::TextureDimension::e2D)
2017-07-28 01:30:57 +00:00
.SetExtent(640, 480, 1)
2018-07-18 11:45:46 +00:00
.SetFormat(dawn::TextureFormat::D32FloatS8Uint)
2017-07-28 01:30:57 +00:00
.SetMipLevels(1)
2018-07-18 11:45:46 +00:00
.SetAllowedUsage(dawn::TextureUsageBit::OutputAttachment)
2017-07-28 01:30:57 +00:00
.GetResult();
return depthStencilTexture.CreateTextureViewBuilder()
.GetResult();
}
2018-07-18 11:45:46 +00:00
void GetNextRenderPassDescriptor(const dawn::Device& device,
const dawn::SwapChain& swapchain,
const dawn::TextureView& depthStencilView,
dawn::Texture* backbuffer,
dawn::RenderPassDescriptor* info) {
2017-07-28 01:30:57 +00:00
*backbuffer = swapchain.GetNextTexture();
auto backbufferView = backbuffer->CreateTextureViewBuilder().GetResult();
*info = device.CreateRenderPassDescriptorBuilder()
2018-07-18 11:45:46 +00:00
.SetColorAttachment(0, backbufferView, dawn::LoadOp::Clear)
.SetDepthStencilAttachment(depthStencilView, dawn::LoadOp::Clear, dawn::LoadOp::Clear)
2017-07-28 01:30:57 +00:00
.GetResult();
}
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 = utils::BackendType::D3D12;
continue;
}
if (i < argc && std::string("metal") == argv[i]) {
backendType = utils::BackendType::Metal;
continue;
}
if (i < argc && std::string("null") == argv[i]) {
backendType = utils::BackendType::Null;
continue;
}
if (i < argc && std::string("opengl") == argv[i]) {
backendType = utils::BackendType::OpenGL;
continue;
}
if (i < argc && std::string("vulkan") == argv[i]) {
backendType = utils::BackendType::Vulkan;
continue;
}
fprintf(stderr, "--backend expects a backend name (opengl, metal, d3d12, null, vulkan)\n");
return false;
}
2017-07-28 01:30:57 +00:00
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;
}
2017-07-28 01:30:57 +00:00
void DoFlush() {
if (cmdBufType == CmdBufType::Terrible) {
2018-06-21 01:54:18 +00:00
ASSERT(c2sBuf->Flush());
ASSERT(s2cBuf->Flush());
}
glfwPollEvents();
}
bool ShouldQuit() {
return glfwWindowShouldClose(window);
}
GLFWwindow* GetGLFWWindow() {
return window;
}