aboutsummaryrefslogtreecommitdiffstats
path: root/api-test
diff options
context:
space:
mode:
authorladevieq <ladevie.quentin@gmail.com>2026-05-05 00:43:54 +0200
committerladevieq <ladevie.quentin@gmail.com>2026-05-05 00:49:12 +0200
commitc3aac9026951e2a6e35e76b9c7d36e114a281453 (patch)
treebdfc2ab5d5f1d196ba8c7a76371a29911f75913e /api-test
parent754249d9c652ef941e6b082d2e86538d15ba9434 (diff)
Remove old api and move api-test content to src and include dirs
Diffstat (limited to 'api-test')
-rw-r--r--api-test/dx12-command-buffer.cpp47
-rw-r--r--api-test/dx12-device.cpp239
-rw-r--r--api-test/main.cpp653
-rw-r--r--api-test/vk-bindless.cpp431
-rw-r--r--api-test/vk-command-buffer.cpp233
-rw-r--r--api-test/vk-device.cpp1302
-rw-r--r--api-test/vk-utils.cpp44
7 files changed, 0 insertions, 2949 deletions
diff --git a/api-test/dx12-command-buffer.cpp b/api-test/dx12-command-buffer.cpp
deleted file mode 100644
index 0310dfd..0000000
--- a/api-test/dx12-command-buffer.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "dx12-command-buffer.hpp"
-
-#include "dx12-device.hpp"
-
-namespace dx12 {
- void command_buffer::start() const {
- HRESULT hr = command_allocator->Reset();
- assert(hr == S_OK);
-
- hr = dx12_command_buffer->Reset(command_allocator, nullptr);
- assert(hr == S_OK);
-
- auto& device = dx12::device::get_render_device();
- dx12_command_buffer->SetDescriptorHeaps(2U, dx12::device::get_bindless_model().get_heaps());
- }
-
- void command_buffer::stop() const {
- HRESULT hr = dx12_command_buffer->Close();
- assert(hr == S_OK);
- }
-
- void command_buffer::copy(handle<device_buffer> src_buffer, handle<device_texture> dst_texture, uint64_t offset) const {
- auto& dst = device::get_render_device().get_texture(dst_texture);
- D3D12_TEXTURE_COPY_LOCATION dst_copy_location {
- .pResource = dst.resource,
- .Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX,
- .SubresourceIndex = 0U,
- };
-
- auto& src = device::get_render_device().get_buffer(src_buffer);
- D3D12_TEXTURE_COPY_LOCATION src_copy_location {
- .pResource = src.resource,
- .Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT,
- .PlacedFootprint = {
- .Offset = offset,
- .Footprint = {
- .Format = dst.format,
- .Width = dst.width,
- .Height = dst.height,
- .Depth = dst.depth,
- .RowPitch = static_cast<UINT>(dst.row_pitch),
- },
- },
- };
- dx12_command_buffer->CopyTextureRegion(&dst_copy_location, 0U, 0U, 0U, &src_copy_location, nullptr);
- }
-}
diff --git a/api-test/dx12-device.cpp b/api-test/dx12-device.cpp
deleted file mode 100644
index ac328ed..0000000
--- a/api-test/dx12-device.cpp
+++ /dev/null
@@ -1,239 +0,0 @@
-#include "dx12-device.hpp"
-
-#include <cstdint>
-#include <cstdio>
-
-#include "dx12-command-buffer.hpp"
-
-namespace dx12 {
- device device::render_device = dx12::device();
-
- void device::init() {
- HRESULT hr = S_OK;
- hr = CreateDXGIFactory2(DXGI_CREATE_FACTORY_DEBUG, IID_PPV_ARGS(&factory));
- assert(hr == S_OK);
-
- uint32_t index = 0U;
- while (factory->EnumAdapters(index, &adapter) != DXGI_ERROR_NOT_FOUND) {
- DXGI_ADAPTER_DESC desc;
- SUCCEEDED(adapter->GetDesc(&desc));
- printf("%S\n", desc.Description);
- index++;
- }
-
- SUCCEEDED(factory->EnumAdapters(0U, &adapter));
-
- if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&debug_interface)))) {
- debug_interface->EnableDebugLayer();
- }
-
- hr = D3D12CreateDevice(adapter, D3D_FEATURE_LEVEL_12_0, IID_PPV_ARGS(&device));
- assert(hr == S_OK);
-
- queues[static_cast<uint32_t>(QueueType::GRAPHICS)].type = D3D12_COMMAND_LIST_TYPE_DIRECT;
- D3D12_COMMAND_QUEUE_DESC queue_desc{
- .Type = queues[static_cast<uint32_t>(QueueType::GRAPHICS)].type,
- .Priority = D3D12_COMMAND_QUEUE_PRIORITY::D3D12_COMMAND_QUEUE_PRIORITY_HIGH,
- .Flags = D3D12_COMMAND_QUEUE_FLAGS::D3D12_COMMAND_QUEUE_FLAG_NONE,
- .NodeMask = 0U,
- };
- device->CreateCommandQueue(&queue_desc, IID_PPV_ARGS(&queues[static_cast<uint32_t>(QueueType::GRAPHICS)].dx_queue));
- assert(hr == S_OK);
-
- queue_desc.Type = queues[static_cast<uint32_t>(QueueType::ASYNC_COMPUTE)].type = D3D12_COMMAND_LIST_TYPE_COMPUTE;
- queue_desc.Priority = D3D12_COMMAND_QUEUE_PRIORITY::D3D12_COMMAND_QUEUE_PRIORITY_HIGH,
- device->CreateCommandQueue(&queue_desc, IID_PPV_ARGS(&queues[static_cast<uint32_t>(QueueType::ASYNC_COMPUTE)].dx_queue));
- assert(hr == S_OK);
-
- queue_desc.Type = queues[static_cast<uint32_t>(QueueType::TRANSFER)].type = D3D12_COMMAND_LIST_TYPE_COPY;
- queue_desc.Priority = D3D12_COMMAND_QUEUE_PRIORITY::D3D12_COMMAND_QUEUE_PRIORITY_HIGH,
- device->CreateCommandQueue(&queue_desc, IID_PPV_ARGS(&queues[static_cast<uint32_t>(QueueType::TRANSFER)].dx_queue));
- assert(hr == S_OK);
-
- hr = device->CreateFence(0U, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&fence));
- assert(hr == S_OK);
-
- D3D12MA::ALLOCATOR_DESC allocator_desc {
- .pDevice = device,
- .pAdapter = adapter,
- };
-
- hr = D3D12MA::CreateAllocator(&allocator_desc, &allocator);
- assert(hr == S_OK);
-
- model.init();
- }
-
- handle<device_surface> device::create_surface(const surface_desc& desc) {
- device_surface surface {
- };
- DXGI_SAMPLE_DESC sample_desc{
- .Count = 1U,
- .Quality = 0U,
- };
- DXGI_SWAP_CHAIN_DESC1 swapchain_desc1{
- .Width = 0U,
- .Height = 0U,
- .Format = desc.surface_format,
- .Stereo = FALSE,
- .SampleDesc = sample_desc,
- .BufferUsage = desc.usages,
- .BufferCount = desc.image_count,
- .Scaling = DXGI_SCALING_NONE,
- .SwapEffect = desc.present_mode,
- .AlphaMode = DXGI_ALPHA_MODE_IGNORE,
- .Flags = 0U,
- };
- HRESULT hr = factory->CreateSwapChainForHwnd(queues[static_cast<uint32_t>(QueueType::GRAPHICS)].dx_queue, desc.window_handle, &swapchain_desc1, nullptr, nullptr, &surface.swapchain);
- assert(hr == S_OK);
-
- return surfaces.add(surface);
- }
-
- handle<device_buffer> device::create_buffer(const buffer_desc& desc) {
- device_buffer buffer {
- .size = desc.size,
- };
-
- DXGI_SAMPLE_DESC sample_desc {
- .Count = 1U,
- .Quality = 0U,
- };
- D3D12_RESOURCE_DESC resource_desc {
- .Dimension = D3D12_RESOURCE_DIMENSION_BUFFER,
- .Alignment = 0U,
- .Width = buffer.size,
- .Height = 1U,
- .DepthOrArraySize = 1U,
- .MipLevels = 1U,
- .Format = DXGI_FORMAT_UNKNOWN,
- .SampleDesc = sample_desc,
- .Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
- .Flags = desc.usages,
- };
- D3D12MA::ALLOCATION_DESC allocation_desc {
- .HeapType = desc.heap_type,
- };
- HRESULT hr = allocator->CreateResource(&allocation_desc, &resource_desc, desc.states, nullptr, &buffer.alloc, IID_PPV_ARGS(&buffer.resource));
- assert(hr == S_OK);
-
- if (desc.map) {
- hr = buffer.resource->Map(0U, nullptr, &buffer.mapped_ptr);
- assert(hr == S_OK);
- }
-
- return buffers.add(buffer);
- }
-
- handle<device_texture> device::create_texture(const texture_desc& desc) {
- device_texture texture {
- .width = desc.width,
- .height = desc.height,
- .depth = desc.depth,
- .mips = desc.mips,
- .format = desc.format,
- };
-
- DXGI_SAMPLE_DESC sample_desc {
- .Count = 1U,
- .Quality = 0U,
- };
- D3D12_RESOURCE_DESC resource_desc {
- .Dimension = desc.type,
- .Alignment = 0U,
- .Width = texture.width,
- .Height = texture.height,
- .DepthOrArraySize = static_cast<uint16_t>(texture.depth),
- .MipLevels = static_cast<uint16_t>(texture.mips),
- .Format = desc.format,
- .SampleDesc = sample_desc,
- .Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
- .Flags = desc.usages,
- };
- D3D12MA::ALLOCATION_DESC allocation_desc {
- .HeapType = D3D12_HEAP_TYPE_DEFAULT,
- };
-
- HRESULT hr = allocator->CreateResource(&allocation_desc, &resource_desc, desc.states, nullptr, &texture.alloc, IID_PPV_ARGS(&texture.resource));
- assert(hr == S_OK);
-
- D3D12_PLACED_SUBRESOURCE_FOOTPRINT place_footprint;
- UINT num_rows = 0U;
- UINT64 total_bytes = 0U;
- device->GetCopyableFootprints(&resource_desc, 0U, 1U, 0U, &place_footprint, &num_rows, &texture.row_pitch, &total_bytes);
-
- return textures.add(texture);
- }
-
- void device::allocate_command_buffers(command_buffer* buffers, size_t count, QueueType type) {
- HRESULT hr = S_OK;
- for (uint32_t index = 0U; index < count; index++) {
- buffers[index].queue_type = type;
-
- auto list_type = queues[static_cast<uint32_t>(type)].type;
- hr = device->CreateCommandAllocator(list_type, IID_PPV_ARGS(&buffers[index].command_allocator));
- assert(hr == S_OK);
-
- hr = device->CreateCommandList(0U, list_type, buffers[index].command_allocator, nullptr, IID_PPV_ARGS(&buffers[index].dx12_command_buffer));
- assert(hr == S_OK);
-
- hr = buffers[index].dx12_command_buffer->Close();
- assert(hr == S_OK);
- }
- }
-
- uint32_t device::submit(command_buffer* buffers, uint32_t count) {
- assert((max_submitable_command_buffers - count) >= 0);
- const auto queue_type = buffers[0].queue_type;
- auto& queue = queues[static_cast<uint32_t>(buffers[0].queue_type)];
- ID3D12CommandList* lists[max_submitable_command_buffers] = { nullptr };
-
- for (auto index{ 0U }; index < count; index++) {
- assert(queue_type == buffers[index].queue_type);
-
- lists[index] = buffers[index].dx12_command_buffer;
- }
-
- queue.dx_queue->ExecuteCommandLists(count, lists);
- HRESULT hr = queue.dx_queue->Signal(fence, ++fence_value);
- assert(hr == S_OK);
-
- for (uint32_t index = 0U; index < count; index++) {
- auto& buffer = buffers[index];
-
- hr = buffer.dx12_command_buffer->Reset(buffer.command_allocator, nullptr);
- assert(hr == S_OK);
- }
-
- return fence_value;
- }
-
- void device::wait() {
- for (auto& queue : queues) {
- queue.dx_queue->Wait(fence, fence_value);
- }
- }
-
- void device::bindless_model::init() {
- ID3D12Device* device = device::get_render_device().get_device();
-
- D3D12_DESCRIPTOR_HEAP_DESC resources_descriptor_heap_desc {
- .Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV,
- .NumDescriptors = D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_2,
- .Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE,
- .NodeMask = 0U,
- };
-
- HRESULT hr = device->CreateDescriptorHeap(&resources_descriptor_heap_desc, IID_PPV_ARGS(&resources_heap));
- assert(hr == S_OK);
-
- D3D12_DESCRIPTOR_HEAP_DESC samplers_descriptor_heap_desc {
- .Type = D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER,
- .NumDescriptors = D3D12_MAX_SHADER_VISIBLE_SAMPLER_HEAP_SIZE,
- .Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE,
- .NodeMask = 0U,
- };
- hr = device->CreateDescriptorHeap(&samplers_descriptor_heap_desc, IID_PPV_ARGS(&samplers_heap));
- assert(hr == S_OK);
- }
-}
diff --git a/api-test/main.cpp b/api-test/main.cpp
deleted file mode 100644
index f4a825d..0000000
--- a/api-test/main.cpp
+++ /dev/null
@@ -1,653 +0,0 @@
-// #include <cassert>
-// #include <cstdio>
-// #include <array>
-
-#define STB_IMAGE_IMPLEMENTATION
-// #include <stb_image.h>
-
-#include "imgui.cpp"
-#include "imgui_draw.cpp"
-#include "imgui_tables.cpp"
-#include "imgui_widgets.cpp"
-#include "imgui_demo.cpp"
-
-#define API_TEST
-
-#include "../src/vulkan-loader.cpp"
-#include "../src/window.cpp"
-#include "../src/vec3.cpp"
-#include "../src/camera.cpp"
-#include "../src/scene.cpp"
-#include "../src/utils.cpp"
-#include "../src/bvh.cpp"
-#include "../src/gltf.cpp"
-#include "../src/mesh.cpp"
-
-#include "vk-utils.cpp"
-#include "vk-device.cpp"
-#include "vk-bindless.cpp"
-#include "vk-command-buffer.cpp"
-
-// #include "handle.hpp"
-// #include "window.hpp"
-// #include "utils.hpp"
-
-#ifdef VK
-#include <vk_mem_alloc.h>
-#include "vk-device.hpp"
-#include "vk-command-buffer.hpp"
-#else
-#include "dx12-device.hpp"
-#include "dx12-command-buffer.hpp"
-#endif
-
-struct device_texture;
-
-#define VK
-// #define DX12
-
-#ifdef DEBUG
-#define ENABLE_RENDERDOC
-#endif // _DEBUG
-
-#include "camera.hpp"
-#include "scene.hpp"
-
-#ifdef ENABLE_RENDERDOC
-#include <renderdoc_app.h>
-
-#define RD_START_CAPTURE if(rdoc_api != nullptr) rdoc_api->StartFrameCapture(nullptr, nullptr)
-#define RD_END_CAPTURE if(rdoc_api != nullptr) rdoc_api->EndFrameCapture(nullptr, nullptr)
-
-RENDERDOC_API_1_6_0 *rdoc_api = nullptr;
-#else
-#define RD_START_CAPTURE (0)
-#define RD_END_CAPTURE (0)
-#endif // ENABLE_RENDERDOC
-
-static constexpr size_t Kb = 1024U;
-static constexpr size_t Mb = 1024U * Kb;
-
-static uintptr_t transmittance_LUT_tex_id = 0U;
-
-void ui(uint64_t frame_time) {
- static float max_fps = 0.f;
- static uint64_t max_frame_time = 1000U;
- float fps = static_cast<float>(1000000U / frame_time);
- if (fps > max_fps) {
- max_fps = fps;
- }
- if (frame_time > max_frame_time) {
- max_frame_time = frame_time;
- }
- ImGui::NewFrame();
- ImGui::Text("FPS : %f\n", fps);
- ImGui::Text("Max FPS : %f\n", max_fps);
- ImGui::Text("frame_time : %f ms\n", frame_time / 1000.f);
- ImGui::Text("max frame_time : %f ms\n", max_frame_time / 1000.f);
-
- ImGui::Text("LUT");
- ImGui::Image(transmittance_LUT_tex_id, ImVec2(128, 128));
- ImGui::EndFrame();
- ImGui::Render();
-}
-
-void update_buffers(ImDrawData* draw_data, const device_buffer& vertex_buffer, const device_buffer& index_buffer) {
- off_t vertex_offset = 0;
- off_t index_offset = 0;
- for (auto index {0} ; index < draw_data->CmdListsCount; index++) {
- auto* cmd_list = draw_data->CmdLists[index];
-
- size_t vertex_bytes_size = sizeof(ImDrawVert) * cmd_list->VtxBuffer.size();
- auto* vtx_ptr = static_cast<uint8_t*>(vertex_buffer.mapped_ptr) + vertex_offset;
- memcpy(vtx_ptr, cmd_list->VtxBuffer.Data, vertex_bytes_size);
- vertex_offset += static_cast<off_t>(vertex_bytes_size);
-
- size_t index_bytes_size = sizeof(ImDrawIdx) * cmd_list->IdxBuffer.size();
- memcpy(static_cast<uint8_t*>(index_buffer.mapped_ptr) + index_offset, cmd_list->IdxBuffer.Data, index_bytes_size);
- index_offset += static_cast<off_t>(index_bytes_size);
- }
-}
-
-int main() {
- LARGE_INTEGER freq;
- // From Microsoft doc
- // https://learn.microsoft.com/en-us/windows/win32/api/profileapi/nf-profileapi-queryperformancefrequency
- // The frequency of the performance counter is fixed at system boot and is
- // consistent across all processors so you only need to query the frequency
- // from QueryPerformanceFrequency as the application initializes,
- // and then cache the result.
- QueryPerformanceFrequency(&freq);
-
-#ifdef ENABLE_RENDERDOC
- {
- HMODULE mod = GetModuleHandleA("renderdoc.dll");
- // if (!mod) {
- // mod = LoadLibraryA("renderdoc.dll");
- // }
-
- if (mod) {
- auto RENDERDOC_GetAPI = (pRENDERDOC_GetAPI)GetProcAddress(mod, "RENDERDOC_GetAPI");
- assert(RENDERDOC_GetAPI(eRENDERDOC_API_Version_1_6_0, (void **)&rdoc_api) == 1);
- }
-
- // if (!rdoc_api->IsTargetControlConnected()) {
- // rdoc_api->LaunchReplayUI(true, nullptr);
- // }
- }
-#endif
-
- constexpr size_t window_width = 1280U;
- constexpr size_t window_height = 720U;
- window wnd { window_width, window_height };
-
- ImGui::CreateContext();
- ImGuiIO &io = ImGui::GetIO();
- io.DisplaySize.x = window_width;
- io.DisplaySize.y = window_height;
-
- const float aspect_ratio = 16.f / 9.f;
-
- point3 position { 13.f, 2.f, -3.f };
- point3 target {};
- const auto v_fov = 90.f;
- const auto aperture = 0.1f;
- const auto focus_distance = 10.f;
-
-#ifdef VK
- auto& device = vkdevice::get_render_device();
-#else
- auto& device = dx12::device::get_render_device();
-#endif
- device.init();
-
-#ifdef VK
- auto main_scene = scene(camera(position, target, v_fov, aspect_ratio, aperture, focus_distance), window_width, window_height);
-#endif
-
- auto surface_handle = device.create_surface({
- .window_handle = wnd.handle,
-#ifdef VK
- .surface_format = {
- .format = VK_FORMAT_B8G8R8A8_UNORM,
- .colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
- },
- .present_mode = VK_PRESENT_MODE_IMMEDIATE_KHR,
- .usages = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_STORAGE_BIT,
-#else
- .surface_format = DXGI_FORMAT_R16G16B16A16_FLOAT,
- .present_mode = DXGI_SWAP_EFFECT_FLIP_DISCARD,
- .usages = DXGI_USAGE_RENDER_TARGET_OUTPUT,
-#endif
- .image_count = 2U,
- });
- auto& surface = device.get_surface(surface_handle);
-
- constexpr size_t image_size = 1024U;
- constexpr size_t image_count = 4U;
- auto staging_buffer_handle = device.create_buffer({
- .size = image_size * image_size * sizeof(uint32_t) * image_count,
-#ifdef VK
- .usages = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
- .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
- .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
-#else
-
- .map = true,
- .states = D3D12_RESOURCE_STATE_COPY_SOURCE,
- .usages = D3D12_RESOURCE_FLAG_NONE,
- .heap_type = D3D12_HEAP_TYPE_UPLOAD,
-#endif
- });
- const auto& staging_buffer = device.get_buffer(staging_buffer_handle);
-
- // API test code
- int width;
- int height;
- int channels;
- uint8_t* data = stbi_load("../models/sponza/466164707995436622.jpg", &width, &height, &channels, 4);
- size_t size = static_cast<size_t>(width) * height * 4U;
- memcpy(staging_buffer.mapped_ptr, data, size);
-
- auto gpu_texture_handle = device.create_texture({
- .width = static_cast<uint32_t>(width),
- .height = static_cast<uint32_t>(height),
-#ifdef VK
- .usages = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
- .format = VK_FORMAT_R8G8B8A8_UNORM,
- .type = VK_IMAGE_TYPE_2D,
-#else
- .states = D3D12_RESOURCE_STATE_COPY_DEST,
- .usages = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS,
- .format = DXGI_FORMAT_R8G8B8A8_UNORM,
- .type = D3D12_RESOURCE_DIMENSION_TEXTURE2D,
-#endif
- });
-
- off_t buffer_offset = width * height * 4;
- data = stbi_load("../models/sponza/715093869573992647.jpg", &width, &height, &channels, 4);
- size = static_cast<size_t>(width) * height * 4U;
- auto* addr = static_cast<void*>(static_cast<uint8_t*>(staging_buffer.mapped_ptr) + buffer_offset);
- memcpy(addr, data, size);
-
- auto second_texture = device.create_texture({
- .width = static_cast<uint32_t>(width),
- .height = static_cast<uint32_t>(height),
-#ifdef VK
- .usages = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_STORAGE_BIT,
- .format = VK_FORMAT_R8G8B8A8_UNORM,
- .type = VK_IMAGE_TYPE_2D,
-#else
- .states = D3D12_RESOURCE_STATE_COPY_DEST,
- .usages = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS,
- .format = DXGI_FORMAT_R8G8B8A8_UNORM,
- .type = D3D12_RESOURCE_DIMENSION_TEXTURE2D,
-#endif
- });
-
- auto output_texture_handle = device.create_texture({
- .width = static_cast<uint32_t>(width),
- .height = static_cast<uint32_t>(height),
-#ifdef VK
- .usages = VK_IMAGE_USAGE_STORAGE_BIT,
- .format = VK_FORMAT_R8G8B8A8_UNORM,
- .type = VK_IMAGE_TYPE_2D,
-#else
- .usages = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS,
- .format = DXGI_FORMAT_R8G8B8A8_UNORM,
- .type = D3D12_RESOURCE_DIMENSION_TEXTURE2D,
-#endif
- });
-
- uint8_t *pixels = nullptr;
- int atlas_width;
- int atlas_height;
- io.Fonts->GetTexDataAsRGBA32(&pixels, &atlas_width, &atlas_height);
- const auto ui_texture_handle = device.create_texture({
- .width = static_cast<uint32_t>(atlas_width),
- .height = static_cast<uint32_t>(atlas_height),
-#ifdef VK
- .usages = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
- .format = VK_FORMAT_R8G8B8A8_UNORM,
- .type = VK_IMAGE_TYPE_2D,
-#else
- .states = D3D12_RESOURCE_STATE_COPY_DEST,
- .usages = D3D12_RESOURCE_FLAG_NONE,
- .format = DXGI_FORMAT_R8G8B8A8_UNORM,
- .type = D3D12_RESOURCE_DIMENSION_TEXTURE2D,
-#endif
- });
- const auto& ui_texture = device.get_texture(ui_texture_handle);
- // io.Fonts->SetTexID(*(void **)&ui_texture_handle.id);
- io.Fonts->SetTexID(reinterpret_cast<void*>(ui_texture.get_sampled_index()));
-
- off_t ui_offset = 2L * buffer_offset;
- size = static_cast<size_t>(atlas_width) * atlas_height * 4U;
- addr = static_cast<void*>(static_cast<uint8_t*>(staging_buffer.mapped_ptr) + ui_offset);
- memcpy(addr, pixels, size);
-
- auto vertex_buffer_handle = device.create_buffer({
- .size = Mb * sizeof(uint32_t),
-#ifdef VK
- .usages = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
- .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
- .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
-#else
- #endif
- });
- auto vertex_buffer = device.get_buffer(vertex_buffer_handle);
-
- auto index_buffer_handle = device.create_buffer({
- .size = Mb * sizeof(uint32_t),
-#ifdef VK
- .usages = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
- .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
- .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
-#else
-#endif
- });
- auto index_buffer = device.get_buffer(index_buffer_handle);
-
-#ifdef VK
- auto code = read_file("shaders/test.comp.spv");
- auto compute = device.create_compute_pipeline({
- .cs_code = code,
- });
-
- auto rt_code = read_file("shaders/compute.comp.spv");
- auto raytracing = device.create_compute_pipeline({
- .cs_code = rt_code,
- });
- auto tonemapping_code = read_file("shaders/tonemapping.comp.spv");
- auto tonemapping = device.create_compute_pipeline({
- .cs_code = tonemapping_code,
- });
-#endif
- const auto acc_handle = device.create_texture({
- .width = static_cast<uint32_t>(window_width),
- .height = static_cast<uint32_t>(window_height),
-#ifdef VK
- .usages = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT,
- .format = VK_FORMAT_R32G32B32A32_SFLOAT,
- .type = VK_IMAGE_TYPE_2D,
-#else
- .states = D3D12_RESOURCE_STATE_UNORDERED_ACCESS,
- .usages = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS,
- .format = DXGI_FORMAT_R32G32B32A32_FLOAT,
- .type = D3D12_RESOURCE_DIMENSION_TEXTURE2D,
-#endif
- });
-
-#ifdef VK
- auto acc_storage_index = device.get_texture(acc_handle).get_storage_index();
-#endif
-
- const auto result_handle = device.create_texture({
- .width = static_cast<uint32_t>(window_width),
- .height = static_cast<uint32_t>(window_height),
-#ifdef VK
- .usages = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT,
- .format = VK_FORMAT_R32G32B32A32_SFLOAT,
- .type = VK_IMAGE_TYPE_2D,
-#else
- .states = D3D12_RESOURCE_STATE_UNORDERED_ACCESS,
- .usages = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS,
- .format = DXGI_FORMAT_R32G32B32A32_FLOAT,
- .type = D3D12_RESOURCE_DIMENSION_TEXTURE2D,
-#endif
- });
-#ifdef VK
- auto result_storage_index = device.get_texture(result_handle).get_storage_index();
-#endif
-
-#ifdef VK
- std::array<VkFormat, 1U> formats { surface.surface_format.format };
- auto vertex_code = read_file("shaders/api-test-ui.vert.spv");
- auto fragment_code = read_file("shaders/api-test-ui.frag.spv");
- auto graphics = device.create_graphics_pipeline({
- .vs_code = vertex_code,
- .fs_code = fragment_code,
- .color_attachments_format = formats
- });
-#endif
-
-#ifdef VK
- std::array<graphics_command_buffer, 4U> graphics_command_buffers;
- device.allocate_command_buffers(graphics_command_buffers.data(), graphics_command_buffers.size(), QueueType::GRAPHICS, "graphics_cmd_buf");
-#else
- std::array<dx12::graphics_command_buffer, 4U> graphics_command_buffers;
- device.allocate_command_buffers(graphics_command_buffers.data(), graphics_command_buffers.size(), dx12::QueueType::GRAPHICS);
-#endif
-
-
- handle<device_texture> transmittance_lut_handle = device.create_texture({
- .width = static_cast<uint32_t>(1024),
- .height = static_cast<uint32_t>(1024),
-#ifdef VK
- .usages = VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
- .format = VK_FORMAT_R16G16B16A16_SFLOAT,
- .type = VK_IMAGE_TYPE_2D,
-#else
- .usages = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS,
- .format = DXGI_FORMAT_R8G8B8A8_UNORM,
- .type = D3D12_RESOURCE_DIMENSION_TEXTURE2D,
-#endif
- .name = "transmittance_lut",
- });
- device_texture transmittance_lut = device.get_texture(transmittance_lut_handle);
- transmittance_LUT_tex_id = transmittance_lut.get_sampled_index();
-
- std::vector<uint8_t> transmittance_lut_code = read_file("shaders/transmittance_lut.comp.spv");
- handle<device_pipeline> transmittance_lut_compute = device.create_compute_pipeline({
- .cs_code = transmittance_lut_code,
- .name = "transmittance_lut_comp",
- });
-
-
- // API test code
- RD_START_CAPTURE;
-
- graphics_command_buffers[0].start();
-
-#ifdef VK
- graphics_command_buffers[0].barrier(gpu_texture_handle, VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
- graphics_command_buffers[0].barrier(second_texture, VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
- graphics_command_buffers[0].barrier(ui_texture_handle, VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
-#endif
-
- graphics_command_buffers[0].copy(staging_buffer_handle, gpu_texture_handle);
- graphics_command_buffers[0].copy(staging_buffer_handle, second_texture, buffer_offset);
- graphics_command_buffers[0].copy(staging_buffer_handle, ui_texture_handle, ui_offset);
-#ifdef VK
- graphics_command_buffers[0].barrier(gpu_texture_handle, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL);
- graphics_command_buffers[0].barrier(second_texture, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_READ_BIT, VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL);
-
- {
- graphics_command_buffers[0].dispatch({
- .pipeline = compute,
- .group_size = { .vec = { image_size, image_size, 1U }},
- .local_group_size = { .vec = { 8U, 8U, 1U }},
- .params = {
- device.get_texture(second_texture).get_storage_index(), // Input 1
- device.get_texture(gpu_texture_handle).get_storage_index(), // Input 2
- device.get_texture(output_texture_handle).get_storage_index(), // Output
- },
- });
-
- graphics_command_buffers[0].dispatch({
- .pipeline = transmittance_lut_compute,
- .group_size = { .vec = { 1024U, 1024U, 1U }},
- .local_group_size = { .vec { 8U, 8U, 1U }},
- .params = {
- transmittance_lut.get_storage_index(),
- uint64_t(transmittance_lut.width) << 32U | transmittance_lut.height,
- }
- });
- }
-
- graphics_command_buffers[0].barrier(gpu_texture_handle, VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
-#endif
-
- graphics_command_buffers[0].stop();
-
- device.submit(graphics_command_buffers.data(), 1);
- device.wait();
-
- RD_END_CAPTURE;
-
- // watcher::watch_file(std::filesystem::path("../shaders/compute.comp"), [&]() {
- // printf("change");
- // });
-
-#ifdef VK
- std::array<handle<device_texture>, 1U> color_attachment {};
- constexpr uint32_t virtual_frames_count = 2U;
- uint64_t frame_time = 1U;
- uint32_t frame_count = 0U;
- while(wnd.isOpen) {
- LARGE_INTEGER start_qpc;
- QueryPerformanceCounter(&start_qpc);
- wnd.poll_events();
-
- watcher::pull_changes();
-
- uint32_t virtual_frame_index = frame_count % virtual_frames_count;
- auto command_buffer = graphics_command_buffers[2U + virtual_frame_index];
- for (auto& event : wnd.events) {
- if (event.type == EVENT_TYPES::MOUSE_MOVE) {
- io.MousePos.x = static_cast<float>(event.data.position.x);
- io.MousePos.y = static_cast<float>(event.data.position.y);
- }
-
- io.MouseDown[0] = event.type == EVENT_TYPES::BUTTON_PRESS;
- }
-
- ui(frame_time);
-
- auto* draw_data = ImGui::GetDrawData();
- update_buffers(draw_data, vertex_buffer, index_buffer);
-
- const auto& scene_buffer = device.get_buffer(main_scene.scene_buffer_handle);
- main_scene.meta.sample_index = frame_count;
- uint8_t* ptr = static_cast<uint8_t*>(scene_buffer.mapped_ptr);
- memcpy(static_cast<void*>(ptr), &main_scene.meta, sizeof(main_scene.meta));
- memcpy(static_cast<void*>(ptr + sizeof(main_scene.meta)), &main_scene.meta, sizeof(main_scene.meta));
- memcpy(static_cast<void*>(ptr + sizeof(main_scene.meta) * 2U), &main_scene.meta, sizeof(main_scene.meta));
-
- // TODO: Refactor backbuffer acquisition
- auto backbuffer = surface.swapchain_images[device.acquire_image_index(surface_handle)];
- color_attachment[0] = backbuffer;
-
- // RD_START_CAPTURE;
- command_buffer.start();
-
- command_buffer.barrier(backbuffer, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL);
-
- {
- uint64_t textures = (virtual_frame_index == 0U) ? ((uint64_t(acc_storage_index) << 32U) | result_storage_index) : ((uint64_t(result_storage_index) << 32U) | acc_storage_index);
-
- if (virtual_frame_index == 0) {
- command_buffer.barrier(result_handle, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL);
- command_buffer.barrier(acc_handle, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_READ_BIT, VK_IMAGE_LAYOUT_GENERAL);
- } else {
- command_buffer.barrier(result_handle, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_READ_BIT, VK_IMAGE_LAYOUT_GENERAL);
- command_buffer.barrier(acc_handle, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL);
- }
-
- command_buffer.dispatch({
- .pipeline = raytracing,
- .group_size = { .vec { window_width, window_height, 1U, } },
- .local_group_size = { .vec { 8U, 8U, 1U, } },
- .params = {
- main_scene.scene_buffer_address(),
- main_scene.bvh_buffer_address(),
- main_scene.indices_buffer_address(),
- main_scene.positions_buffer_address(),
- main_scene.normals_buffer_address(),
- main_scene.uvs_buffer_address(),
- main_scene.materials_buffer_address(),
- textures,
- },
- });
-
- // TODO: Refactor backbuffer acquisition
- auto backbuffer_storage_index = device.get_texture(backbuffer).get_storage_index();
- uint64_t out = (virtual_frame_index == 0U) ? ((uint64_t(result_storage_index) << 32U) | backbuffer_storage_index) : ((uint64_t(acc_storage_index) << 32U) | backbuffer_storage_index);
- command_buffer.dispatch({
- .pipeline = tonemapping,
- .group_size = { .vec { window_width, window_height, 1U, } },
- .local_group_size = { .vec { 8U, 8U, 1U, } },
- .params = {
- main_scene.scene_buffer_address(),
- main_scene.bvh_buffer_address(),
- main_scene.indices_buffer_address(),
- main_scene.positions_buffer_address(),
- main_scene.normals_buffer_address(),
- main_scene.uvs_buffer_address(),
- main_scene.materials_buffer_address(),
- out,
- },
- });
- }
-
- command_buffer.barrier(backbuffer, VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
-
- command_buffer.begin_renderpass({
- .render_area = {
- .x = static_cast<int32_t>(draw_data->DisplayPos.x),
- .y = static_cast<int32_t>(draw_data->DisplayPos.y),
- .width = static_cast<uint32_t>(draw_data->DisplaySize.x),
- .height = static_cast<uint32_t>(draw_data->DisplaySize.y),
- },
- .color_attachments = color_attachment,
- });
-
- auto& draws_uniform_buffer = device.get_bindingmodel().get_draws_uniform_buffer();
- uint32_t vertex_offset = 0;
- uint32_t index_offset = 0;
- for (auto index {0} ; index < draw_data->CmdListsCount; index++) {
- auto* cmd_list = draw_data->CmdLists[index];
-
- for (auto& draw_command : cmd_list->CmdBuffer) {
- auto offset = draws_uniform_buffer.offset;
- ImTextureID texture_id = draw_command.TexRef.GetTexID();
- {
- struct ui_params {
- // uintptr_t vertex_buffer;
- float scale[2U];
- float translate[2U];
- uint32_t texture_index;
- };
- auto* ui_param = draws_uniform_buffer.allocate<ui_params>();
- *ui_param = ui_params{
- // .vertex_buffer = vertex_buffer.device_address,
- .scale {
- 2.f / draw_data->DisplaySize.x,
- 2.f / draw_data->DisplaySize.y,
- },
- .translate {
- -1.f - draw_data->DisplayPos.x * (2.f / draw_data->DisplaySize.x),
- -1.f - draw_data->DisplayPos.y * (2.f / draw_data->DisplaySize.y),
- },
- .texture_index = *reinterpret_cast<uint32_t*>(&texture_id),
- };
- }
-
- command_buffer.draw_indexed({
- .pipeline = graphics,
- .index_buffer = index_buffer_handle,
- .vertex_count = draw_command.ElemCount,
- .vertex_offset = draw_command.VtxOffset + vertex_offset,
- .index_offset = draw_command.IdxOffset + index_offset,
- .instance_count = 1U,
- .uniforms_address = draws_uniform_buffer.device_address + offset,
- .vertex_address = vertex_buffer.device_address,
- });
- }
- vertex_offset += cmd_list->VtxBuffer.size();
- index_offset += cmd_list->IdxBuffer.size();
- }
-
- command_buffer.end_renderpass();
- command_buffer.barrier(backbuffer, VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
-
- command_buffer.stop();
-
- device.submit_before_present(surface_handle, &command_buffer, 1U);
- device.present(surface_handle);
- device.wait();
-
- LARGE_INTEGER end_qpc;
- QueryPerformanceCounter(&end_qpc);
- LONGLONG diff_qpc = end_qpc.QuadPart - start_qpc.QuadPart;
- frame_time = (diff_qpc * 1000000ULL) / freq.QuadPart;
- frame_count++;
-
- // RD_END_CAPTURE;
- }
-
- device.wait();
- device.destroy_surface(surface_handle);
-
- device.destroy_pipeline(compute);
- device.destroy_pipeline(graphics);
- device.destroy_pipeline(raytracing);
- device.destroy_pipeline(tonemapping);
-
- device.destroy_texture(gpu_texture_handle);
- device.destroy_texture(second_texture);
- device.destroy_texture(output_texture_handle);
- device.destroy_texture(ui_texture_handle);
- device.destroy_texture(acc_handle);
- device.destroy_texture(result_handle);
-
- device.destroy_buffer(staging_buffer_handle);
- device.destroy_buffer(vertex_buffer_handle);
- device.destroy_buffer(index_buffer_handle);
- device.deinit();
-
- ImGui::DestroyContext();
-#endif // VK
-
- return 0;
-}
diff --git a/api-test/vk-bindless.cpp b/api-test/vk-bindless.cpp
deleted file mode 100644
index d3d6415..0000000
--- a/api-test/vk-bindless.cpp
+++ /dev/null
@@ -1,431 +0,0 @@
-#include "vk-bindless.hpp"
-
-#include <vk_mem_alloc.h>
-#include <vulkan/vulkan_core.h>
-
-#include "vk-device.hpp"
-#include "vk-utils.hpp"
-#include "vulkan-loader.hpp"
-
-device_buffer& bindless_model::get_globals_uniform_buffer() const {
- auto& render_device = vkdevice::get_render_device();
- return render_device.get_buffer(globals_uniform_buffer_handle);
-}
-
-device_buffer& bindless_model::get_draws_uniform_buffer() const {
- auto& render_device = vkdevice::get_render_device();
- return render_device.get_buffer(draws_uniform_buffer_handle);
-}
-
-bindless_model bindless_model::create_bindless_model() {
- bindless_model bindless;
- auto& render_device = vkdevice::get_render_device();
- auto* device = render_device.get_device();
-#ifndef USE_VK_DESCRIPTOR_BUFFER
- bindless.create_immutable_samplers(device);
- bindless.create_layout(device);
- bindless.create_descriptor_pool(device);
- bindless.allocate_sets(device);
-
- // VkWriteDescriptorSet writes_descriptor_set[BindlessSetType::MAX];
-
- // {
- bindless.globals_uniform_buffer_handle = render_device.create_buffer({
- .size = globals_uniform_buffer_size,
- .usages = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
- .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
- .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
- });
-
- // const auto& buffer = render_device.get_buffer(bindless.globals_uniform_buffer_handle);
- // VkDescriptorBufferInfo buffer_info {
- // .buffer = buffer.vk_buffer,
- // .offset = 0U,
- // .range = VK_WHOLE_SIZE,
- // };
-
- // writes_descriptor_set[BindlessSetType::GLOBAL] = {
- // .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
- // .pNext = nullptr,
- // .dstSet = bindless.sets[BindlessSetType::GLOBAL],
- // .dstBinding = 3U,
- // .dstArrayElement = 0U,
- // .descriptorCount = 1U,
- // .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
- // .pImageInfo = nullptr,
- // .pBufferInfo = &buffer_info,
- // .pTexelBufferView = nullptr,
- // };
- // }
-
- // {
- // bindless.instances_uniform_buffer_handle = render_device.create_buffer({
- // .size = instances_uniform_buffer_size,
- // .usages = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
- // .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
- // .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
- // });
-
- // const auto& buffer = render_device.get_buffer(bindless.instances_uniform_buffer_handle);
- // VkDescriptorBufferInfo buffer_info {
- // .buffer = buffer.vk_buffer,
- // .offset = 0U,
- // .range = VK_WHOLE_SIZE,
- // };
-
- // writes_descriptor_set[BindlessSetType::INSTANCES_UNIFORMS] = {
- // .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
- // .pNext = nullptr,
- // .dstSet = bindless.sets[BindlessSetType::INSTANCES_UNIFORMS],
- // .dstBinding = 0U,
- // .dstArrayElement = 0U,
- // .descriptorCount = 1U,
- // .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
- // .pImageInfo = nullptr,
- // .pBufferInfo = &buffer_info,
- // .pTexelBufferView = nullptr,
- // };
- // }
-
- // {
- bindless.draws_uniform_buffer_handle = render_device.create_buffer({
- .size = draws_uniform_buffer_size,
- .usages = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
- .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
- .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
- });
-
- // const auto& buffer = render_device.get_buffer(bindless.draws_uniform_buffer_handle);
- // VkDescriptorBufferInfo buffer_info {
- // .buffer = buffer.vk_buffer,
- // .offset = 0U,
- // .range = draws_uniform_buffer_size,
- // };
-
- // writes_descriptor_set[BindlessSetType::DRAWS_UNIFORMS] = {
- // .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
- // .pNext = nullptr,
- // .dstSet = bindless.sets[BindlessSetType::DRAWS_UNIFORMS],
- // .dstBinding = 0U,
- // .dstArrayElement = 0U,
- // .descriptorCount = 1U,
- // .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
- // .pImageInfo = nullptr,
- // .pBufferInfo = &buffer_info,
- // .pTexelBufferView = nullptr,
- // };
- // }
-
- // vkUpdateDescriptorSets(device, sizeof(writes_descriptor_set) / sizeof(VkWriteDescriptorSet), writes_descriptor_set, 0U, nullptr);
-#else
- VkBufferCreateInfo create_info{
- .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .size = desc.size,
- .usage = VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT,
- .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
- .queueFamilyIndexCount = 0,
- .pQueueFamilyIndices = nullptr,
- };
-
- VmaAllocatorCreateFlags alloc_create_flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
- VmaAllocationCreateInfo alloc_create_info{
- .flags = alloc_create_flags,
- .usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
- .requiredFlags = desc.memory_properties,
- .preferredFlags = 0U,
- .memoryTypeBits = 0U,
- .pool = nullptr,
- .pUserData = nullptr,
- };
-
- VmaAllocationInfo alloc_info{};
-
- VKCHECK(vmaCreateBuffer(gpu_allocator, &create_info, &alloc_create_info, &device_buffer.vk_buffer, &device_buffer.alloc, &alloc_info));
-
- device_buffer.mapped_ptr = alloc_info.pMappedData;
-
- return { buffers.add(device_buffer) };
-#endif
-
- return bindless;
-}
-
-void bindless_model::destroy_bindless_model(bindless_model& bindless) {
- auto& render_device = vkdevice::get_render_device();
- auto* device = vkdevice::get_render_device().get_device();
- vkDestroyDescriptorPool(device, bindless.descriptor_pool, nullptr);
-
- for (auto index{ 0U }; index < BindlessSetType::MAX; index++) {
- vkDestroyDescriptorSetLayout(device, bindless.sets_layout[index], nullptr);
- }
-
- vkDestroyPipelineLayout(device, bindless.graphics_layout, nullptr);
- vkDestroyPipelineLayout(device, bindless.compute_layout, nullptr);
-
- bindless.destroy_immutable_samplers(device);
-
- // render_device.destroy_buffer(bindless.instances_uniform_buffer_handle);
- render_device.destroy_buffer(bindless.draws_uniform_buffer_handle);
-}
-
-void bindless_model::create_layout(VkDevice device) {
- // Set 0 global resources
- // Binding 0 Storage images
- // Binding 1 Sampled images
- // Binding 2 Samplers
- // Binding 3 Dynamic Uniform Buffer
- {
- VkDescriptorSetLayoutBinding set_layout_bindings[]{
- {
- .binding = 0U,
- .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER,
- .descriptorCount = SamplerType::MAX_SAMPLER,
- .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
- .pImmutableSamplers = samplers,
- },
- {
- .binding = 1U,
- .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
- .descriptorCount = set_descriptors_count,
- .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
- .pImmutableSamplers = nullptr,
- },
- {
- .binding = 2U,
- .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
- .descriptorCount = set_descriptors_count,
- .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
- .pImmutableSamplers = nullptr,
- },
- // {
- // .binding = 3U,
- // .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
- // .descriptorCount = 1U,
- // .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
- // .pImmutableSamplers = nullptr,
- // },
- };
-
- VkDescriptorBindingFlags flags[]{
- VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT | VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT,
- VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT | VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT,
- VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT | VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT,
- // VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT | VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT,
- // 0U,
- };
-
- VkDescriptorSetLayoutBindingFlagsCreateInfo layout_binding_flags{
- .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
- .pNext = VK_NULL_HANDLE,
- .bindingCount = sizeof(flags) / sizeof(VkDescriptorBindingFlags),
- .pBindingFlags = flags,
- };
-
- VkDescriptorSetLayoutCreateInfo create_info{
- .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
- .pNext = &layout_binding_flags,
- .flags = 0U,
- .bindingCount = sizeof(set_layout_bindings) / sizeof(VkDescriptorSetLayoutBinding),
- .pBindings = set_layout_bindings,
- };
-
- VKCHECK(vkCreateDescriptorSetLayout(device, &create_info, nullptr, &sets_layout[BindlessSetType::GLOBAL]));
- }
-
- // Set 1 per instance uniforms
- // Binding 0 Dynamic Uniform Buffer
- {
- VkDescriptorSetLayoutBinding set_layout_bindings[]{
- {
- .binding = 0U,
- .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
- .descriptorCount = 1U,
- .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
- .pImmutableSamplers = nullptr,
- },
- };
-
- VkDescriptorSetLayoutCreateInfo create_info{
- .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .bindingCount = sizeof(set_layout_bindings) / sizeof(VkDescriptorSetLayoutBinding),
- .pBindings = set_layout_bindings,
- };
-
- VKCHECK(vkCreateDescriptorSetLayout(device, &create_info, nullptr, &sets_layout[BindlessSetType::INSTANCES_UNIFORMS]));
- }
-
- // Set 2 per draw uniforms
- // Binding 0 Dynamic Uniform Buffer
- {
- VkDescriptorSetLayoutBinding set_layout_bindings[]{
- {
- .binding = 0U,
- .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
- .descriptorCount = 1,
- .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
- .pImmutableSamplers = nullptr,
- },
- };
-
- VkDescriptorSetLayoutCreateInfo create_info{
- .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .bindingCount = sizeof(set_layout_bindings) / sizeof(VkDescriptorSetLayoutBinding),
- .pBindings = set_layout_bindings,
- };
-
- VKCHECK(vkCreateDescriptorSetLayout(device, &create_info, nullptr, &sets_layout[BindlessSetType::DRAWS_UNIFORMS]));
- }
-
- {
- VkPushConstantRange push_constants[] {
- {
- .stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
- .offset = 0U,
- .size = max_push_constants_slots_size * (max_push_constants_slots),
- },
- };
-
- VkPipelineLayoutCreateInfo create_info{
- .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .setLayoutCount = sizeof(sets_layout) / sizeof(VkDescriptorSetLayout),
- .pSetLayouts = sets_layout,
- .pushConstantRangeCount = sizeof(push_constants) / sizeof(push_constants[0]),
- .pPushConstantRanges = push_constants,
- };
-
- VKCHECK(vkCreatePipelineLayout(device, &create_info, nullptr, &graphics_layout));
- }
-
- {
- VkPushConstantRange push_constants[] {
- {
- .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
- .offset = 0U,
- .size = max_push_constants_slots_size * max_push_constants_slots,
- },
- };
-
-
- VkPipelineLayoutCreateInfo create_info{
- .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .setLayoutCount = sizeof(sets_layout) / sizeof(VkDescriptorSetLayout),
- .pSetLayouts = sets_layout,
- .pushConstantRangeCount = sizeof(push_constants) / sizeof(push_constants[0]),
- .pPushConstantRanges = push_constants,
- };
-
- VKCHECK(vkCreatePipelineLayout(device, &create_info, nullptr, &compute_layout));
- }
-}
-
-#ifndef USE_VK_DESCRIPTOR_BUFFER
-void bindless_model::create_descriptor_pool(VkDevice device) {
- VkDescriptorPoolSize pool_sizes[]{
- {
- .type = VK_DESCRIPTOR_TYPE_SAMPLER,
- .descriptorCount = set_descriptors_count,
- },
- {
- .type = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
- .descriptorCount = set_descriptors_count,
- },
- {
- .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
- .descriptorCount = set_descriptors_count,
- },
- {
- .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
- .descriptorCount = 8U,
- },
- };
-
- VkDescriptorPoolCreateInfo descriptor_pool_create_info{
- .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .maxSets = descriptor_pool_allocable_sets_count,
- .poolSizeCount = sizeof(pool_sizes) / sizeof(VkDescriptorPoolSize),
- .pPoolSizes = pool_sizes,
- };
- VKCHECK(vkCreateDescriptorPool(device, &descriptor_pool_create_info, nullptr, &descriptor_pool));
-}
-
-void bindless_model::allocate_sets(VkDevice device) {
- VkDescriptorSetAllocateInfo allocate_info{
- .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
- .pNext = nullptr,
- .descriptorPool = descriptor_pool,
- .descriptorSetCount = 1U,
- .pSetLayouts = &sets_layout[BindlessSetType::GLOBAL],
- };
- VKCHECK(vkAllocateDescriptorSets(device, &allocate_info, &sets[BindlessSetType::GLOBAL]));
-
- allocate_info.pSetLayouts = &sets_layout[BindlessSetType::INSTANCES_UNIFORMS],
- VKCHECK(vkAllocateDescriptorSets(device, &allocate_info, &sets[BindlessSetType::INSTANCES_UNIFORMS]));
-
- allocate_info.pSetLayouts = &sets_layout[BindlessSetType::DRAWS_UNIFORMS],
- VKCHECK(vkAllocateDescriptorSets(device, &allocate_info, &sets[BindlessSetType::DRAWS_UNIFORMS]));
-}
-
-void bindless_model::create_immutable_samplers(VkDevice device) {
- VkSamplerCreateInfo create_info{
- .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
- .pNext = VK_NULL_HANDLE,
- .flags = 0,
- .mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST,
- .mipLodBias = 0.f,
- .anisotropyEnable = VK_FALSE,
- .compareEnable = VK_FALSE,
- .compareOp = VK_COMPARE_OP_NEVER,
- .minLod = 0.f,
- .maxLod = 0.f,
- .borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
- .unnormalizedCoordinates = VK_FALSE,
- };
-
- // Nearest sampler creation
- {
- VkFilter filter = VK_FILTER_NEAREST;
- VkSamplerAddressMode address_mode = VK_SAMPLER_ADDRESS_MODE_REPEAT;
-
- create_info.magFilter = filter,
- create_info.minFilter = filter,
- create_info.addressModeU = address_mode,
- create_info.addressModeV = address_mode,
- create_info.addressModeW = address_mode,
-
- VKCHECK(vkCreateSampler(device, &create_info, VK_NULL_HANDLE, &samplers[SamplerType::NEAREST]));
- }
-
- // Linear sampler creation
- {
- VkFilter filter = VK_FILTER_LINEAR;
- VkSamplerAddressMode address_mode = VK_SAMPLER_ADDRESS_MODE_REPEAT;
-
- create_info.magFilter = filter,
- create_info.minFilter = filter,
- create_info.addressModeU = address_mode,
- create_info.addressModeV = address_mode,
- create_info.addressModeW = address_mode,
-
- VKCHECK(vkCreateSampler(device, &create_info, VK_NULL_HANDLE, &samplers[SamplerType::LINEAR]));
- }
-}
-
-void bindless_model::destroy_immutable_samplers(VkDevice device) {
- for (auto* sampler : samplers) {
- vkDestroySampler(device, sampler, nullptr);
- }
-}
-#else
-#endif
diff --git a/api-test/vk-command-buffer.cpp b/api-test/vk-command-buffer.cpp
deleted file mode 100644
index bdb0e40..0000000
--- a/api-test/vk-command-buffer.cpp
+++ /dev/null
@@ -1,233 +0,0 @@
-#include "vk-command-buffer.hpp"
-
-#include <vulkan/vulkan_core.h>
-
-#include "vulkan-loader.hpp"
-
-#include "vk-device.hpp"
-#include "vk-utils.hpp"
-
-void command_buffer::start() const {
- VkCommandBufferBeginInfo begin_info{
- .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
- .pNext = nullptr,
- .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
- .pInheritanceInfo = nullptr
- };
-
- VKCHECK(vkBeginCommandBuffer(vk_command_buffer, &begin_info));
-
- const auto& bindless = vkdevice::get_render_device().get_bindingmodel();
- const auto* global_set = &bindless.sets[BindlessSetType::GLOBAL];
- // const auto global_uniforms = bindless.get_globals_uniform_buffer();
- // if (queue_type == QueueType::GRAPHICS) {
- // vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, bindless.graphics_layout, 0, 1U, global_set, 1U, &global_uniforms.offset);
- // vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, bindless.compute_layout, 0, 1U, global_set, 1U, &global_uniforms.offset);
- // } else if (queue_type == QueueType::ASYNC_COMPUTE) {
- // vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, bindless.compute_layout, 0, 1U, global_set, 1U, &global_uniforms.offset);
- // }
- if (queue_type == QueueType::GRAPHICS) {
- vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, bindless.graphics_layout, 0, 1U, global_set, 0U, nullptr);
- vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, bindless.compute_layout, 0, 1U, global_set, 0U, nullptr);
- } else if (queue_type == QueueType::ASYNC_COMPUTE) {
- vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, bindless.compute_layout, 0, 1U, global_set, 0U, nullptr);
- }
-}
-
-void command_buffer::stop() const {
- VKCHECK(vkEndCommandBuffer(vk_command_buffer));
-}
-
-void command_buffer::barrier(handle<device_texture> texture_handle, VkPipelineStageFlags2 stage, VkAccessFlags2 access, VkImageLayout layout) const {
- auto& texture = vkdevice::get_render_device().get_texture(texture_handle);
-
- VkImageSubresourceRange subresource_range{
- .aspectMask = texture.aspects,
- .baseMipLevel = 0U,
- .levelCount = 1U,
- .baseArrayLayer = 0U,
- .layerCount = 1U,
- };
-
- VkImageMemoryBarrier2 image_barrier{
- .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
- .pNext = nullptr,
- .srcStageMask = texture.stage,
- .srcAccessMask = texture.access,
- .dstStageMask = stage,
- .dstAccessMask = access,
- .oldLayout = texture.layout,
- .newLayout = layout,
- .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
- .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
- .image = texture.vk_image,
- .subresourceRange = subresource_range,
- };
-
- VkDependencyInfo dependency_info{
- .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
- .pNext = nullptr,
- .dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT,
- .memoryBarrierCount = 0U,
- .pMemoryBarriers = nullptr,
- .bufferMemoryBarrierCount = 0U,
- .pBufferMemoryBarriers = nullptr,
- .imageMemoryBarrierCount = 1U,
- .pImageMemoryBarriers = &image_barrier,
- };
- vkCmdPipelineBarrier2(vk_command_buffer, &dependency_info);
-
- texture.layout = layout;
- texture.stage = stage;
- texture.access = access;
-}
-
-void command_buffer::copy(handle<device_buffer> buffer_handle, ::handle<device_texture> texture_handle, uint64_t offset) const {
- auto& device = vkdevice::get_render_device();
- const auto& buffer = device.get_buffer(buffer_handle);
- const auto& texture = device.get_texture(texture_handle);
-
- VkImageSubresourceLayers image_subresource_layers{
- .aspectMask = texture.aspects,
- .mipLevel = 0,
- .baseArrayLayer = 0,
- .layerCount = 1,
- };
-
- VkBufferImageCopy buffer_to_image_copy{
- .bufferOffset = offset,
- .bufferRowLength = 0,
- .bufferImageHeight = 0,
- .imageSubresource = image_subresource_layers,
- .imageOffset = { .x = 0, .y = 0, .z = 0 },
- .imageExtent = {
- .width = texture.width,
- .height = texture.height,
- .depth = texture.depth,
- },
- };
-
- vkCmdCopyBufferToImage(vk_command_buffer, buffer.vk_buffer, texture.vk_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &buffer_to_image_copy);
-}
-
-void graphics_command_buffer::dispatch(const dispatch_params& params) const {
- const auto& pipeline = vkdevice::get_render_device().get_pipeline(params.pipeline);
- const auto& bindless = vkdevice::get_render_device().get_bindingmodel();
- // vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, bindless.compute_layout, static_cast<uint32_t>(BindlessSetType::INSTANCES_UNIFORMS), 1U, &bindless.sets[BindlessSetType::INSTANCES_UNIFORMS], 1U, &params.uniforms_offset);
- // vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, bindless.compute_layout, static_cast<uint32_t>(BindlessSetType::DRAWS_UNIFORMS), 1U, &bindless.sets[BindlessSetType::DRAWS_UNIFORMS], 1U, &params.uniforms_offset);
-
- for (uint32_t push_index = 0U; push_index < bindless_model::max_push_constants_slots; push_index++) {
- vkCmdPushConstants(vk_command_buffer, bindless.compute_layout, VK_SHADER_STAGE_COMPUTE_BIT, push_index * bindless_model::max_push_constants_slots_size, bindless_model::max_push_constants_slots_size, &params.params[push_index]);
- }
-
- vkCmdBindPipeline(vk_command_buffer, pipeline.bind_point, pipeline.vk_pipeline);
-
- auto x = params.group_size.vec.x / params.local_group_size.vec.x;
- auto y = params.group_size.vec.y / params.local_group_size.vec.y;
- auto z = params.group_size.vec.z / params.local_group_size.vec.z;
- vkCmdDispatch(vk_command_buffer, x, y, z);
-}
-
-void graphics_command_buffer::begin_renderpass(const renderpass_params& params) const {
- std::vector<VkRenderingAttachmentInfo> attachments_info(params.color_attachments.size());
-
- for (auto index{ 0U }; index < params.color_attachments.size(); index++) {
- auto& attachment_info = attachments_info[index];
- auto& attachment = vkdevice::get_render_device().get_texture(params.color_attachments[index]);
-
- attachment_info.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
- attachment_info.pNext = nullptr;
- attachment_info.imageView = attachment.whole_view;
- attachment_info.imageLayout = attachment.layout;
- attachment_info.resolveMode = VK_RESOLVE_MODE_NONE;
- attachment_info.resolveImageView = nullptr;
- attachment_info.resolveImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
- attachment_info.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
- attachment_info.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
- attachment_info.clearValue = VkClearValue{
- .color = {
- .float32 = { 0.f, 0.f, 0.f, 0.f },
- },
- };
- }
-
- VkRect2D scissor{
- .offset{
- .x = params.render_area.x,
- .y = params.render_area.x,
- },
- .extent{
- .width = params.render_area.width,
- .height = params.render_area.height,
- },
- };
- VkViewport viewport{
- .x = static_cast<float>(params.render_area.x),
- .y = static_cast<float>(params.render_area.y),
- .width = static_cast<float>(params.render_area.width),
- .height = static_cast<float>(params.render_area.height),
- .minDepth = 0.f,
- .maxDepth = 1.f,
- };
- VkRenderingInfo rendering_info{
- .sType = VK_STRUCTURE_TYPE_RENDERING_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .renderArea = scissor,
- .layerCount = 1U,
- .viewMask = 0U,
- .colorAttachmentCount = static_cast<uint32_t>(attachments_info.size()),
- .pColorAttachments = attachments_info.data(),
- .pDepthAttachment = nullptr,
- .pStencilAttachment = nullptr,
- };
- vkCmdBeginRendering(vk_command_buffer, &rendering_info);
-
- vkCmdSetScissor(vk_command_buffer, 0U, 1U, &scissor);
- vkCmdSetViewport(vk_command_buffer, 0U, 1U, &viewport);
-
- // auto& device = vkdevice::get_render_device();
- // const auto& bindless = device.get_bindingmodel();
- // vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, bindless.layout, static_cast<uint32_t>(BindlessSetType::GLOBAL), 1U, &bindless.sets[BindlessSetType::GLOBAL], 1U, &params.uniforms_offset);
- // vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, bindless.layout, static_cast<uint32_t>(BindlessSetType::GLOBAL), 1U, &bindless.sets[BindlessSetType::GLOBAL], 1U, &params.uniforms_offset);
-}
-
-void graphics_command_buffer::draw(const draw_params& params) const {
- auto& device = vkdevice::get_render_device();
- const auto& pipeline = device.get_pipeline(params.pipeline);
-
- const auto& bindless = device.get_bindingmodel();
- // vkCmdBindDescriptorSets(vk_command_buffer, pipeline.bind_point, bindless.layout, static_cast<uint32_t>(BindlessSetType::DRAWS_UNIFORMS), 1U, &bindless.sets[BindlessSetType::DRAWS_UNIFORMS], 1U, &params.uniforms_offset);
-
- vkCmdBindPipeline(vk_command_buffer, pipeline.bind_point, pipeline.vk_pipeline);
-
- vkCmdPushConstants(vk_command_buffer, bindless.graphics_layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, ConstantType::GLOBALS * bindless_model::max_push_constants_slots_size, bindless_model::max_push_constants_slots_size, &params.globals_address);
- vkCmdPushConstants(vk_command_buffer, bindless.graphics_layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, ConstantType::INSTANCES * bindless_model::max_push_constants_slots_size, bindless_model::max_push_constants_slots_size, &params.instances_address);
- vkCmdPushConstants(vk_command_buffer, bindless.graphics_layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, ConstantType::DRAWS * bindless_model::max_push_constants_slots_size, bindless_model::max_push_constants_slots_size, &params.uniforms_address);
- vkCmdPushConstants(vk_command_buffer, bindless.graphics_layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, ConstantType::VERTEX_BUFFER * bindless_model::max_push_constants_slots_size, bindless_model::max_push_constants_slots_size, &params.vertex_address);
-
- vkCmdDraw(vk_command_buffer, params.vertex_count, params.instance_count, params.vertex_offset, 0U);
-}
-
-void graphics_command_buffer::draw_indexed(const draw_indexed_params& params) const {
- auto& device = vkdevice::get_render_device();
- const auto& pipeline = device.get_pipeline(params.pipeline);
-
- const auto& bindless = device.get_bindingmodel();
- // vkCmdBindDescriptorSets(vk_command_buffer, pipeline.bind_point, bindless.layout, static_cast<uint32_t>(BindlessSetType::DRAWS_UNIFORMS), 1U, &bindless.sets[BindlessSetType::DRAWS_UNIFORMS], 1U, &params.uniforms_offset);
-
- vkCmdBindPipeline(vk_command_buffer, pipeline.bind_point, pipeline.vk_pipeline);
-
- vkCmdPushConstants(vk_command_buffer, bindless.graphics_layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, ConstantType::GLOBALS * bindless_model::max_push_constants_slots_size, bindless_model::max_push_constants_slots_size, &params.globals_address);
- vkCmdPushConstants(vk_command_buffer, bindless.graphics_layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, ConstantType::INSTANCES * bindless_model::max_push_constants_slots_size, bindless_model::max_push_constants_slots_size, &params.instances_address);
- vkCmdPushConstants(vk_command_buffer, bindless.graphics_layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, ConstantType::DRAWS * bindless_model::max_push_constants_slots_size, bindless_model::max_push_constants_slots_size, &params.uniforms_address);
- vkCmdPushConstants(vk_command_buffer, bindless.graphics_layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, ConstantType::VERTEX_BUFFER * bindless_model::max_push_constants_slots_size, bindless_model::max_push_constants_slots_size, &params.vertex_address);
-
- const auto& index_buffer = device.get_buffer(params.index_buffer);
- vkCmdBindIndexBuffer(vk_command_buffer, index_buffer.vk_buffer, 0U, VK_INDEX_TYPE_UINT16);
- vkCmdDrawIndexed(vk_command_buffer, params.vertex_count, params.instance_count, params.index_offset, static_cast<int32_t>(params.vertex_offset), 0U);
-}
-
-void graphics_command_buffer::end_renderpass() const {
- vkCmdEndRendering(vk_command_buffer);
-}
diff --git a/api-test/vk-device.cpp b/api-test/vk-device.cpp
deleted file mode 100644
index 1e7b385..0000000
--- a/api-test/vk-device.cpp
+++ /dev/null
@@ -1,1302 +0,0 @@
-#include "vk-device.hpp"
-
-#include <cassert>
-#include <vector>
-
-#include <vulkan/vulkan_core.h>
-
-#define VMA_IMPLEMENTATION
-#include <vk_mem_alloc.h>
-
-#include "vk-utils.hpp"
-#include "vulkan-loader.hpp"
-#include "vk-command-buffer.hpp"
-
-vkdevice vkdevice::render_device = vkdevice();
-
-void vkdevice::init() {
- queues[static_cast<uint32_t>(QueueType::GRAPHICS)] = {
- .usages = VK_QUEUE_GRAPHICS_BIT |
- VK_QUEUE_COMPUTE_BIT |
- VK_QUEUE_TRANSFER_BIT,
- };
- queues[static_cast<uint32_t>(QueueType::ASYNC_COMPUTE)] = {
- .usages = VK_QUEUE_COMPUTE_BIT,
- };
- queues[static_cast<uint32_t>(QueueType::TRANSFER)] = {
- .usages = VK_QUEUE_TRANSFER_BIT,
- };
-
- load_vulkan();
-
- create_instance();
-
-#ifdef _DEBUG
- create_debug_layer_callback();
-#endif // _DEBUG
-
- create_device();
-
- create_memory_allocator();
-
- bindless = bindless_model::create_bindless_model();
-
- auto semaphore = create_semaphore({
- .type = VK_SEMAPHORE_TYPE_TIMELINE,
- }, "timeline_semaphore");
- timeline_semaphore = get_semaphore(semaphore);
-}
-
-void vkdevice::deinit() {
- vkDeviceWaitIdle(device);
-
- bindless_model::destroy_bindless_model(bindless);
-
- vmaDestroyAllocator(gpu_allocator);
-
- for (auto& queue : queues) {
- vkDestroyCommandPool(device, queue.command_pool, nullptr);
- }
-
- vkDestroySemaphore(device, timeline_semaphore.vk_semaphore, nullptr);
-
- vkDestroyDevice(device, nullptr);
-
-#ifdef _DEBUG
- vkDestroyDebugUtilsMessengerEXT(instance, debug_messenger, nullptr);
-#endif // _DEBUG
-
- vkDestroyInstance(instance, nullptr);
-}
-
-
-void vkdevice::wait() { vkDeviceWaitIdle(device); };
-
-handle<device_texture> vkdevice::create_texture(const texture_desc& desc) {
- device_texture device_texture;
- device_texture.init(desc);
-
- return textures.add(device_texture);
-}
-
-handle<device_sampler> vkdevice::create_sampler(const sampler_desc& desc) {
- device_sampler device_sampler;
- device_sampler.init(desc);
-
- return samplers.add(device_sampler);
-}
-
-handle<device_buffer> vkdevice::create_buffer(const buffer_desc& desc) {
- device_buffer device_buffer{
- .size = desc.size,
- };
-
- VkBufferCreateInfo create_info{
- .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .size = desc.size,
- .usage = desc.usages,
- .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
- .queueFamilyIndexCount = 0,
- .pQueueFamilyIndices = nullptr,
- };
-
- VmaAllocatorCreateFlags alloc_create_flags =
- desc.memory_usage != VMA_MEMORY_USAGE_GPU_ONLY ? VMA_ALLOCATION_CREATE_MAPPED_BIT : 0U;
-
- VmaAllocationCreateInfo alloc_create_info{
- .flags = alloc_create_flags,
- .usage = static_cast<VmaMemoryUsage>(desc.memory_usage),
- .requiredFlags = desc.memory_properties,
- .preferredFlags = 0U,
- .memoryTypeBits = 0U,
- .pool = nullptr,
- .pUserData = nullptr,
- };
-
- VmaAllocationInfo alloc_info{};
-
- VKCHECK(vmaCreateBuffer(gpu_allocator, &create_info, &alloc_create_info, &device_buffer.vk_buffer, &device_buffer.alloc, &alloc_info));
-
- if ((desc.usages & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) != 0U) {
- VkBufferDeviceAddressInfo address_info {
- .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
- .pNext = nullptr,
- .buffer = device_buffer.vk_buffer,
- };
- device_buffer.device_address = vkGetBufferDeviceAddress(device, &address_info);
- }
-
- device_buffer.mapped_ptr = alloc_info.pMappedData;
-
- return buffers.add(device_buffer);
-}
-
-handle<device_pipeline> vkdevice::create_graphics_pipeline(const graphics_pipeline_desc& desc) {
- device_pipeline device_pipeline{
- };
-
- VkPipelineShaderStageCreateInfo shader_stages_create_info[2U]{ {
- .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .stage = VK_SHADER_STAGE_VERTEX_BIT,
- .module = create_shader_module(desc.vs_code),
- .pName = "main",
- .pSpecializationInfo = nullptr,
- },
- {
- .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .stage = VK_SHADER_STAGE_FRAGMENT_BIT,
- .module = create_shader_module(desc.fs_code),
- .pName = "main",
- .pSpecializationInfo = nullptr,
- },
- };
-
- VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info{
- .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
- };
-
- VkPipelineInputAssemblyStateCreateInfo input_assembly_create_info{
- .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
- .primitiveRestartEnable = VK_FALSE,
- };
-
- VkPipelineViewportStateCreateInfo viewport_state_create_info{
- .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .viewportCount = 1U,
- .pViewports = nullptr,
- .scissorCount = 1U,
- .pScissors = nullptr,
- };
-
- VkPipelineRasterizationStateCreateInfo rasterization_state_create_info{
- .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .depthClampEnable = VK_FALSE,
- .rasterizerDiscardEnable = VK_FALSE,
- .polygonMode = VK_POLYGON_MODE_FILL,
- .cullMode = VK_CULL_MODE_NONE,
- .frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE,
- .depthBiasEnable = VK_FALSE,
- .lineWidth = 1.f,
- };
-
- VkPipelineMultisampleStateCreateInfo multisample_state_create_info{
- .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0,
- .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT,
- .sampleShadingEnable = VK_FALSE,
- .minSampleShading = 1.f,
- };
-
- VkPipelineColorBlendAttachmentState color_attachment_state{
- .blendEnable = VK_TRUE,
- .srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA,
- .dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
- .colorBlendOp = VK_BLEND_OP_ADD,
- .srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE,
- .dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
- .alphaBlendOp = VK_BLEND_OP_ADD,
- .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT,
- };
-
- VkPipelineColorBlendStateCreateInfo color_blend_state_create_info{
- .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0,
- .logicOpEnable = VK_FALSE,
- .attachmentCount = 1,
- .pAttachments = &color_attachment_state,
- };
-
- VkDynamicState dynamic_states[]{
- VK_DYNAMIC_STATE_VIEWPORT,
- VK_DYNAMIC_STATE_SCISSOR,
- };
-
- VkPipelineDynamicStateCreateInfo dynamic_state_create_info{
- .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .dynamicStateCount = sizeof(dynamic_states) / sizeof(VkDynamicState),
- .pDynamicStates = dynamic_states,
- };
-
- VkPipelineRenderingCreateInfo pipeline_rendering_create_info{
- .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
- .pNext = nullptr,
- .viewMask = 0U,
- .colorAttachmentCount = static_cast<uint32_t>(desc.color_attachments_format.size()),
- .pColorAttachmentFormats = desc.color_attachments_format.data(),
- .depthAttachmentFormat = VK_FORMAT_UNDEFINED,
- .stencilAttachmentFormat = VK_FORMAT_UNDEFINED,
- };
-
- VkGraphicsPipelineCreateInfo create_info{
- .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
- .pNext = &pipeline_rendering_create_info,
- .flags = 0U,
- .stageCount = sizeof(shader_stages_create_info) / sizeof(VkPipelineShaderStageCreateInfo),
- .pStages = shader_stages_create_info,
- .pVertexInputState = &vertex_input_state_create_info,
- .pInputAssemblyState = &input_assembly_create_info,
- .pTessellationState = nullptr,
- .pViewportState = &viewport_state_create_info,
- .pRasterizationState = &rasterization_state_create_info,
- .pMultisampleState = &multisample_state_create_info,
- .pDepthStencilState = nullptr,
- .pColorBlendState = &color_blend_state_create_info,
- .pDynamicState = &dynamic_state_create_info,
- .layout = bindless.graphics_layout,
- .renderPass = nullptr,
- .subpass = 0U,
- .basePipelineHandle = nullptr,
- .basePipelineIndex = 0,
- };
-
- device_pipeline.bind_point = VK_PIPELINE_BIND_POINT_GRAPHICS;
- VKCHECK(vkCreateGraphicsPipelines(device, nullptr, 1U, &create_info, nullptr, &device_pipeline.vk_pipeline));
-
- for(auto& stage_create_info : shader_stages_create_info) {
- vkDestroyShaderModule(device, stage_create_info.module, nullptr);
- }
-
- if (desc.name) {
- VkDebugUtilsObjectNameInfoEXT object_name{
- .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
- .pNext = nullptr,
- .objectType = VK_OBJECT_TYPE_PIPELINE,
- .objectHandle = reinterpret_cast<uint64_t>(device_pipeline.vk_pipeline),
- .pObjectName = desc.name,
- };
- vkSetDebugUtilsObjectNameEXT(device, &object_name);
- }
-
- return pipelines.add(device_pipeline);
-}
-
-handle<device_pipeline> vkdevice::create_compute_pipeline(const compute_pipeline_desc& desc) {
- device_pipeline device_pipeline{
- };
-
- VkPipelineShaderStageCreateInfo stage_create_info{
- .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .stage = VK_SHADER_STAGE_COMPUTE_BIT,
- .module = create_shader_module(desc.cs_code),
- .pName = "main",
- .pSpecializationInfo = nullptr,
- };
-
- VkComputePipelineCreateInfo create_info{
- .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .stage = stage_create_info,
- .layout = bindless.compute_layout,
- .basePipelineHandle = nullptr,
- .basePipelineIndex = 0,
- };
-
- device_pipeline.bind_point = VK_PIPELINE_BIND_POINT_COMPUTE;
- VKCHECK(vkCreateComputePipelines(device, nullptr, 1U, &create_info, nullptr, &device_pipeline.vk_pipeline));
-
- vkDestroyShaderModule(device, stage_create_info.module, nullptr);
-
- if (desc.name) {
- VkDebugUtilsObjectNameInfoEXT object_name{
- .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
- .pNext = nullptr,
- .objectType = VK_OBJECT_TYPE_PIPELINE,
- .objectHandle = reinterpret_cast<uint64_t>(device_pipeline.vk_pipeline),
- .pObjectName = desc.name,
- };
- vkSetDebugUtilsObjectNameEXT(device, &object_name);
- }
-
- return pipelines.add(device_pipeline);
-}
-
-handle<device_surface> vkdevice::create_surface(const surface_desc& desc) {
- device_surface device_surface {
- };
-
- {
- VkWin32SurfaceCreateInfoKHR create_info{
- .sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,
- .pNext = nullptr,
- .flags = 0U,
- .hinstance = GetModuleHandle(nullptr),
- .hwnd = desc.window_handle,
- };
-
- VKCHECK(vkCreateWin32SurfaceKHR(instance, &create_info, nullptr, &device_surface.vk_surface));
- }
-
- create_swapchain(desc, device_surface);
-
- assert(surface_desc::max_image_count >= device_surface.image_count);
-
- for (uint32_t index = 0u; index < device_surface.image_count; index++) {
- device_surface.acquire_semaphores[index] = create_semaphore({
- .type = VK_SEMAPHORE_TYPE_BINARY,
- }, "acquire_semaphore");
- device_surface.submit_semaphores[index] = create_semaphore({
- .type = VK_SEMAPHORE_TYPE_BINARY,
- }, "submit_semaphore");
- }
-
- return surfaces.add(device_surface);
-}
-
-handle<device_semaphore> vkdevice::create_semaphore(const semaphore_desc& desc, const char* name) {
- device_semaphore semaphore {
- .value = desc.initial_value,
- };
- VkSemaphoreTypeCreateInfo semaphore_type_create_info{
- .sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
- .pNext = nullptr,
- .semaphoreType = desc.type,
- .initialValue = desc.initial_value,
- };
-
- VkSemaphoreCreateInfo create_info{
- .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
- .pNext = &semaphore_type_create_info,
- .flags = 0U,
- };
-
- VKCHECK(vkCreateSemaphore(device, &create_info, nullptr, &semaphore.vk_semaphore));
-
- if (name) {
- VkDebugUtilsObjectNameInfoEXT object_name{
- .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
- .pNext = nullptr,
- .objectType = VK_OBJECT_TYPE_SEMAPHORE,
- .objectHandle = reinterpret_cast<uint64_t>(semaphore.vk_semaphore),
- .pObjectName = name,
- };
- vkSetDebugUtilsObjectNameEXT(device, &object_name);
- }
- return semaphores.add(semaphore);
-}
-
-void vkdevice::destroy_texture(handle<device_texture> handle) {
- auto& texture = get_texture(handle);
-
- texture.release();
- textures.remove(handle);
-}
-
-void vkdevice::destroy_buffer(handle<device_buffer> handle) {
- const auto& buffer = get_buffer(handle);
-
- vmaDestroyBuffer(gpu_allocator, buffer.vk_buffer, buffer.alloc);
- buffers.remove(handle);
-}
-
-void vkdevice::destroy_pipeline(handle<device_pipeline> handle) {
- const auto& pipeline = vkdevice::get_pipeline(handle);
-
- vkDestroyPipeline(device, pipeline.vk_pipeline, nullptr);
- pipelines.remove(handle);
-}
-
-void vkdevice::destroy_semaphore(handle<device_semaphore> handle) {
- auto& semaphore = vkdevice::get_semaphore(handle);
-
- vkDestroySemaphore(device, semaphore.vk_semaphore, nullptr);
- semaphores.remove(handle);
-}
-
-void vkdevice::destroy_surface(handle<device_surface> handle) {
- auto& surface = vkdevice::get_surface(handle);
-
- for (auto texture_index{0U}; texture_index < surface.image_count; texture_index++) {
- auto texture_handle = surface.swapchain_images[texture_index];
- destroy_texture(texture_handle);
- }
-
- for (uint32_t index = 0u; index < surface.image_count; index++) {
- destroy_semaphore(surface.acquire_semaphores[index]);
- destroy_semaphore(surface.submit_semaphores[index]);
- }
-
- vkDestroySwapchainKHR(device, surface.vk_swapchain, nullptr);
-
- vkDestroySurfaceKHR(instance, surface.vk_surface, nullptr);
-}
-
-// uint64_t vkdevice::submit(std::span<command_buffer> buffers, handle<device_semaphore> wait_handle, handle<device_semaphore> signal_handle, handle<device_semaphore> fence_handle) {
-// assert((max_submitable_command_buffers - buffers.size()) >= 0);
-// const auto queue_type = buffers[0].queue_type;
-//
-// VkCommandBufferSubmitInfo command_buffers_info[buffers.size()];
-//
-// for (auto index{ 0U }; index < buffers.size(); index++) {
-// assert(queue_type == buffers[index].queue_type);
-//
-// auto& command_buffer_info = command_buffers_info[index];
-// command_buffer_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO;
-// command_buffer_info.pNext = nullptr;
-// command_buffer_info.commandBuffer = buffers[index].vk_command_buffer;
-// command_buffer_info.deviceMask = 0U;
-// }
-//
-// VkSemaphoreSubmitInfo wait_semaphore_info{
-// .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
-// .pNext = nullptr,
-// .stageMask = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT,
-// .deviceIndex = 0U,
-// };
-//
-// VkSemaphoreSubmitInfo signal_semaphore_infos[2U];
-//
-// VkSubmitInfo2 submit_info{
-// .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2,
-// .pNext = nullptr,
-// .flags = 0U,
-// .waitSemaphoreInfoCount = 0U,
-// .commandBufferInfoCount = static_cast<uint32_t>(buffers.size()),
-// .pCommandBufferInfos = command_buffers_info,
-// .pSignalSemaphoreInfos = signal_semaphore_infos,
-// };
-//
-// if (wait_handle.is_valid()) {
-// const auto& wait = vkdevice::get_render_device().get_semaphore(wait_handle);
-// wait_semaphore_info.semaphore = wait.vk_semaphore;
-// wait_semaphore_info.value = wait.value;
-// submit_info.waitSemaphoreInfoCount++;
-// submit_info.pWaitSemaphoreInfos = &wait_semaphore_info;
-// }
-//
-// if (signal_handle.is_valid()) {
-// auto& signal = vkdevice::get_render_device().get_semaphore(signal_handle);
-// signal_semaphore_infos[0U] = {
-// .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
-// .pNext = nullptr,
-// .semaphore = signal.vk_semaphore,
-// .value = signal.value,
-// .stageMask = VK_PIPELINE_STAGE_2_NONE,
-// .deviceIndex = 0U,
-// };
-// submit_info.signalSemaphoreInfoCount++;
-// }
-//
-// uint64_t ret = -1;
-//
-// if (fence_handle.is_valid()) {
-// auto& fence = vkdevice::get_render_device().get_semaphore(fence_handle);
-// auto fence_index = submit_info.signalSemaphoreInfoCount;
-// signal_semaphore_infos[fence_index] = {
-// .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
-// .pNext = nullptr,
-// .semaphore = fence.vk_semaphore,
-// .value = ++fence.value,
-// .stageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
-// .deviceIndex = 0U,
-// };
-// ret = fence.value;
-// }
-//
-// VKCHECK(vkQueueSubmit2(queues[static_cast<uint32_t>(queue_type)].vk_queue, 1, &submit_info, nullptr));
-//
-// return ret;
-// }
-
-uint64_t vkdevice::submit(command_buffer* buffers, uint32_t count) {
- assert((max_submitable_command_buffers - count) >= 0);
- const auto queue_type = buffers[0].queue_type;
-
- // VkCommandBufferSubmitInfo command_buffers_info[count];
- VkCommandBufferSubmitInfo command_buffers_info[max_submitable_command_buffers];
-
- for (auto index{ 0U }; index < count; index++) {
- assert(queue_type == buffers[index].queue_type);
-
- auto& command_buffer_info = command_buffers_info[index];
- command_buffer_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO;
- command_buffer_info.pNext = nullptr;
- command_buffer_info.commandBuffer = buffers[index].vk_command_buffer;
- command_buffer_info.deviceMask = 0U;
- }
-
- VkSubmitInfo2 submit_info{
- .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2,
- .pNext = nullptr,
- .flags = 0U,
- .waitSemaphoreInfoCount = 0U,
- .pWaitSemaphoreInfos = nullptr,
- .commandBufferInfoCount = count,
- .pCommandBufferInfos = command_buffers_info,
- };
-
- auto& fence = timeline_semaphore;
- VkSemaphoreSubmitInfo signal_semaphore_infos[] = {
- {
- .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
- .pNext = nullptr,
- .semaphore = fence.vk_semaphore,
- .value = ++fence.value,
- .stageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
- .deviceIndex = 0U,
- },
- };
- submit_info.signalSemaphoreInfoCount = sizeof(signal_semaphore_infos) / sizeof(signal_semaphore_infos[0U]);
- submit_info.pSignalSemaphoreInfos = signal_semaphore_infos;
-
- VKCHECK(vkQueueSubmit2(queues[static_cast<uint32_t>(queue_type)].vk_queue, 1, &submit_info, nullptr));
-
- return fence.value;
-}
-
-uint64_t vkdevice::submit_before_present(handle<device_surface> surface_handle, command_buffer* buffers, uint32_t count) {
- assert((max_submitable_command_buffers - count) >= 0);
- const auto queue_type = buffers[0].queue_type;
-
- // VkCommandBufferSubmitInfo command_buffers_info[count];
- VkCommandBufferSubmitInfo command_buffers_info[max_submitable_command_buffers];
-
- for (auto index{ 0U }; index < count; index++) {
- assert(queue_type == buffers[index].queue_type);
-
- auto& command_buffer_info = command_buffers_info[index];
- command_buffer_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO;
- command_buffer_info.pNext = nullptr;
- command_buffer_info.commandBuffer = buffers[index].vk_command_buffer;
- command_buffer_info.deviceMask = 0U;
- }
-
- const auto& surface = get_surface(surface_handle);
- auto& wait = get_semaphore(surface.acquire_semaphores[surface.frame_index]);
- VkSemaphoreSubmitInfo wait_semaphore_info = {
- .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
- .pNext = nullptr,
- .semaphore = wait.vk_semaphore,
- .value = wait.value,
- .stageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
- .deviceIndex = 0U,
- };
-
- VkSubmitInfo2 submit_info{
- .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2,
- .pNext = nullptr,
- .flags = 0U,
- .waitSemaphoreInfoCount = 1U,
- .pWaitSemaphoreInfos = &wait_semaphore_info,
- .commandBufferInfoCount = count,
- .pCommandBufferInfos = command_buffers_info,
- };
-
- auto& fence = timeline_semaphore;
- auto& signal = get_semaphore(surface.submit_semaphores[surface.frame_index]);
- VkSemaphoreSubmitInfo signal_semaphore_infos[] = {
- {
- .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
- .pNext = nullptr,
- .semaphore = fence.vk_semaphore,
- .value = ++fence.value,
- .stageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
- .deviceIndex = 0U,
- },
- {
- .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
- .pNext = nullptr,
- .semaphore = signal.vk_semaphore,
- .value = signal.value,
- .stageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
- .deviceIndex = 0U,
- },
- };
- submit_info.signalSemaphoreInfoCount = sizeof(signal_semaphore_infos) / sizeof(signal_semaphore_infos[0U]);
- submit_info.pSignalSemaphoreInfos = signal_semaphore_infos;
-
- VKCHECK(vkQueueSubmit2(queues[static_cast<uint32_t>(queue_type)].vk_queue, 1, &submit_info, nullptr));
-
- return fence.value;
-}
-
-void vkdevice::present(handle<device_surface> surface_handle) {
- auto& surface = vkdevice::get_render_device().get_surface(surface_handle);
- VkResult result;
- VkPresentInfoKHR present_info{
- .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
- .pNext = nullptr,
- .swapchainCount = 1U,
- .pSwapchains = &surface.vk_swapchain,
- .pImageIndices = &surface.image_index,
- .pResults = &result,
- };
-
- const auto& semaphore = get_semaphore(surface.submit_semaphores[surface.frame_index]);
- present_info.waitSemaphoreCount = 1U;
- present_info.pWaitSemaphores = &semaphore.vk_semaphore;
-
- VKCHECK(vkQueuePresentKHR(queues[static_cast<uint32_t>(QueueType::GRAPHICS)].vk_queue, &present_info));
-
- VKCHECK(result);
- surface.frame_index = (surface.frame_index + 1) % surface.image_count;
-}
-
-// private
-void vkdevice::allocate_command_buffers(command_buffer* buffers, size_t count, QueueType type, const char* name) {
- assert((max_allocable_command_buffers - count) >= 0);
- const auto& queue = queues[static_cast<uint32_t>(type)];
- VkCommandBuffer command_buffers[max_allocable_command_buffers];
-
- VkCommandBufferAllocateInfo allocate_info{
- .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
- .pNext = nullptr,
- .commandPool = queue.command_pool,
- .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
- .commandBufferCount = static_cast<uint32_t>(count),
- };
-
- VKCHECK(vkAllocateCommandBuffers(device, &allocate_info, command_buffers));
-
- for (auto index{ 0U }; index < count; index++) {
- buffers[index].vk_command_buffer = command_buffers[index];
- buffers[index].queue_type = type;
-
- if (name) {
- VkDebugUtilsObjectNameInfoEXT object_name{
- .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
- .pNext = nullptr,
- .objectType = VK_OBJECT_TYPE_COMMAND_BUFFER,
- .objectHandle = reinterpret_cast<uint64_t>(command_buffers[index]),
- .pObjectName = name,
- };
- vkSetDebugUtilsObjectNameEXT(device, &object_name);
- }
- }
-}
-
-VkShaderModule vkdevice::create_shader_module(const std::span<uint8_t>& shader_code) {
- VkShaderModule shader_module;
- const auto& code = shader_code;
- VkShaderModuleCreateInfo create_info{
- .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .codeSize = code.size(),
- .pCode = reinterpret_cast<uint32_t*>(code.data()),
- };
-
- VKCHECK(vkCreateShaderModule(device, &create_info, nullptr, &shader_module));
- return shader_module;
-}
-
-void vkdevice::create_swapchain(const surface_desc& desc, device_surface& surface) {
- VkSurfaceKHR vk_surface = surface.vk_surface;
-
- auto& queue = queues[static_cast<uint32_t>(QueueType::GRAPHICS)];
-
- {
- VkBool32 supported = VK_FALSE;
- VKCHECK(vkGetPhysicalDeviceSurfaceSupportKHR(physical_device, queue.index, vk_surface, &supported));
-
- assert(supported);
- }
-
- VkSurfaceCapabilitiesKHR surface_capabilities;
- VKCHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device, vk_surface, &surface_capabilities));
-
- VkExtent2D extent = surface_capabilities.currentExtent;
- if (extent.width < surface_capabilities.minImageExtent.width) {
- extent.width = surface_capabilities.minImageExtent.width;
- } else if (extent.width > surface_capabilities.maxImageExtent.width) {
- extent.width = surface_capabilities.maxImageExtent.width;
- }
-
- if (extent.height < surface_capabilities.minImageExtent.height) {
- extent.height = surface_capabilities.minImageExtent.height;
- } else if (extent.height > surface_capabilities.maxImageExtent.height) {
- extent.height = surface_capabilities.maxImageExtent.height;
- }
-
- {
- auto supported = false;
- auto supported_formats_count = 0U;
- VKCHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, vk_surface, &supported_formats_count, nullptr));
-
- std::vector<VkSurfaceFormatKHR> supported_formats{ supported_formats_count };
- VKCHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, vk_surface, &supported_formats_count, supported_formats.data()));
-
- for (auto& surface_format : supported_formats) {
- if (surface_format.format == desc.surface_format.format &&
- surface_format.colorSpace == desc.surface_format.colorSpace) {
- supported = true;
- break;
- }
- }
-
- assert(supported);
- }
-
- {
- auto supported = false;
- auto supported_present_modes_count = 0U;
- VKCHECK(vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, vk_surface, &supported_present_modes_count, nullptr));
-
- std::vector<VkPresentModeKHR> supported_present_modes{ supported_present_modes_count };
- VKCHECK(vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, vk_surface, &supported_present_modes_count, supported_present_modes.data()));
-
- for (auto& present_mode : supported_present_modes) {
- if (present_mode == desc.present_mode) {
- supported = true;
- break;
- }
- }
-
- assert(supported);
- }
-
- assert(desc.image_count >= surface_capabilities.minImageCount);
- assert(desc.image_count <= surface_capabilities.maxImageCount);
-
- VkSwapchainCreateInfoKHR create_info = {
- .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
- .pNext = nullptr,
- .flags = 0U,
- .surface = vk_surface,
- .minImageCount = desc.image_count,
- .imageFormat = desc.surface_format.format,
- .imageColorSpace = desc.surface_format.colorSpace,
- .imageExtent = extent,
- .imageArrayLayers = 1U,
- .imageUsage = desc.usages,
- .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE,
- .queueFamilyIndexCount = 0U,
- .pQueueFamilyIndices = nullptr,
- .preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
- .compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
- .presentMode = desc.present_mode,
- .clipped = VK_TRUE,
- .oldSwapchain = nullptr,
- };
-
- VKCHECK(vkCreateSwapchainKHR(device, &create_info, nullptr, &surface.vk_swapchain));
-
- surface.surface_format = desc.surface_format;
-
- vkGetSwapchainImagesKHR(device, surface.vk_swapchain, &surface.image_count, nullptr);
- assert(surface.image_count <= surface_desc::max_image_count);
-
- std::vector<VkImage> images {surface.image_count};
- vkGetSwapchainImagesKHR(device, surface.vk_swapchain, &surface.image_count, images.data());
-
- for (auto index {0U}; index < surface.image_count; index++) {
- surface.swapchain_images[index] = create_texture({
- .width = extent.width,
- .height = extent.height,
- .depth = 1U,
- .mips = 1U,
- .usages = desc.usages,
- .format = desc.surface_format.format,
- .type = VK_IMAGE_TYPE_2D,
- .vk_image = images[index],
- });
- }
-}
-
-// ----------------- vkadapter -----------------
-
-void vkdevice::create_instance() {
- VkApplicationInfo app_info{
- .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
- .pApplicationName = "path-tracer",
- .applicationVersion = VK_MAKE_VERSION(1, 0, 0),
- .pEngineName = "gpu-path-tracer",
- .engineVersion = VK_MAKE_VERSION(1, 0, 0),
- .apiVersion = VK_API_VERSION_1_3,
- };
-
- constexpr const char* instance_layers[]{
- "VK_LAYER_KHRONOS_validation",
- };
-
- constexpr const char* instance_extensions[]{
- VK_EXT_DEBUG_UTILS_EXTENSION_NAME,
- "VK_KHR_surface",
- "VK_KHR_win32_surface"
- };
-
- VkInstanceCreateInfo create_info{
- .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .pApplicationInfo = &app_info,
- .enabledLayerCount = sizeof(instance_layers) / sizeof(instance_layers[0]),
- .ppEnabledLayerNames = instance_layers,
- .enabledExtensionCount = sizeof(instance_extensions) / sizeof(instance_extensions[0]),
- .ppEnabledExtensionNames = instance_extensions,
- };
-
- VKCHECK(vkCreateInstance(&create_info, nullptr, &instance));
-
- load_instance_functions(instance);
-}
-
-void vkdevice::create_device() {
- pick_physical_device();
-
- float queue_priority = 1.f;
- VkDeviceQueueCreateInfo queue_create_infos[static_cast<uint32_t>(QueueType::MAX)];
-
- for (auto& queue_create_info : queue_create_infos) {
- queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
- queue_create_info.pNext = nullptr;
- queue_create_info.flags = 0U;
- queue_create_info.queueCount = 1;
- queue_create_info.pQueuePriorities = &queue_priority;
- }
-
- auto queue_properties_count = 0U;
- vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_properties_count, nullptr);
-
- std::vector<VkQueueFamilyProperties> queue_properties{ queue_properties_count };
- vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_properties_count, queue_properties.data());
-
- for (auto index{ 0U }; index < static_cast<uint32_t>(QueueType::MAX); index++) {
- auto& queue = queues[index];
-
- for (auto properties_index{ 0U }; properties_index < queue_properties_count; properties_index++) {
- auto& queue_property = queue_properties[properties_index];
-
- if ((queue_property.queueFlags & queue.usages) == queue.usages) {
- queue_create_infos[index].queueFamilyIndex = queue.index = properties_index;
- queue_property.queueFlags = 0U;
- }
- }
- }
-
- constexpr const char* device_extensions[] = {
- VK_KHR_SWAPCHAIN_EXTENSION_NAME,
- // VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME
- };
-
- VkPhysicalDeviceVulkan12Features physical_device_12_features{
- .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
- .pNext = nullptr,
- .shaderSampledImageArrayNonUniformIndexing = VK_TRUE,
- .shaderStorageImageArrayNonUniformIndexing = VK_TRUE,
- .descriptorBindingUpdateUnusedWhilePending = VK_TRUE,
- .descriptorBindingPartiallyBound = VK_TRUE,
- .runtimeDescriptorArray = VK_TRUE,
- .timelineSemaphore = VK_TRUE,
- .bufferDeviceAddress = VK_TRUE,
- };
-
- VkPhysicalDeviceVulkan13Features physical_device_13_features{
- .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES,
- .pNext = &physical_device_12_features,
- .synchronization2 = VK_TRUE,
- .dynamicRendering = VK_TRUE,
- };
-
- VkDeviceCreateInfo create_info{
- .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
- .pNext = &physical_device_13_features,
- .flags = 0U,
- .queueCreateInfoCount = static_cast<uint32_t>(QueueType::MAX),
- .pQueueCreateInfos = queue_create_infos,
- .enabledLayerCount = 0,
- .ppEnabledLayerNames = nullptr,
- .enabledExtensionCount = sizeof(device_extensions) / sizeof(device_extensions[0]),
- .ppEnabledExtensionNames = device_extensions,
- .pEnabledFeatures = nullptr,
- };
-
- VKCHECK(vkCreateDevice(physical_device, &create_info, nullptr, &device));
-
- load_device_functions(device);
-
- for (auto& queue : queues) {
- vkGetDeviceQueue(device, queue.index, 0, &queue.vk_queue);
- }
-
- create_command_pools();
-}
-
-void vkdevice::create_memory_allocator() {
- VmaAllocatorCreateInfo create_info{
- .flags = VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT,
- .physicalDevice = physical_device,
- .device = device,
- .instance = instance,
- .vulkanApiVersion = VK_API_VERSION_1_2,
- };
-
- VKCHECK(vmaCreateAllocator(&create_info, &gpu_allocator));
-}
-
-void vkdevice::create_command_pools() {
- VkCommandPoolCreateInfo create_info{
- .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
- .pNext = nullptr,
- .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
- };
-
- for (auto& queue : queues) {
- create_info.queueFamilyIndex = queue.index;
-
- VKCHECK(vkCreateCommandPool(device, &create_info, nullptr, &queue.command_pool));
- }
-}
-
-void vkdevice::pick_physical_device() {
- auto physical_devices_count = 0U;
- vkEnumeratePhysicalDevices(instance, &physical_devices_count, nullptr);
-
- assert(physical_devices_count > 0);
-
- std::vector<VkPhysicalDevice> physical_devices{ physical_devices_count };
- vkEnumeratePhysicalDevices(instance, &physical_devices_count, physical_devices.data());
-
- for (auto& physical_dev : physical_devices) {
- if (device_support_features(physical_dev)) {
- physical_device = physical_dev;
- return;
- }
- }
-
- assert(true);
-}
-
-bool vkdevice::device_support_features(VkPhysicalDevice physical_dev) {
- // limits
- {
- VkPhysicalDeviceProperties2 props{
- .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
- .pNext = nullptr,
- };
- vkGetPhysicalDeviceProperties2(physical_dev, &props);
-
- VkPhysicalDeviceLimits* limits = &props.properties.limits;
- if (limits->maxPerStageDescriptorSampledImages < 0x10000 ||
- limits->maxPerStageDescriptorStorageImages < 0x10000 ||
- limits->maxDescriptorSetSampledImages < 0x10000 ||
- limits->maxDescriptorSetStorageImages < 0x10000) {
- return false;
- }
- }
-
- // Vulkan 1.2 physical device features support
- {
- VkPhysicalDeviceVulkan12Features vulkan_12_features{
- .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
- };
-
- VkPhysicalDeviceFeatures2 physical_device_features{
- .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
- .pNext = &vulkan_12_features,
- };
-
- vkGetPhysicalDeviceFeatures2(physical_dev, &physical_device_features);
-
- // clang-format off
- if (vulkan_12_features.bufferDeviceAddress == VK_FALSE ||
- vulkan_12_features.runtimeDescriptorArray == VK_FALSE ||
- vulkan_12_features.shaderStorageImageArrayNonUniformIndexing == VK_FALSE ||
- vulkan_12_features.shaderSampledImageArrayNonUniformIndexing == VK_FALSE ||
- vulkan_12_features.descriptorBindingPartiallyBound == VK_FALSE ||
- vulkan_12_features.descriptorBindingUpdateUnusedWhilePending == VK_FALSE ||
- vulkan_12_features.imagelessFramebuffer == VK_FALSE) {
- return false;
- }
- // clang-format on
- }
-
- // Vulkan 1.3 physical device features support
- {
- VkPhysicalDeviceVulkan13Features vulkan_13_features{
- .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES,
- };
-
- VkPhysicalDeviceFeatures2 physical_device_features{
- .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
- .pNext = &vulkan_13_features,
- };
-
- vkGetPhysicalDeviceFeatures2(physical_dev, &physical_device_features);
-
- if (vulkan_13_features.synchronization2 == VK_FALSE ||
- vulkan_13_features.dynamicRendering == VK_FALSE) {
- return false;
- }
- }
-
- return true;
-}
-
-void vkdevice::create_debug_layer_callback() {
-#ifdef _DEBUG
- VkDebugUtilsMessengerCreateInfoEXT create_info{
- .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
- .pNext = nullptr,
- .flags = 0U,
- .messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT |
- VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT,
- .messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
- VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT |
- VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT,
- .pfnUserCallback = debug_callback,
- .pUserData = nullptr,
- };
-
- VKCHECK(vkCreateDebugUtilsMessengerEXT(instance, &create_info, nullptr, &debug_messenger));
-#endif // _DEBUG
-}
-
-
-idlist<> device_texture::sampled_indices = {};
-idlist<> device_texture::storage_indices = {};
-idlist<> device_sampler::sampler_indices = {};
-
-void device_texture::init(const texture_desc& desc) {
- auto& render_device = vkdevice::get_render_device();
- const auto& bindless = render_device.get_bindingmodel();
- auto* device = render_device.get_device();
-
- vk_image = desc.vk_image;
- format = desc.format;
- width = desc.width;
- height = desc.height;
- mips = desc.mips;
- aspects = ((desc.usages & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0U)
- ? VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT
- : VK_IMAGE_ASPECT_COLOR_BIT;
-
- assert(mips <= texture_desc::max_mips);
-
- if (vk_image == nullptr) {
- VkImageCreateInfo create_info{
- .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .imageType = desc.type,
- .format = desc.format,
- .extent = {
- .width = desc.width,
- .height = desc.height,
- .depth = desc.depth
- },
- .mipLevels = desc.mips,
- .arrayLayers = 1,
- .samples = VK_SAMPLE_COUNT_1_BIT,
- .tiling = VK_IMAGE_TILING_OPTIMAL,
- .usage = desc.usages,
- .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
- .queueFamilyIndexCount = 0,
- .pQueueFamilyIndices = nullptr,
- .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
- };
-
- VmaAllocationCreateInfo alloc_create_info{
- .flags = 0U,
- .usage = VMA_MEMORY_USAGE_GPU_ONLY,
- .requiredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
- .preferredFlags = 0U,
- .memoryTypeBits = 0U,
- .pool = nullptr,
- .pUserData = nullptr,
- };
-
- VKCHECK(vmaCreateImage(render_device.get_allocator(), &create_info, &alloc_create_info, &vk_image, &alloc, nullptr));
- }
-
- if (desc.name) {
- VkDebugUtilsObjectNameInfoEXT object_name{
- .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
- .pNext = nullptr,
- .objectType = VK_OBJECT_TYPE_IMAGE,
- .objectHandle = reinterpret_cast<uint64_t>(vk_image),
- .pObjectName = desc.name,
- };
- vkSetDebugUtilsObjectNameEXT(device, &object_name);
- }
-
- create_views();
-
- // TODO: Handle mips views
- VkDescriptorImageInfo images_info[]{
- {
- nullptr,
- whole_view,
- VK_IMAGE_LAYOUT_GENERAL,
- },
- };
-
- std::vector<VkWriteDescriptorSet> write_descriptor_sets;
- if ((desc.usages & VK_IMAGE_USAGE_STORAGE_BIT) != 0) {
- storage_index = storage_indices.add();
-
- write_descriptor_sets.push_back({
- .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
- .pNext = nullptr,
- .dstSet = bindless.sets[BindlessSetType::GLOBAL],
- .dstBinding = 2U,
- .dstArrayElement = storage_index.id,
- .descriptorCount = sizeof(images_info) / sizeof(VkDescriptorImageInfo),
- .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
- .pImageInfo = images_info,
- .pBufferInfo = nullptr,
- .pTexelBufferView = nullptr,
- });
- }
- if ((desc.usages & VK_IMAGE_USAGE_SAMPLED_BIT) != 0) {
- sampled_index = sampled_indices.add();
-
- write_descriptor_sets.push_back({
- .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
- .pNext = nullptr,
- .dstSet = bindless.sets[BindlessSetType::GLOBAL],
- .dstBinding = 1U,
- .dstArrayElement = sampled_index.id,
- .descriptorCount = sizeof(images_info) / sizeof(VkDescriptorImageInfo),
- .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
- .pImageInfo = images_info,
- .pBufferInfo = nullptr,
- .pTexelBufferView = nullptr,
- });
- }
-
- vkUpdateDescriptorSets(device, static_cast<uint32_t>(write_descriptor_sets.size()), write_descriptor_sets.data(), 0U, nullptr);
-}
-
-void device_texture::release() {
- auto& render_device = vkdevice::get_render_device();
- auto* device = render_device.get_device();
- auto* gpu_allocator = render_device.get_allocator();
-
- if (alloc != nullptr) {
- vmaDestroyImage(gpu_allocator, vk_image, alloc);
- }
-
- vkDestroyImageView(device, whole_view, nullptr);
-
- for (auto mip_index{ 0U }; mip_index < mips; mip_index++) {
- const auto& mip_view = mips_views[mip_index];
- vkDestroyImageView(device, mip_view, nullptr);
- }
-
- if (storage_index.is_valid()) {
- storage_indices.remove(storage_index);
- }
-
- if (sampled_index.is_valid()) {
- sampled_indices.remove(sampled_index);
- }
-}
-
-void device_texture::create_views() {
- auto* device = vkdevice::get_render_device().get_device();
-
- VkImageViewCreateInfo create_info{
- .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .image = vk_image,
- .viewType = VK_IMAGE_VIEW_TYPE_2D,
- .format = format,
- .components = {
- .r = VK_COMPONENT_SWIZZLE_R,
- .g = VK_COMPONENT_SWIZZLE_G,
- .b = VK_COMPONENT_SWIZZLE_B,
- .a = VK_COMPONENT_SWIZZLE_A,
- },
- .subresourceRange = {
- .aspectMask = aspects,
- .baseMipLevel = 0,
- .levelCount = 1,
- .baseArrayLayer = 0,
- .layerCount = 1,
- },
- };
-
- for (auto mip_index{ 0U }; mip_index < mips; mip_index++) {
- create_info.subresourceRange.baseMipLevel = mip_index;
- VKCHECK(vkCreateImageView(device, &create_info, nullptr, &mips_views[mip_index]));
- }
-
- create_info.subresourceRange.baseMipLevel = 0;
- create_info.subresourceRange.levelCount = mips;
- VKCHECK(vkCreateImageView(device, &create_info, nullptr, &whole_view));
-}
-
-
-void device_sampler::init(const sampler_desc& desc) {
- auto& render_device = vkdevice::get_render_device();
- // const auto& bindless = render_device.get_bindingmodel();
- auto* device = render_device.get_device();
-
- VkSamplerCreateInfo sampler_create_info{
- .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .magFilter = desc.mag_filter,
- .minFilter = desc.min_filter,
- .mipmapMode = desc.mipmap_mode,
- .addressModeU = desc.address_mode_u,
- .addressModeV = desc.address_mode_v,
- .addressModeW = desc.address_mode_w,
- .mipLodBias = desc.mip_lod_bias,
- .anisotropyEnable = desc.anisotropy,
- .maxAnisotropy = desc.max_anisotropy,
- .compareEnable = desc.compare_enabled,
- .compareOp = desc.compare_op,
- .minLod = desc.min_lod,
- .maxLod = desc.max_lod,
- .borderColor = desc.border_color,
- .unnormalizedCoordinates = desc.unnomalized_coords,
- };
-
- VKCHECK(vkCreateSampler(device, &sampler_create_info, nullptr, &vk_sampler));
-
- sampler_index = sampler_indices.add();
-
- // VkWriteDescriptorSet write_descriptor_set{
- // .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
- // .pNext = nullptr,
- // .dstSet = bindless.sets[BindlessSetType::GLOBAL],
- // .dstBinding = 1U,
- // .dstArrayElement = sampler_index.id,
- // .descriptorCount = 1U,
- // .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
- // .pImageInfo = images_info,
- // .pBufferInfo = nullptr,
- // .pTexelBufferView = nullptr,
- // });
-}
-
-
-uint32_t vkdevice::acquire_image_index(handle<device_surface> surface_handle) {
- auto& surface = get_surface(surface_handle);
- const auto& signal = get_semaphore(surface.acquire_semaphores[surface.frame_index]);
-
- VkSemaphoreWaitInfo wait_info {
- .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
- .pNext = nullptr,
- .flags = 0U,
- .semaphoreCount = 1U,
- .pSemaphores = &timeline_semaphore.vk_semaphore,
- .pValues = &timeline_semaphore.value,
- };
- vkWaitSemaphores(device, &wait_info, UINT64_MAX);
- VKCHECK(vkAcquireNextImageKHR(device, surface.vk_swapchain, UINT64_MAX, signal.vk_semaphore, nullptr, &surface.image_index));
-
- return surface.image_index;
-}
diff --git a/api-test/vk-utils.cpp b/api-test/vk-utils.cpp
deleted file mode 100644
index 4df6424..0000000
--- a/api-test/vk-utils.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "vk-utils.hpp"
-
-#include <cstdio>
-
-VKAPI_ATTR VkBool32 VKAPI_CALL debug_callback(VkDebugUtilsMessageSeverityFlagBitsEXT severity,
- VkDebugUtilsMessageTypeFlagsEXT type,
- const VkDebugUtilsMessengerCallbackDataEXT* data,
- void*) {
- const char* severity_cstr = nullptr;
- switch (severity) {
- case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT:
- severity_cstr = "VERBOSE";
- break;
- case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT:
- severity_cstr = "INFO";
- break;
- case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT:
- severity_cstr = "WARNING";
- break;
- case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT:
- severity_cstr = "ERROR";
- break;
- default:
- break;
- }
-
- const char* type_cstr = nullptr;
- switch (type) {
- case VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT:
- type_cstr = "GENERAL";
- break;
- case VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT:
- type_cstr = "VALIDATION";
- break;
- case VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT:
- type_cstr = "PERFORMANCE";
- break;
- default:
- break;
- }
-
- fprintf(stderr, "[%s_%s]:%s\n", severity_cstr, type_cstr, data->pMessage);
- return VK_FALSE;
-}
generated by cgit v1.3 (git 2.53.0) at 2026-10-25 09:23:27 +0000