Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
10 changes: 5 additions & 5 deletions examples/vulkan/ComputeBarycentricRasterizer/Barycentric.comp
Original file line number Diff line number Diff line change
@@ -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;

Expand Down
87 changes: 59 additions & 28 deletions examples/vulkan/ComputeBarycentricRasterizer/ComputeBarycentric.cpp
Original file line number Diff line number Diff line change
@@ -1,56 +1,86 @@
#include "ComputeBarycentric.h"

#include <cstring>
#include <stdexcept>

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<int, 1> mat(uniform_data_.height, uniform_data_.width);
mat.Fill(0);
memcpy(data, mat.data(), mat.total() * sizeof(int));
std::memset(data, 0, static_cast<size_t>(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<uint32_t>(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<uint32_t>(sizeof(parameters)), &parameters);

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<uint32_t>(width_) + 15) / 16;
const uint32_t group_y = (static_cast<uint32_t>(height_) + 15) / 16;
vkCmdDispatch(command_buffer, group_x, group_y, 1);
}

std::vector<core::vulkan::BindingInfo> 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<VkPushConstantRange> ComputeBarycentric::GetPushConstantRanges()
const {
return {{.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
.offset = 0,
.size = static_cast<uint32_t>(sizeof(PushConstants))}};
}

const std::vector<uint32_t>& ComputeBarycentric::LoadShaderCode() const {
Expand All @@ -61,7 +91,8 @@ const std::vector<uint32_t>& ComputeBarycentric::LoadShaderCode() const {
}

void ComputeBarycentric::CreateBuffers() {
const VkDeviceSize size = uniform_data_.width * uniform_data_.height * sizeof(int);
const VkDeviceSize size = static_cast<VkDeviceSize>(width_) *
static_cast<VkDeviceSize>(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);
Expand Down
24 changes: 17 additions & 7 deletions examples/vulkan/ComputeBarycentricRasterizer/ComputeBarycentric.h
Original file line number Diff line number Diff line change
Expand Up @@ -2,7 +2,6 @@

#include <iostream>

#include "Mat.h"
#include "VulkanBuffer.h"
#include "VulkanCompute.h"
#include "glm/glm.hpp"
Expand All @@ -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<core::vulkan::BindingInfo> GetBindingInfo() const override;
std::vector<VkPushConstantRange> GetPushConstantRanges() const override;
const std::vector<uint32_t>& 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
12 changes: 12 additions & 0 deletions examples/vulkan/ComputeBarycentricRasterizer/main.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand Down
10 changes: 9 additions & 1 deletion tests/vulkan/CMakeLists.txt
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
Loading
Loading