diff options
Diffstat (limited to 'api-test')
| -rw-r--r-- | api-test/dx12-command-buffer.cpp | 47 | ||||
| -rw-r--r-- | api-test/dx12-device.cpp | 239 | ||||
| -rw-r--r-- | api-test/main.cpp | 653 | ||||
| -rw-r--r-- | api-test/vk-bindless.cpp | 431 | ||||
| -rw-r--r-- | api-test/vk-command-buffer.cpp | 233 | ||||
| -rw-r--r-- | api-test/vk-device.cpp | 1302 | ||||
| -rw-r--r-- | api-test/vk-utils.cpp | 44 |
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, ¶ms.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, ¶ms.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, ¶ms.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, ¶ms.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, ¶ms.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, ¶ms.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, ¶ms.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, ¶ms.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, ¶ms.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, ¶ms.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, ¶ms.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, ¶ms.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, ¶ms.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, ¶ms.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, ¶ms.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; -} |