diff --git a/examples/vulkan/ComputeBarycentricRasterizer/Barycentric.comp b/examples/vulkan/ComputeBarycentricRasterizer/Barycentric.comp index 60511fa..3c476e7 100644 --- a/examples/vulkan/ComputeBarycentricRasterizer/Barycentric.comp +++ b/examples/vulkan/ComputeBarycentricRasterizer/Barycentric.comp @@ -1,15 +1,15 @@ #version 450 -layout(binding = 0) uniform UniformBufferObject { +layout(push_constant, std430) uniform PushConstants { int width; int height; - vec2 vertex_a; - vec2 vertex_b; - vec2 vertex_c; + ivec2 vertex_a; + ivec2 vertex_b; + ivec2 vertex_c; } ubo; -layout(std430, binding = 1) buffer rasterize_in_out { int rasterize[]; }; +layout(std430, binding = 0) buffer rasterize_in_out { int rasterize[]; }; layout(local_size_x = 16, local_size_y = 16, local_size_z = 1) in; diff --git a/examples/vulkan/ComputeBarycentricRasterizer/ComputeBarycentric.cpp b/examples/vulkan/ComputeBarycentricRasterizer/ComputeBarycentric.cpp index 4b2978c..3d58a68 100644 --- a/examples/vulkan/ComputeBarycentricRasterizer/ComputeBarycentric.cpp +++ b/examples/vulkan/ComputeBarycentricRasterizer/ComputeBarycentric.cpp @@ -1,56 +1,86 @@ #include "ComputeBarycentric.h" +#include +#include + namespace core { namespace example { -ComputeBarycentric::ComputeBarycentric(core::vulkan::VulkanContext* context, const int width, - const int height) - : core::vulkan::VulkanCompute(context), - uniform_buffer_(context, sizeof(UniformData), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT), - uniform_data_{.width = width, .height = height} { +ComputeBarycentric::ComputeBarycentric(core::vulkan::VulkanContext* context, + const int width, const int height) + : core::vulkan::VulkanCompute(context), width_(width), height_(height) { + if (width_ <= 0 || height_ <= 0 || width_ > 16384 || height_ > 16384) { + throw std::invalid_argument( + "Rasterizer dimensions must be between 1 and 16384"); + } CreateBuffers(); } void ComputeBarycentric::Init() { core::vulkan::VulkanCompute::Init(); - // Copy uniform data to the uniform buffer - // Fill uniform with randon A, B, C vertex coordinates - uniform_buffer_.MapData([this](void* data) { - uniform_data_.vertex_a = glm::vec2(300, 800); - uniform_data_.vertex_b = glm::vec2(500, 100); - uniform_data_.vertex_c = glm::vec2(700, 800); - memcpy(data, &uniform_data_, sizeof(UniformData)); - }); - - // Fill rasterized with all 0s rasterized.MapData([this](void* data) { - core::Mat mat(uniform_data_.height, uniform_data_.width); - mat.Fill(0); - memcpy(data, mat.data(), mat.total() * sizeof(int)); + std::memset(data, 0, static_cast(rasterized.Size())); }); - CreateUniformBufferDescriptorSet(0, uniform_buffer_); - CreateStorageBufferDescriptorSet(1, rasterized); + CreateStorageBufferDescriptorSet(0, rasterized); - vkUpdateDescriptorSets(context_->logical_device, writes_.size(), writes_.data(), 0, nullptr); + vkUpdateDescriptorSets(context_->logical_device, + static_cast(writes_.size()), writes_.data(), + 0, nullptr); } void ComputeBarycentric::Run(const VkCommandBuffer command_buffer) { - // Record commands to dispatch the compute shader + Run(command_buffer, Triangle{.a = glm::ivec2(300, 800), + .b = glm::ivec2(500, 100), + .c = glm::ivec2(700, 800)}); +} + +void ComputeBarycentric::Run(VkCommandBuffer command_buffer, + const Triangle& triangle) { + for (const glm::ivec2& vertex : {triangle.a, triangle.b, triangle.c}) { + if (vertex.x < -16383 || vertex.x > 16383 || vertex.y < -16383 || + vertex.y > 16383) { + throw std::invalid_argument( + "Rasterizer coordinates must be between -16383 and 16383"); + } + } + const PushConstants parameters{.width = width_, + .height = height_, + .vertex_a = triangle.a, + .vertex_b = triangle.b, + .vertex_c = triangle.c}; + VkMemoryBarrier barrier{}; + barrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER; + barrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT; + barrier.dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT; + vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 1, &barrier, 0, + nullptr, 0, nullptr); + vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline); vkCmdBindDescriptorSets(command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline_layout, 0, 1, &descriptor_set_, 0, nullptr); + vkCmdPushConstants(command_buffer, pipeline_layout, + VK_SHADER_STAGE_COMPUTE_BIT, 0, + static_cast(sizeof(parameters)), ¶meters); - const uint32_t group_x = (uniform_data_.width + 15) / 16; - const uint32_t group_y = (uniform_data_.height + 15) / 16; + const uint32_t group_x = (static_cast(width_) + 15) / 16; + const uint32_t group_y = (static_cast(height_) + 15) / 16; vkCmdDispatch(command_buffer, group_x, group_y, 1); } std::vector ComputeBarycentric::GetBindingInfo() const { - return {{0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT}, - {1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT}}; + return {{.binding = 0, + .descriptor_type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, + .shader_stage = VK_SHADER_STAGE_COMPUTE_BIT}}; +} + +std::vector ComputeBarycentric::GetPushConstantRanges() + const { + return {{.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT, + .offset = 0, + .size = static_cast(sizeof(PushConstants))}}; } const std::vector& ComputeBarycentric::LoadShaderCode() const { @@ -61,7 +91,8 @@ const std::vector& ComputeBarycentric::LoadShaderCode() const { } void ComputeBarycentric::CreateBuffers() { - const VkDeviceSize size = uniform_data_.width * uniform_data_.height * sizeof(int); + const VkDeviceSize size = static_cast(width_) * + static_cast(height_) * sizeof(int); rasterized = core::vulkan::VulkanBuffer( context_, size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); diff --git a/examples/vulkan/ComputeBarycentricRasterizer/ComputeBarycentric.h b/examples/vulkan/ComputeBarycentricRasterizer/ComputeBarycentric.h index ddec9cd..2650c86 100644 --- a/examples/vulkan/ComputeBarycentricRasterizer/ComputeBarycentric.h +++ b/examples/vulkan/ComputeBarycentricRasterizer/ComputeBarycentric.h @@ -2,7 +2,6 @@ #include -#include "Mat.h" #include "VulkanBuffer.h" #include "VulkanCompute.h" #include "glm/glm.hpp" @@ -12,28 +11,39 @@ namespace example { class ComputeBarycentric : public core::vulkan::VulkanCompute { public: + struct Triangle { + glm::ivec2 a; + glm::ivec2 b; + glm::ivec2 c; + }; + ComputeBarycentric(core::vulkan::VulkanContext* context, const int width, const int height); void Init() override; void Run(const VkCommandBuffer command_buffer); + void Run(VkCommandBuffer command_buffer, const Triangle& triangle); core::vulkan::VulkanBuffer rasterized; protected: std::vector GetBindingInfo() const override; + std::vector GetPushConstantRanges() const override; const std::vector& LoadShaderCode() const override; private: void CreateBuffers(); - core::vulkan::VulkanBuffer uniform_buffer_; - struct UniformData { + struct PushConstants { int width; int height; - glm::vec2 vertex_a; - glm::vec2 vertex_b; - glm::vec2 vertex_c; - } uniform_data_; + glm::ivec2 vertex_a; + glm::ivec2 vertex_b; + glm::ivec2 vertex_c; + }; + static_assert(sizeof(PushConstants) == 32); + + int width_; + int height_; }; } // namespace example } // namespace core \ No newline at end of file diff --git a/examples/vulkan/ComputeBarycentricRasterizer/main.cpp b/examples/vulkan/ComputeBarycentricRasterizer/main.cpp index 015b152..bec8686 100644 --- a/examples/vulkan/ComputeBarycentricRasterizer/main.cpp +++ b/examples/vulkan/ComputeBarycentricRasterizer/main.cpp @@ -36,7 +36,19 @@ int main() { query_pool.Reset(command_buffer.buffer()); query_pool.Query(command_buffer.buffer(), 0, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT); barycentric->Run(command_buffer.buffer()); + barycentric->Run( + command_buffer.buffer(), + core::example::ComputeBarycentric::Triangle{.a = glm::ivec2(50, 450), + .b = glm::ivec2(150, 50), + .c = glm::ivec2(250, 450)}); query_pool.Query(command_buffer.buffer(), 1, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT); + VkMemoryBarrier host_barrier{}; + host_barrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER; + host_barrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT; + host_barrier.dstAccessMask = VK_ACCESS_HOST_READ_BIT; + vkCmdPipelineBarrier( + command_buffer.buffer(), VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &host_barrier, 0, nullptr, 0, nullptr); command_buffer.Submit(fence.fence, core::vulkan::SubmitSyncInfo{}); vkWaitForFences(context.logical_device, 1, &fence.fence, VK_TRUE, UINT64_MAX); diff --git a/tests/vulkan/CMakeLists.txt b/tests/vulkan/CMakeLists.txt index 496eb59..c37eac5 100644 --- a/tests/vulkan/CMakeLists.txt +++ b/tests/vulkan/CMakeLists.txt @@ -12,14 +12,22 @@ file(GLOB test_src add_executable(vulkan_tests ${test_src}) +add_vulkan_shader_target(vulkan_rasterizer_test_shader + SOURCE_DIR ${PROJECT_SOURCE_DIR}/examples/vulkan/ComputeBarycentricRasterizer + OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/shaders) + +target_sources(vulkan_tests PRIVATE + ${PROJECT_SOURCE_DIR}/examples/vulkan/ComputeBarycentricRasterizer/ComputeBarycentric.cpp) + target_include_directories(vulkan_tests PRIVATE ComputeSum ComputeGaussianBlur Roofline + ${PROJECT_SOURCE_DIR}/examples/vulkan/ComputeBarycentricRasterizer ${CMAKE_CURRENT_BINARY_DIR}/shaders) -add_dependencies(vulkan_tests vulkan_shaders) +add_dependencies(vulkan_tests vulkan_shaders vulkan_rasterizer_test_shader) target_link_libraries(vulkan_tests PRIVATE diff --git a/tests/vulkan/VulkanPushConstantsTest.cpp b/tests/vulkan/VulkanPushConstantsTest.cpp new file mode 100644 index 0000000..deaf40b --- /dev/null +++ b/tests/vulkan/VulkanPushConstantsTest.cpp @@ -0,0 +1,219 @@ +#include + +#include +#include +#include +#include +#include +#include + +#include "ComputeBarycentric.h" +#include "VulkanBase.h" +#include "VulkanCommandBuffer.h" +#include "VulkanContext.h" +#include "VulkanSync.h" + +namespace core { +namespace test { +namespace { + +using Triangle = example::ComputeBarycentric::Triangle; + +class LayoutProbe : public vulkan::VulkanBase { + public: + LayoutProbe(vulkan::VulkanContext* context, + std::vector ranges) + : VulkanBase(context), ranges_(std::move(ranges)) {} + + private: + std::vector GetBindingInfo() const override { + return {}; + } + std::vector GetPushConstantRanges() const override { + return ranges_; + } + void CreatePipeline() override {} + + std::vector ranges_; +}; + +bool Covers(const Triangle& triangle, int x, int y) { + if (x < std::min({triangle.a.x, triangle.b.x, triangle.c.x}) || + x > std::max({triangle.a.x, triangle.b.x, triangle.c.x}) || + y < std::min({triangle.a.y, triangle.b.y, triangle.c.y}) || + y > std::max({triangle.a.y, triangle.b.y, triangle.c.y})) { + return false; + } + const glm::ivec2 vertices[] = {triangle.a, triangle.b, triangle.c, + triangle.a}; + for (int edge = 0; edge < 3; ++edge) { + const int64_t dx = + static_cast(vertices[edge + 1].x) - vertices[edge].x; + const int64_t dy = + static_cast(vertices[edge + 1].y) - vertices[edge].y; + const int64_t px = static_cast(x) - vertices[edge].x; + const int64_t py = static_cast(y) - vertices[edge].y; + if (dx * py - dy * px < 0) { + return false; + } + } + return true; +} + +void SubmitAndWait(vulkan::VulkanContext& context, + vulkan::VulkanCommandBuffer& command) { + VkMemoryBarrier barrier{}; + barrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER; + barrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT; + barrier.dstAccessMask = VK_ACCESS_HOST_READ_BIT; + vkCmdPipelineBarrier(command.buffer(), VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &barrier, 0, nullptr, + 0, nullptr); + vulkan::VulkanFence fence(&context); + fence.Reset(); + command.Submit(fence.fence, vulkan::SubmitSyncInfo{}); + VK_CHECK(vkWaitForFences(context.logical_device, 1, &fence.fence, VK_TRUE, + UINT64_MAX)); +} + +TEST(VulkanPushConstantsTest, + AcceptsDeviceLimitAndSharedBytesForDistinctStages) { + vulkan::VulkanContext context(true); + context.Init(); + VkPhysicalDeviceProperties properties{}; + vkGetPhysicalDeviceProperties(context.physical_device, &properties); + LayoutProbe probe( + &context, + {{.stageFlags = VK_SHADER_STAGE_VERTEX_BIT, .offset = 0, .size = 4}, + {.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT, .offset = 0, .size = 4}, + {.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT, + .offset = properties.limits.maxPushConstantsSize - 4, + .size = 4}}); + probe.Init(); + EXPECT_NE(probe.pipeline_layout, VK_NULL_HANDLE); +} + +TEST(VulkanPushConstantsTest, RejectsInvalidRangesBeforeCreatingResources) { + vulkan::VulkanContext context(true); + context.Init(); + VkPhysicalDeviceProperties properties{}; + vkGetPhysicalDeviceProperties(context.physical_device, &properties); + const uint32_t limit = properties.limits.maxPushConstantsSize; + const std::vector invalid_ranges = { + {.stageFlags = 0, .offset = 0, .size = 4}, + {.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT, .offset = 2, .size = 4}, + {.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT, .offset = 0, .size = 0}, + {.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT, .offset = 0, .size = 6}, + {.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT, .offset = limit, .size = 4}, + {.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT, + .offset = limit - 4, + .size = 8}, + {.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT, + .offset = UINT32_MAX - 3, + .size = 4}}; + for (const VkPushConstantRange& range : invalid_ranges) { + LayoutProbe probe(&context, {range}); + EXPECT_THROW(probe.Init(), std::invalid_argument); + EXPECT_EQ(probe.pipeline_layout, VK_NULL_HANDLE); + } + LayoutProbe duplicate( + &context, + {{.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT, .offset = 0, .size = 4}, + {.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT, .offset = 4, .size = 4}}); + EXPECT_THROW(duplicate.Init(), std::invalid_argument); +} + +TEST(VulkanPushConstantsTest, + RecordsDistinctTrianglesAndReusesPipelineAcrossSubmissions) { + vulkan::VulkanContext context(true); + context.Init(); + example::ComputeBarycentric rasterizer(&context, 37, 29); + rasterizer.Init(); + vulkan::VulkanCommandBuffer command(&context); + const std::vector triangles = { + {.a = glm::ivec2(1, 1), .b = glm::ivec2(21, 2), .c = glm::ivec2(3, 25)}, + {.a = glm::ivec2(10, 8), .b = glm::ivec2(36, 8), .c = glm::ivec2(30, 28)}, + {.a = glm::ivec2(-5, -3), + .b = glm::ivec2(12, -3), + .c = glm::ivec2(-5, 15)}}; + for (size_t count = 1; count <= triangles.size(); ++count) { + rasterizer.rasterized.MapData([&rasterizer](void* data) { + std::memset(data, 0, static_cast(rasterizer.rasterized.Size())); + }); + command.BeginCommandBufferWithReset(); + for (size_t index = 0; index < count; ++index) { + Triangle parameters = triangles[index]; + rasterizer.Run(command.buffer(), parameters); + parameters.a = glm::ivec2(100, 100); + parameters.b = glm::ivec2(110, 100); + parameters.c = glm::ivec2(100, 110); + } + SubmitAndWait(context, command); + rasterizer.rasterized.MapData([&triangles, count](void* data) { + const int* pixels = static_cast(data); + for (int y = 0; y < 29; ++y) { + for (int x = 0; x < 37; ++x) { + bool covered = false; + for (size_t index = 0; index < count; ++index) { + covered = covered || Covers(triangles[index], x, y); + } + ASSERT_EQ(pixels[y * 37 + x], covered ? 1 : 0) << x << "," << y; + } + } + }); + } +} + +TEST(VulkanPushConstantsTest, + PreservesDefaultTriangleAndHandlesSinglePixelAndErrors) { + vulkan::VulkanContext context(true); + context.Init(); + example::ComputeBarycentric original(&context, 1000, 1000); + original.Init(); + vulkan::VulkanCommandBuffer command(&context); + command.BeginCommandBufferWithReset(); + original.Run(command.buffer()); + SubmitAndWait(context, command); + const Triangle legacy{.a = glm::ivec2(300, 800), + .b = glm::ivec2(500, 100), + .c = glm::ivec2(700, 800)}; + original.rasterized.MapData([&legacy](void* data) { + const int* pixels = static_cast(data); + for (int y = 0; y < 1000; ++y) { + for (int x = 0; x < 1000; ++x) { + ASSERT_EQ(pixels[y * 1000 + x], Covers(legacy, x, y) ? 1 : 0); + } + } + }); + + EXPECT_THROW((example::ComputeBarycentric(&context, 0, 1)), + std::invalid_argument); + EXPECT_THROW((example::ComputeBarycentric(&context, 1, 16385)), + std::invalid_argument); + example::ComputeBarycentric single(&context, 1, 1); + single.Init(); + command.BeginCommandBufferWithReset(); + Triangle point{.a = glm::ivec2(0), .b = glm::ivec2(0), .c = glm::ivec2(0)}; + point.a.x = 16384; + EXPECT_THROW(single.Run(command.buffer(), point), std::invalid_argument); + point.a.x = -16384; + EXPECT_THROW(single.Run(command.buffer(), point), std::invalid_argument); + point.a.x = 0; + single.Run(command.buffer(), point); + SubmitAndWait(context, command); + single.rasterized.MapData( + [](void* data) { EXPECT_EQ(*static_cast(data), 1); }); + + single.rasterized.MapData([](void* data) { *static_cast(data) = 0; }); + command.BeginCommandBufferWithReset(); + single.Run(command.buffer(), Triangle{.a = glm::ivec2(-16383, -16383), + .b = glm::ivec2(16383, -16383), + .c = glm::ivec2(-16383, 16383)}); + SubmitAndWait(context, command); + single.rasterized.MapData( + [](void* data) { EXPECT_EQ(*static_cast(data), 1); }); +} + +} +} +} diff --git a/vulkan/include/VulkanBase.h b/vulkan/include/VulkanBase.h index 41f0b57..f7a5dee 100644 --- a/vulkan/include/VulkanBase.h +++ b/vulkan/include/VulkanBase.h @@ -34,6 +34,7 @@ class VulkanBase { protected: virtual std::vector GetBindingInfo() const = 0; + virtual std::vector GetPushConstantRanges() const; virtual void CreatePipeline() = 0; protected: @@ -48,9 +49,9 @@ class VulkanBase { const VkSampler& sampler); VulkanContext* context_ = nullptr; - VkDescriptorSetLayout descriptor_set_layout_; - VkDescriptorPool descriptor_pool_; - VkDescriptorSet descriptor_set_; + VkDescriptorSetLayout descriptor_set_layout_ = VK_NULL_HANDLE; + VkDescriptorPool descriptor_pool_ = VK_NULL_HANDLE; + VkDescriptorSet descriptor_set_ = VK_NULL_HANDLE; std::vector buffer_infos_; std::vector image_infos_; diff --git a/vulkan/src/VulkanBase.cpp b/vulkan/src/VulkanBase.cpp index 681fd85..c250774 100644 --- a/vulkan/src/VulkanBase.cpp +++ b/vulkan/src/VulkanBase.cpp @@ -1,5 +1,7 @@ #include "VulkanBase.h" +#include + namespace core { namespace vulkan { @@ -15,6 +17,23 @@ VulkanBase::~VulkanBase() { } void VulkanBase::Init() { + const std::vector push_constant_ranges = + GetPushConstantRanges(); + if (!push_constant_ranges.empty()) { + VkPhysicalDeviceProperties properties{}; + vkGetPhysicalDeviceProperties(context_->physical_device, &properties); + const uint32_t limit = properties.limits.maxPushConstantsSize; + VkShaderStageFlags used_stages = 0; + for (const VkPushConstantRange& range : push_constant_ranges) { + if (range.stageFlags == 0 || (range.stageFlags & used_stages) != 0 || + range.size == 0 || range.offset % 4 != 0 || range.size % 4 != 0 || + range.offset >= limit || range.size > limit - range.offset) { + throw std::invalid_argument("Invalid push constant range"); + } + used_stages |= range.stageFlags; + } + } + // 1. Create descriptor set layout VkDescriptorSetLayoutCreateInfo layout_info{}; layout_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; @@ -53,8 +72,9 @@ void VulkanBase::Init() { pipeline_layout_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipeline_layout_info.setLayoutCount = 1; pipeline_layout_info.pSetLayouts = &descriptor_set_layout_; - pipeline_layout_info.pushConstantRangeCount = 0; - pipeline_layout_info.pPushConstantRanges = nullptr; + pipeline_layout_info.pushConstantRangeCount = + static_cast(push_constant_ranges.size()); + pipeline_layout_info.pPushConstantRanges = push_constant_ranges.data(); VK_CHECK(vkCreatePipelineLayout(context_->logical_device, &pipeline_layout_info, nullptr, &pipeline_layout)); @@ -62,6 +82,10 @@ void VulkanBase::Init() { CreatePipeline(); } +std::vector VulkanBase::GetPushConstantRanges() const { + return {}; +} + std::vector VulkanBase::CreateDescriptorLayoutBindings() const { std::vector bindings; const auto binding_info = GetBindingInfo();