mirror of
https://github.com/encounter/aurora.git
synced 2025-12-16 16:37:04 +00:00
Initial commit
This commit is contained in:
466
lib/webgpu/gpu.cpp
Normal file
466
lib/webgpu/gpu.cpp
Normal file
@@ -0,0 +1,466 @@
|
||||
#include "gpu.hpp"
|
||||
|
||||
#include <aurora/aurora.h>
|
||||
|
||||
#include "../window.hpp"
|
||||
#include "../internal.hpp"
|
||||
|
||||
#include <SDL.h>
|
||||
#include <dawn/native/DawnNative.h>
|
||||
#include <magic_enum.hpp>
|
||||
#include <memory>
|
||||
#include <algorithm>
|
||||
|
||||
#include "../dawn/BackendBinding.hpp"
|
||||
|
||||
namespace aurora::webgpu {
|
||||
static Module Log("aurora::gpu");
|
||||
|
||||
WGPUDevice g_device;
|
||||
WGPUQueue g_queue;
|
||||
WGPUSwapChain g_swapChain;
|
||||
WGPUBackendType g_backendType;
|
||||
GraphicsConfig g_graphicsConfig;
|
||||
TextureWithSampler g_frameBuffer;
|
||||
TextureWithSampler g_frameBufferResolved;
|
||||
TextureWithSampler g_depthBuffer;
|
||||
|
||||
// EFB -> XFB copy pipeline
|
||||
static WGPUBindGroupLayout g_CopyBindGroupLayout;
|
||||
WGPURenderPipeline g_CopyPipeline;
|
||||
WGPUBindGroup g_CopyBindGroup;
|
||||
|
||||
static std::unique_ptr<dawn::native::Instance> g_Instance;
|
||||
static dawn::native::Adapter g_Adapter;
|
||||
static WGPUAdapterProperties g_AdapterProperties;
|
||||
static std::unique_ptr<utils::BackendBinding> g_BackendBinding;
|
||||
|
||||
TextureWithSampler create_render_texture(bool multisampled) {
|
||||
const WGPUExtent3D size{
|
||||
.width = g_graphicsConfig.width,
|
||||
.height = g_graphicsConfig.height,
|
||||
.depthOrArrayLayers = 1,
|
||||
};
|
||||
const auto format = g_graphicsConfig.colorFormat;
|
||||
uint32_t sampleCount = 1;
|
||||
if (multisampled) {
|
||||
sampleCount = g_graphicsConfig.msaaSamples;
|
||||
}
|
||||
const WGPUTextureDescriptor textureDescriptor{
|
||||
.label = "Render texture",
|
||||
.usage = WGPUTextureUsage_RenderAttachment | WGPUTextureUsage_TextureBinding | WGPUTextureUsage_CopySrc |
|
||||
WGPUTextureUsage_CopyDst,
|
||||
.dimension = WGPUTextureDimension_2D,
|
||||
.size = size,
|
||||
.format = format,
|
||||
.mipLevelCount = 1,
|
||||
.sampleCount = sampleCount,
|
||||
};
|
||||
auto texture = wgpuDeviceCreateTexture(g_device, &textureDescriptor);
|
||||
|
||||
const WGPUTextureViewDescriptor viewDescriptor{
|
||||
.dimension = WGPUTextureViewDimension_2D,
|
||||
.mipLevelCount = WGPU_MIP_LEVEL_COUNT_UNDEFINED,
|
||||
.arrayLayerCount = WGPU_ARRAY_LAYER_COUNT_UNDEFINED,
|
||||
};
|
||||
auto view = wgpuTextureCreateView(texture, &viewDescriptor);
|
||||
|
||||
const WGPUSamplerDescriptor samplerDescriptor{
|
||||
.label = "Render sampler",
|
||||
.addressModeU = WGPUAddressMode_ClampToEdge,
|
||||
.addressModeV = WGPUAddressMode_ClampToEdge,
|
||||
.addressModeW = WGPUAddressMode_ClampToEdge,
|
||||
.magFilter = WGPUFilterMode_Linear,
|
||||
.minFilter = WGPUFilterMode_Linear,
|
||||
.mipmapFilter = WGPUFilterMode_Linear,
|
||||
.lodMinClamp = 0.f,
|
||||
.lodMaxClamp = 1000.f,
|
||||
.maxAnisotropy = 1,
|
||||
};
|
||||
auto sampler = wgpuDeviceCreateSampler(g_device, &samplerDescriptor);
|
||||
|
||||
return {
|
||||
.texture{texture},
|
||||
.view{view},
|
||||
.size = size,
|
||||
.format = format,
|
||||
.sampler{sampler},
|
||||
};
|
||||
}
|
||||
|
||||
static TextureWithSampler create_depth_texture() {
|
||||
const WGPUExtent3D size{
|
||||
.width = g_graphicsConfig.width,
|
||||
.height = g_graphicsConfig.height,
|
||||
.depthOrArrayLayers = 1,
|
||||
};
|
||||
const auto format = g_graphicsConfig.depthFormat;
|
||||
const WGPUTextureDescriptor textureDescriptor{
|
||||
.label = "Depth texture",
|
||||
.usage = WGPUTextureUsage_RenderAttachment | WGPUTextureUsage_TextureBinding,
|
||||
.dimension = WGPUTextureDimension_2D,
|
||||
.size = size,
|
||||
.format = format,
|
||||
.mipLevelCount = 1,
|
||||
.sampleCount = g_graphicsConfig.msaaSamples,
|
||||
};
|
||||
auto texture = wgpuDeviceCreateTexture(g_device, &textureDescriptor);
|
||||
|
||||
const WGPUTextureViewDescriptor viewDescriptor{
|
||||
.dimension = WGPUTextureViewDimension_2D,
|
||||
.mipLevelCount = WGPU_MIP_LEVEL_COUNT_UNDEFINED,
|
||||
.arrayLayerCount = WGPU_ARRAY_LAYER_COUNT_UNDEFINED,
|
||||
};
|
||||
auto view = wgpuTextureCreateView(texture, &viewDescriptor);
|
||||
|
||||
const WGPUSamplerDescriptor samplerDescriptor{
|
||||
.label = "Depth sampler",
|
||||
.addressModeU = WGPUAddressMode_ClampToEdge,
|
||||
.addressModeV = WGPUAddressMode_ClampToEdge,
|
||||
.addressModeW = WGPUAddressMode_ClampToEdge,
|
||||
.magFilter = WGPUFilterMode_Linear,
|
||||
.minFilter = WGPUFilterMode_Linear,
|
||||
.mipmapFilter = WGPUFilterMode_Linear,
|
||||
.lodMinClamp = 0.f,
|
||||
.lodMaxClamp = 1000.f,
|
||||
.maxAnisotropy = 1,
|
||||
};
|
||||
auto sampler = wgpuDeviceCreateSampler(g_device, &samplerDescriptor);
|
||||
|
||||
return {
|
||||
.texture{texture},
|
||||
.view{view},
|
||||
.size = size,
|
||||
.format = format,
|
||||
.sampler{sampler},
|
||||
};
|
||||
}
|
||||
|
||||
void create_copy_pipeline() {
|
||||
WGPUShaderModuleWGSLDescriptor sourceDescriptor{
|
||||
.chain = {.sType = WGPUSType_ShaderModuleWGSLDescriptor},
|
||||
.source = R"""(
|
||||
@group(0) @binding(0)
|
||||
var efb_sampler: sampler;
|
||||
@group(0) @binding(1)
|
||||
var efb_texture: texture_2d<f32>;
|
||||
|
||||
struct VertexOutput {
|
||||
@builtin(position) pos: vec4<f32>,
|
||||
@location(0) uv: vec2<f32>,
|
||||
};
|
||||
|
||||
var<private> pos: array<vec2<f32>, 3> = array<vec2<f32>, 3>(
|
||||
vec2(-1.0, 1.0),
|
||||
vec2(-1.0, -3.0),
|
||||
vec2(3.0, 1.0),
|
||||
);
|
||||
var<private> uvs: array<vec2<f32>, 3> = array<vec2<f32>, 3>(
|
||||
vec2(0.0, 0.0),
|
||||
vec2(0.0, 2.0),
|
||||
vec2(2.0, 0.0),
|
||||
);
|
||||
|
||||
@stage(vertex)
|
||||
fn vs_main(@builtin(vertex_index) vtxIdx: u32) -> VertexOutput {
|
||||
var out: VertexOutput;
|
||||
out.pos = vec4<f32>(pos[vtxIdx], 0.0, 1.0);
|
||||
out.uv = uvs[vtxIdx];
|
||||
return out;
|
||||
}
|
||||
|
||||
@stage(fragment)
|
||||
fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
|
||||
return textureSample(efb_texture, efb_sampler, in.uv);
|
||||
}
|
||||
)""",
|
||||
};
|
||||
const WGPUShaderModuleDescriptor moduleDescriptor{
|
||||
.nextInChain = &sourceDescriptor.chain,
|
||||
.label = "XFB Copy Module",
|
||||
};
|
||||
auto module = wgpuDeviceCreateShaderModule(g_device, &moduleDescriptor);
|
||||
const std::array colorTargets{WGPUColorTargetState{
|
||||
.format = g_graphicsConfig.colorFormat,
|
||||
.writeMask = WGPUColorWriteMask_All,
|
||||
}};
|
||||
const WGPUFragmentState fragmentState{
|
||||
.module = module,
|
||||
.entryPoint = "fs_main",
|
||||
.targetCount = colorTargets.size(),
|
||||
.targets = colorTargets.data(),
|
||||
};
|
||||
const std::array bindGroupLayoutEntries{
|
||||
WGPUBindGroupLayoutEntry{
|
||||
.binding = 0,
|
||||
.visibility = WGPUShaderStage_Fragment,
|
||||
.sampler =
|
||||
WGPUSamplerBindingLayout{
|
||||
.type = WGPUSamplerBindingType_Filtering,
|
||||
},
|
||||
},
|
||||
WGPUBindGroupLayoutEntry{
|
||||
.binding = 1,
|
||||
.visibility = WGPUShaderStage_Fragment,
|
||||
.texture =
|
||||
WGPUTextureBindingLayout{
|
||||
.sampleType = WGPUTextureSampleType_Float,
|
||||
.viewDimension = WGPUTextureViewDimension_2D,
|
||||
},
|
||||
},
|
||||
};
|
||||
const WGPUBindGroupLayoutDescriptor bindGroupLayoutDescriptor{
|
||||
.entryCount = bindGroupLayoutEntries.size(),
|
||||
.entries = bindGroupLayoutEntries.data(),
|
||||
};
|
||||
g_CopyBindGroupLayout = wgpuDeviceCreateBindGroupLayout(g_device, &bindGroupLayoutDescriptor);
|
||||
const WGPUPipelineLayoutDescriptor layoutDescriptor{
|
||||
.bindGroupLayoutCount = 1,
|
||||
.bindGroupLayouts = &g_CopyBindGroupLayout,
|
||||
};
|
||||
auto pipelineLayout = wgpuDeviceCreatePipelineLayout(g_device, &layoutDescriptor);
|
||||
const WGPURenderPipelineDescriptor pipelineDescriptor{
|
||||
.layout = pipelineLayout,
|
||||
.vertex =
|
||||
WGPUVertexState{
|
||||
.module = module,
|
||||
.entryPoint = "vs_main",
|
||||
},
|
||||
.primitive =
|
||||
WGPUPrimitiveState{
|
||||
.topology = WGPUPrimitiveTopology_TriangleList,
|
||||
},
|
||||
.multisample =
|
||||
WGPUMultisampleState{
|
||||
.count = 1,
|
||||
.mask = UINT32_MAX,
|
||||
},
|
||||
.fragment = &fragmentState,
|
||||
};
|
||||
g_CopyPipeline = wgpuDeviceCreateRenderPipeline(g_device, &pipelineDescriptor);
|
||||
wgpuPipelineLayoutRelease(pipelineLayout);
|
||||
}
|
||||
|
||||
void create_copy_bind_group() {
|
||||
const std::array bindGroupEntries{
|
||||
WGPUBindGroupEntry{
|
||||
.binding = 0,
|
||||
.sampler = g_graphicsConfig.msaaSamples > 1 ? g_frameBufferResolved.sampler : g_frameBuffer.sampler,
|
||||
},
|
||||
WGPUBindGroupEntry{
|
||||
.binding = 1,
|
||||
.textureView = g_graphicsConfig.msaaSamples > 1 ? g_frameBufferResolved.view : g_frameBuffer.view,
|
||||
},
|
||||
};
|
||||
const WGPUBindGroupDescriptor bindGroupDescriptor{
|
||||
.layout = g_CopyBindGroupLayout,
|
||||
.entryCount = bindGroupEntries.size(),
|
||||
.entries = bindGroupEntries.data(),
|
||||
};
|
||||
g_CopyBindGroup = wgpuDeviceCreateBindGroup(g_device, &bindGroupDescriptor);
|
||||
}
|
||||
|
||||
static void error_callback(WGPUErrorType type, char const* message, void* userdata) {
|
||||
Log.report(LOG_FATAL, FMT_STRING("Dawn error {}: {}"), magic_enum::enum_name(static_cast<WGPUErrorType>(type)),
|
||||
message);
|
||||
}
|
||||
|
||||
static void device_callback(WGPURequestDeviceStatus status, WGPUDevice device, char const* message, void* userdata) {
|
||||
if (status == WGPURequestDeviceStatus_Success) {
|
||||
g_device = device;
|
||||
} else {
|
||||
Log.report(LOG_WARNING, FMT_STRING("Device request failed with message: {}"), message);
|
||||
}
|
||||
*static_cast<bool*>(userdata) = true;
|
||||
}
|
||||
|
||||
static WGPUBackendType to_wgpu_backend(AuroraBackend backend) {
|
||||
switch (backend) {
|
||||
case BACKEND_WEBGPU:
|
||||
return WGPUBackendType_WebGPU;
|
||||
case BACKEND_D3D12:
|
||||
return WGPUBackendType_D3D12;
|
||||
case BACKEND_METAL:
|
||||
return WGPUBackendType_Metal;
|
||||
case BACKEND_VULKAN:
|
||||
return WGPUBackendType_Vulkan;
|
||||
case BACKEND_OPENGL:
|
||||
return WGPUBackendType_OpenGL;
|
||||
case BACKEND_OPENGLES:
|
||||
return WGPUBackendType_OpenGLES;
|
||||
default:
|
||||
return WGPUBackendType_Null;
|
||||
}
|
||||
}
|
||||
|
||||
bool initialize(AuroraBackend auroraBackend) {
|
||||
if (!g_Instance) {
|
||||
Log.report(LOG_INFO, FMT_STRING("Creating Dawn instance"));
|
||||
g_Instance = std::make_unique<dawn::native::Instance>();
|
||||
}
|
||||
WGPUBackendType backend = to_wgpu_backend(auroraBackend);
|
||||
Log.report(LOG_INFO, FMT_STRING("Attempting to initialize {}"), magic_enum::enum_name(backend));
|
||||
#if 0
|
||||
// D3D12's debug layer is very slow
|
||||
g_Instance->EnableBackendValidation(backend != WGPUBackendType::D3D12);
|
||||
#endif
|
||||
SDL_Window* window = window::get_sdl_window();
|
||||
if (!utils::DiscoverAdapter(g_Instance.get(), window, backend)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
{
|
||||
std::vector<dawn::native::Adapter> adapters = g_Instance->GetAdapters();
|
||||
std::sort(adapters.begin(), adapters.end(), [&](const auto& a, const auto& b) {
|
||||
WGPUAdapterProperties propertiesA;
|
||||
WGPUAdapterProperties propertiesB;
|
||||
a.GetProperties(&propertiesA);
|
||||
b.GetProperties(&propertiesB);
|
||||
constexpr std::array PreferredTypeOrder{
|
||||
WGPUAdapterType_DiscreteGPU,
|
||||
WGPUAdapterType_IntegratedGPU,
|
||||
WGPUAdapterType_CPU,
|
||||
};
|
||||
const auto typeItA = std::find(PreferredTypeOrder.begin(), PreferredTypeOrder.end(), propertiesA.adapterType);
|
||||
const auto typeItB = std::find(PreferredTypeOrder.begin(), PreferredTypeOrder.end(), propertiesB.adapterType);
|
||||
return typeItA < typeItB;
|
||||
});
|
||||
const auto adapterIt = std::find_if(adapters.begin(), adapters.end(), [=](const auto& adapter) -> bool {
|
||||
WGPUAdapterProperties properties;
|
||||
adapter.GetProperties(&properties);
|
||||
return properties.backendType == backend;
|
||||
});
|
||||
if (adapterIt == adapters.end()) {
|
||||
return false;
|
||||
}
|
||||
g_Adapter = *adapterIt;
|
||||
}
|
||||
g_Adapter.GetProperties(&g_AdapterProperties);
|
||||
g_backendType = g_AdapterProperties.backendType;
|
||||
const auto backendName = magic_enum::enum_name(g_backendType);
|
||||
Log.report(LOG_INFO, FMT_STRING("Graphics adapter information\n API: {}\n Device: {} ({})\n Driver: {}"),
|
||||
backendName, g_AdapterProperties.name, magic_enum::enum_name(g_AdapterProperties.adapterType),
|
||||
g_AdapterProperties.driverDescription);
|
||||
|
||||
{
|
||||
WGPUSupportedLimits supportedLimits{};
|
||||
g_Adapter.GetLimits(&supportedLimits);
|
||||
const WGPURequiredLimits requiredLimits{
|
||||
.limits =
|
||||
{
|
||||
// Use "best" supported alignments
|
||||
.minUniformBufferOffsetAlignment = supportedLimits.limits.minUniformBufferOffsetAlignment == 0
|
||||
? static_cast<uint32_t>(WGPU_LIMIT_U32_UNDEFINED)
|
||||
: supportedLimits.limits.minUniformBufferOffsetAlignment,
|
||||
.minStorageBufferOffsetAlignment = supportedLimits.limits.minStorageBufferOffsetAlignment == 0
|
||||
? static_cast<uint32_t>(WGPU_LIMIT_U32_UNDEFINED)
|
||||
: supportedLimits.limits.minStorageBufferOffsetAlignment,
|
||||
},
|
||||
};
|
||||
std::vector<WGPUFeatureName> features;
|
||||
const auto supportedFeatures = g_Adapter.GetSupportedFeatures();
|
||||
for (const auto* const feature : supportedFeatures) {
|
||||
if (strcmp(feature, "texture-compression-bc") == 0) {
|
||||
features.push_back(WGPUFeatureName_TextureCompressionBC);
|
||||
}
|
||||
}
|
||||
const std::array enableToggles {
|
||||
/* clang-format off */
|
||||
#if _WIN32
|
||||
"use_dxc",
|
||||
#endif
|
||||
#ifdef NDEBUG
|
||||
"skip_validation",
|
||||
"disable_robustness",
|
||||
#endif
|
||||
"use_user_defined_labels_in_backend",
|
||||
"disable_symbol_renaming",
|
||||
/* clang-format on */
|
||||
};
|
||||
const WGPUDawnTogglesDeviceDescriptor togglesDescriptor{
|
||||
.chain = {.sType = WGPUSType_DawnTogglesDeviceDescriptor},
|
||||
.forceEnabledTogglesCount = enableToggles.size(),
|
||||
.forceEnabledToggles = enableToggles.data(),
|
||||
};
|
||||
const WGPUDeviceDescriptor deviceDescriptor{
|
||||
.nextInChain = &togglesDescriptor.chain,
|
||||
.requiredFeaturesCount = static_cast<uint32_t>(features.size()),
|
||||
.requiredFeatures = features.data(),
|
||||
.requiredLimits = &requiredLimits,
|
||||
};
|
||||
bool deviceCallbackReceived = false;
|
||||
g_Adapter.RequestDevice(&deviceDescriptor, &device_callback, &deviceCallbackReceived);
|
||||
// while (!deviceCallbackReceived) {
|
||||
// TODO wgpuInstanceProcessEvents
|
||||
// }
|
||||
if (!g_device) {
|
||||
return false;
|
||||
}
|
||||
wgpuDeviceSetUncapturedErrorCallback(g_device, &error_callback, nullptr);
|
||||
}
|
||||
wgpuDeviceSetDeviceLostCallback(g_device, nullptr, nullptr);
|
||||
g_queue = wgpuDeviceGetQueue(g_device);
|
||||
|
||||
g_BackendBinding = std::unique_ptr<utils::BackendBinding>(utils::CreateBinding(g_backendType, window, g_device));
|
||||
if (!g_BackendBinding) {
|
||||
return false;
|
||||
}
|
||||
|
||||
auto swapChainFormat = static_cast<WGPUTextureFormat>(g_BackendBinding->GetPreferredSwapChainTextureFormat());
|
||||
if (swapChainFormat == WGPUTextureFormat_RGBA8UnormSrgb) {
|
||||
swapChainFormat = WGPUTextureFormat_RGBA8Unorm;
|
||||
} else if (swapChainFormat == WGPUTextureFormat_BGRA8UnormSrgb) {
|
||||
swapChainFormat = WGPUTextureFormat_BGRA8Unorm;
|
||||
}
|
||||
Log.report(LOG_INFO, FMT_STRING("Using swapchain format {}"), magic_enum::enum_name(swapChainFormat));
|
||||
{
|
||||
const WGPUSwapChainDescriptor descriptor{
|
||||
.format = swapChainFormat,
|
||||
.implementation = g_BackendBinding->GetSwapChainImplementation(),
|
||||
};
|
||||
g_swapChain = wgpuDeviceCreateSwapChain(g_device, nullptr, &descriptor);
|
||||
}
|
||||
{
|
||||
const auto size = window::get_window_size();
|
||||
g_graphicsConfig = GraphicsConfig{
|
||||
.width = size.fb_width,
|
||||
.height = size.fb_height,
|
||||
.colorFormat = swapChainFormat,
|
||||
.depthFormat = WGPUTextureFormat_Depth32Float,
|
||||
.msaaSamples = g_config.msaa,
|
||||
.textureAnisotropy = g_config.maxTextureAnisotropy,
|
||||
};
|
||||
create_copy_pipeline();
|
||||
resize_swapchain(size.fb_width, size.fb_height, true);
|
||||
// g_windowSize = size;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void shutdown() {
|
||||
wgpuBindGroupLayoutRelease(g_CopyBindGroupLayout);
|
||||
wgpuRenderPipelineRelease(g_CopyPipeline);
|
||||
wgpuBindGroupRelease(g_CopyBindGroup);
|
||||
g_frameBuffer = {};
|
||||
g_frameBufferResolved = {};
|
||||
g_depthBuffer = {};
|
||||
wgpuSwapChainRelease(g_swapChain);
|
||||
wgpuQueueRelease(g_queue);
|
||||
g_BackendBinding.reset();
|
||||
wgpuDeviceDestroy(g_device);
|
||||
g_Instance.reset();
|
||||
}
|
||||
|
||||
void resize_swapchain(uint32_t width, uint32_t height, bool force) {
|
||||
if (!force && g_graphicsConfig.width == width && g_graphicsConfig.height == height) {
|
||||
return;
|
||||
}
|
||||
g_graphicsConfig.width = width;
|
||||
g_graphicsConfig.height = height;
|
||||
wgpuSwapChainConfigure(g_swapChain, g_graphicsConfig.colorFormat, WGPUTextureUsage_RenderAttachment, width, height);
|
||||
g_frameBuffer = create_render_texture(true);
|
||||
g_frameBufferResolved = create_render_texture(false);
|
||||
g_depthBuffer = create_depth_texture();
|
||||
create_copy_bind_group();
|
||||
}
|
||||
} // namespace aurora::webgpu
|
||||
88
lib/webgpu/gpu.hpp
Normal file
88
lib/webgpu/gpu.hpp
Normal file
@@ -0,0 +1,88 @@
|
||||
#pragma once
|
||||
|
||||
#include <aurora/aurora.h>
|
||||
|
||||
#include "wgpu.hpp"
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
|
||||
struct SDL_Window;
|
||||
|
||||
namespace aurora::webgpu {
|
||||
struct GraphicsConfig {
|
||||
uint32_t width;
|
||||
uint32_t height;
|
||||
WGPUTextureFormat colorFormat;
|
||||
WGPUTextureFormat depthFormat;
|
||||
uint32_t msaaSamples;
|
||||
uint16_t textureAnisotropy;
|
||||
};
|
||||
struct TextureWithSampler {
|
||||
wgpu::Texture texture;
|
||||
wgpu::TextureView view;
|
||||
WGPUExtent3D size;
|
||||
WGPUTextureFormat format;
|
||||
wgpu::Sampler sampler;
|
||||
|
||||
// TextureWithSampler() = default;
|
||||
// TextureWithSampler(WGPUTexture texture, WGPUTextureView view, WGPUExtent3D size, WGPUTextureFormat format,
|
||||
// WGPUSampler sampler) noexcept
|
||||
// : texture(texture), view(view), size(size), format(format), sampler(sampler) {}
|
||||
// TextureWithSampler(const TextureWithSampler& rhs) noexcept
|
||||
// : texture(rhs.texture), view(rhs.view), size(rhs.size), format(rhs.format), sampler(rhs.sampler) {
|
||||
// wgpuTextureReference(texture);
|
||||
// wgpuTextureViewReference(view);
|
||||
// wgpuSamplerReference(sampler);
|
||||
// }
|
||||
// TextureWithSampler(TextureWithSampler&& rhs) noexcept
|
||||
// : texture(rhs.texture), view(rhs.view), size(rhs.size), format(rhs.format), sampler(rhs.sampler) {
|
||||
// rhs.texture = nullptr;
|
||||
// rhs.view = nullptr;
|
||||
// rhs.sampler = nullptr;
|
||||
// }
|
||||
// ~TextureWithSampler() { reset(); }
|
||||
// TextureWithSampler& operator=(const TextureWithSampler& rhs) noexcept {
|
||||
// reset();
|
||||
// texture = rhs.texture;
|
||||
// view = rhs.view;
|
||||
// size = rhs.size;
|
||||
// format = rhs.format;
|
||||
// sampler = rhs.sampler;
|
||||
// wgpuTextureReference(texture);
|
||||
// wgpuTextureViewReference(view);
|
||||
// wgpuSamplerReference(sampler);
|
||||
// return *this;
|
||||
// }
|
||||
// void reset() {
|
||||
// if (texture != nullptr) {
|
||||
// wgpuTextureRelease(texture);
|
||||
// texture = nullptr;
|
||||
// }
|
||||
// if (view != nullptr) {
|
||||
// wgpuTextureViewRelease(view);
|
||||
// view = nullptr;
|
||||
// }
|
||||
// if (sampler != nullptr) {
|
||||
// wgpuSamplerRelease(sampler);
|
||||
// sampler = nullptr;
|
||||
// }
|
||||
// }
|
||||
};
|
||||
|
||||
extern WGPUDevice g_device;
|
||||
extern WGPUQueue g_queue;
|
||||
extern WGPUSwapChain g_swapChain;
|
||||
extern WGPUBackendType g_backendType;
|
||||
extern GraphicsConfig g_graphicsConfig;
|
||||
extern TextureWithSampler g_frameBuffer;
|
||||
extern TextureWithSampler g_frameBufferResolved;
|
||||
extern TextureWithSampler g_depthBuffer;
|
||||
extern WGPURenderPipeline g_CopyPipeline;
|
||||
extern WGPUBindGroup g_CopyBindGroup;
|
||||
|
||||
bool initialize(AuroraBackend backend);
|
||||
void shutdown();
|
||||
void resize_swapchain(uint32_t width, uint32_t height, bool force = false);
|
||||
TextureWithSampler create_render_texture(bool multisampled);
|
||||
} // namespace aurora::webgpu
|
||||
102
lib/webgpu/wgpu.hpp
Normal file
102
lib/webgpu/wgpu.hpp
Normal file
@@ -0,0 +1,102 @@
|
||||
#include <webgpu/webgpu.h>
|
||||
|
||||
namespace wgpu {
|
||||
template <typename Derived, typename CType>
|
||||
struct ObjectBase {
|
||||
ObjectBase() = default;
|
||||
ObjectBase(CType handle) : mHandle(handle) {}
|
||||
~ObjectBase() { Reset(); }
|
||||
|
||||
ObjectBase(ObjectBase const& other) : ObjectBase(other.Get()) {}
|
||||
Derived& operator=(ObjectBase const& other) {
|
||||
if (&other != this) {
|
||||
if (mHandle) {
|
||||
Derived::WGPURelease(mHandle);
|
||||
}
|
||||
mHandle = other.mHandle;
|
||||
if (mHandle) {
|
||||
Derived::WGPUReference(mHandle);
|
||||
}
|
||||
}
|
||||
return static_cast<Derived&>(*this);
|
||||
}
|
||||
|
||||
ObjectBase(ObjectBase&& other) noexcept {
|
||||
mHandle = other.mHandle;
|
||||
other.mHandle = 0;
|
||||
}
|
||||
Derived& operator=(ObjectBase&& other) noexcept {
|
||||
if (&other != this) {
|
||||
if (mHandle) {
|
||||
Derived::WGPURelease(mHandle);
|
||||
}
|
||||
mHandle = other.mHandle;
|
||||
other.mHandle = nullptr;
|
||||
}
|
||||
return static_cast<Derived&>(*this);
|
||||
}
|
||||
|
||||
ObjectBase(std::nullptr_t) {}
|
||||
Derived& operator=(std::nullptr_t) {
|
||||
if (mHandle != nullptr) {
|
||||
Derived::WGPURelease(mHandle);
|
||||
mHandle = nullptr;
|
||||
}
|
||||
return static_cast<Derived&>(*this);
|
||||
}
|
||||
|
||||
bool operator==(std::nullptr_t) const { return mHandle == nullptr; }
|
||||
bool operator!=(std::nullptr_t) const { return mHandle != nullptr; }
|
||||
|
||||
explicit operator bool() const { return mHandle != nullptr; }
|
||||
operator CType() { return mHandle; }
|
||||
[[nodiscard]] CType Get() const { return mHandle; }
|
||||
CType Release() {
|
||||
CType result = mHandle;
|
||||
mHandle = 0;
|
||||
return result;
|
||||
}
|
||||
void Reset() {
|
||||
if (mHandle) {
|
||||
Derived::WGPURelease(mHandle);
|
||||
mHandle = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
protected:
|
||||
CType mHandle = nullptr;
|
||||
};
|
||||
|
||||
class Texture : public ObjectBase<Texture, WGPUTexture> {
|
||||
public:
|
||||
using ObjectBase::ObjectBase;
|
||||
using ObjectBase::operator=;
|
||||
|
||||
private:
|
||||
friend ObjectBase<Texture, WGPUTexture>;
|
||||
static void WGPUReference(WGPUTexture handle) { wgpuTextureReference(handle); }
|
||||
static void WGPURelease(WGPUTexture handle) { wgpuTextureRelease(handle); }
|
||||
};
|
||||
|
||||
class TextureView : public ObjectBase<TextureView, WGPUTextureView> {
|
||||
public:
|
||||
using ObjectBase::ObjectBase;
|
||||
using ObjectBase::operator=;
|
||||
|
||||
private:
|
||||
friend ObjectBase<TextureView, WGPUTextureView>;
|
||||
static void WGPUReference(WGPUTextureView handle) { wgpuTextureViewReference(handle); }
|
||||
static void WGPURelease(WGPUTextureView handle) { wgpuTextureViewRelease(handle); }
|
||||
};
|
||||
|
||||
class Sampler : public ObjectBase<Sampler, WGPUSampler> {
|
||||
public:
|
||||
using ObjectBase::ObjectBase;
|
||||
using ObjectBase::operator=;
|
||||
|
||||
private:
|
||||
friend ObjectBase<Sampler, WGPUSampler>;
|
||||
static void WGPUReference(WGPUSampler handle) { wgpuSamplerReference(handle); }
|
||||
static void WGPURelease(WGPUSampler handle) { wgpuSamplerRelease(handle); }
|
||||
};
|
||||
} // namespace wgpu
|
||||
Reference in New Issue
Block a user