547 lines
22 KiB
C++
547 lines
22 KiB
C++
/* Copyright (c) 2023-2025, Mobica Limited
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 the "License";
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "dynamic_line_rasterization.h"
|
|
|
|
DynamicLineRasterization::DynamicLineRasterization()
|
|
{
|
|
add_device_extension(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
|
|
add_device_extension(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
|
|
add_device_extension(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME);
|
|
}
|
|
|
|
DynamicLineRasterization::~DynamicLineRasterization()
|
|
{
|
|
if (has_device())
|
|
{
|
|
vkDestroyPipelineLayout(get_device().get_handle(), pipeline_layout, nullptr);
|
|
|
|
vkDestroyPipeline(get_device().get_handle(), pipelines.object, nullptr);
|
|
vkDestroyPipeline(get_device().get_handle(), pipelines.grid, nullptr);
|
|
|
|
vkDestroyDescriptorSetLayout(get_device().get_handle(), descriptor_set_layout, nullptr);
|
|
vkDestroyDescriptorPool(get_device().get_handle(), descriptor_pool, nullptr);
|
|
}
|
|
}
|
|
|
|
bool DynamicLineRasterization::prepare(const vkb::ApplicationOptions &options)
|
|
{
|
|
if (!ApiVulkanSample::prepare(options))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
camera.type = vkb::CameraType::LookAt;
|
|
camera.set_position({0.0f, 1.0f, -5.0f});
|
|
camera.set_rotation({-15.0f, 15.0f, 0.0f});
|
|
camera.set_perspective(45.0f, static_cast<float>(width) / static_cast<float>(height), 128.0f, 0.1f);
|
|
|
|
prepare_uniform_buffers();
|
|
prepare_scene();
|
|
setup_descriptor_pool();
|
|
create_descriptor_set_layout();
|
|
create_descriptor_set();
|
|
create_pipelines();
|
|
build_command_buffers();
|
|
|
|
prepared = true;
|
|
|
|
return true;
|
|
}
|
|
|
|
void DynamicLineRasterization::prepare_scene()
|
|
{
|
|
std::vector<glm::vec3> vertices = {
|
|
{-1.0f, -1.0f, 1.0f},
|
|
{1.0f, -1.0f, 1.0f},
|
|
{1.0f, 1.0f, 1.0f},
|
|
{-1.0f, 1.0f, 1.0f},
|
|
|
|
{-1.0f, -1.0f, -1.0f},
|
|
{1.0f, -1.0f, -1.0f},
|
|
{1.0f, 1.0f, -1.0f},
|
|
{-1.0f, 1.0f, -1.0f}};
|
|
|
|
std::vector<uint32_t> cube_indices = {
|
|
0, 1, 2,
|
|
2, 3, 0,
|
|
|
|
4, 5, 6,
|
|
6, 7, 4,
|
|
|
|
0, 3, 7,
|
|
7, 4, 0,
|
|
|
|
1, 5, 6,
|
|
6, 2, 1,
|
|
|
|
3, 2, 6,
|
|
6, 7, 3,
|
|
|
|
0, 4, 5,
|
|
5, 1, 0};
|
|
|
|
// Indices of the edges of the cube
|
|
std::vector<uint32_t> edges_indices = {
|
|
0, 1,
|
|
1, 2,
|
|
2, 3,
|
|
3, 0,
|
|
|
|
4, 5,
|
|
5, 6,
|
|
6, 7,
|
|
7, 4,
|
|
|
|
0, 4,
|
|
1, 5,
|
|
2, 6,
|
|
3, 7};
|
|
|
|
cube_index_count = static_cast<uint32_t>(cube_indices.size());
|
|
edges_index_count = static_cast<uint32_t>(edges_indices.size());
|
|
uint32_t vertex_buffer_size = static_cast<uint32_t>(vertices.size() * sizeof(glm::vec3));
|
|
uint32_t cube_index_buffer_size = static_cast<uint32_t>(cube_indices.size() * sizeof(uint32_t));
|
|
uint32_t edges_index_buffer_size = static_cast<uint32_t>(edges_indices.size() * sizeof(uint32_t));
|
|
|
|
vertex_buffer = std::make_unique<vkb::core::BufferC>(get_device(),
|
|
vertex_buffer_size,
|
|
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
|
|
VMA_MEMORY_USAGE_CPU_TO_GPU);
|
|
vertex_buffer->update(vertices.data(), vertex_buffer_size);
|
|
|
|
cube_index_buffer = std::make_unique<vkb::core::BufferC>(get_device(),
|
|
cube_index_buffer_size,
|
|
VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
|
|
VMA_MEMORY_USAGE_CPU_TO_GPU);
|
|
cube_index_buffer->update(cube_indices.data(), cube_index_buffer_size);
|
|
|
|
edges_index_buffer = std::make_unique<vkb::core::BufferC>(get_device(),
|
|
edges_index_buffer_size,
|
|
VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
|
|
VMA_MEMORY_USAGE_CPU_TO_GPU);
|
|
edges_index_buffer->update(edges_indices.data(), edges_index_buffer_size);
|
|
|
|
fill_color = glm::vec4(0.957f, 0.384f, 0.024f, 0.1f);
|
|
edge_color = glm::vec4(0.957f, 0.384f, 0.024f, 1.0f);
|
|
|
|
// Fill the first half of the stipple array with 'true' values for the initial stipple pattern.
|
|
std::fill(gui_settings.stipple_pattern_arr.begin(), gui_settings.stipple_pattern_arr.begin() + 8, true);
|
|
gui_settings.stipple_pattern = array_to_uint16(gui_settings.stipple_pattern_arr);
|
|
}
|
|
|
|
void DynamicLineRasterization::setup_descriptor_pool()
|
|
{
|
|
std::vector<VkDescriptorPoolSize> pool_sizes = {
|
|
vkb::initializers::descriptor_pool_size(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 2u),
|
|
};
|
|
|
|
VkDescriptorPoolCreateInfo descriptor_pool_create_info =
|
|
vkb::initializers::descriptor_pool_create_info(
|
|
static_cast<uint32_t>(pool_sizes.size()),
|
|
pool_sizes.data(),
|
|
static_cast<uint32_t>(pool_sizes.size()));
|
|
VK_CHECK(vkCreateDescriptorPool(get_device().get_handle(), &descriptor_pool_create_info, nullptr, &descriptor_pool));
|
|
}
|
|
|
|
void DynamicLineRasterization::create_pipelines()
|
|
{
|
|
VkPipelineInputAssemblyStateCreateInfo input_assembly_state =
|
|
vkb::initializers::pipeline_input_assembly_state_create_info(
|
|
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
|
|
0,
|
|
VK_FALSE);
|
|
|
|
VkPipelineRasterizationStateCreateInfo rasterization_state =
|
|
vkb::initializers::pipeline_rasterization_state_create_info(
|
|
VK_POLYGON_MODE_FILL,
|
|
VK_CULL_MODE_NONE,
|
|
VK_FRONT_FACE_COUNTER_CLOCKWISE,
|
|
0);
|
|
|
|
VkPipelineColorBlendAttachmentState blend_attachment_state =
|
|
vkb::initializers::pipeline_color_blend_attachment_state(
|
|
VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT,
|
|
VK_TRUE);
|
|
|
|
blend_attachment_state.colorBlendOp = VK_BLEND_OP_ADD;
|
|
blend_attachment_state.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
|
|
blend_attachment_state.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
|
blend_attachment_state.alphaBlendOp = VK_BLEND_OP_ADD;
|
|
blend_attachment_state.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
|
|
blend_attachment_state.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
|
|
|
|
VkPipelineColorBlendStateCreateInfo color_blend_state =
|
|
vkb::initializers::pipeline_color_blend_state_create_info(
|
|
1,
|
|
&blend_attachment_state);
|
|
|
|
VkPipelineDepthStencilStateCreateInfo depth_stencil_state =
|
|
vkb::initializers::pipeline_depth_stencil_state_create_info(
|
|
VK_FALSE,
|
|
VK_FALSE,
|
|
VK_COMPARE_OP_NEVER);
|
|
|
|
VkPipelineViewportStateCreateInfo viewport_state =
|
|
vkb::initializers::pipeline_viewport_state_create_info(1, 1, 0);
|
|
|
|
VkPipelineMultisampleStateCreateInfo multisample_state =
|
|
vkb::initializers::pipeline_multisample_state_create_info(
|
|
VK_SAMPLE_COUNT_1_BIT,
|
|
0);
|
|
|
|
std::vector<VkDynamicState> dynamic_state_enables = {
|
|
VK_DYNAMIC_STATE_VIEWPORT,
|
|
VK_DYNAMIC_STATE_SCISSOR,
|
|
VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY,
|
|
VK_DYNAMIC_STATE_POLYGON_MODE_EXT,
|
|
VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT,
|
|
VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT,
|
|
VK_DYNAMIC_STATE_LINE_STIPPLE_EXT,
|
|
VK_DYNAMIC_STATE_LINE_WIDTH};
|
|
|
|
VkPipelineDynamicStateCreateInfo dynamic_state =
|
|
vkb::initializers::pipeline_dynamic_state_create_info(
|
|
dynamic_state_enables.data(),
|
|
static_cast<uint32_t>(dynamic_state_enables.size()),
|
|
0);
|
|
|
|
const std::vector<VkVertexInputBindingDescription> vertex_input_bindings = {
|
|
vkb::initializers::vertex_input_binding_description(0, sizeof(glm::vec3), VK_VERTEX_INPUT_RATE_VERTEX),
|
|
};
|
|
const std::vector<VkVertexInputAttributeDescription> vertex_input_attributes = {
|
|
vkb::initializers::vertex_input_attribute_description(0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0),
|
|
};
|
|
|
|
VkPipelineVertexInputStateCreateInfo vertex_input_state = vkb::initializers::pipeline_vertex_input_state_create_info();
|
|
vertex_input_state.vertexBindingDescriptionCount = static_cast<uint32_t>(vertex_input_bindings.size());
|
|
vertex_input_state.pVertexBindingDescriptions = vertex_input_bindings.data();
|
|
vertex_input_state.vertexAttributeDescriptionCount = static_cast<uint32_t>(vertex_input_attributes.size());
|
|
vertex_input_state.pVertexAttributeDescriptions = vertex_input_attributes.data();
|
|
|
|
std::array<VkPipelineShaderStageCreateInfo, 2> shader_stages{};
|
|
shader_stages[0] = load_shader("dynamic_line_rasterization", "base.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
|
|
shader_stages[1] = load_shader("dynamic_line_rasterization", "base.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
|
|
|
|
VkGraphicsPipelineCreateInfo graphics_create{VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO};
|
|
graphics_create.pNext = VK_NULL_HANDLE;
|
|
graphics_create.renderPass = render_pass;
|
|
graphics_create.pInputAssemblyState = &input_assembly_state;
|
|
graphics_create.pRasterizationState = &rasterization_state;
|
|
graphics_create.pColorBlendState = &color_blend_state;
|
|
graphics_create.pMultisampleState = &multisample_state;
|
|
graphics_create.pViewportState = &viewport_state;
|
|
graphics_create.pDepthStencilState = &depth_stencil_state;
|
|
graphics_create.pDynamicState = &dynamic_state;
|
|
graphics_create.pVertexInputState = &vertex_input_state;
|
|
graphics_create.pTessellationState = VK_NULL_HANDLE;
|
|
graphics_create.stageCount = 2;
|
|
graphics_create.pStages = shader_stages.data();
|
|
graphics_create.layout = pipeline_layout;
|
|
|
|
VK_CHECK(vkCreateGraphicsPipelines(get_device().get_handle(),
|
|
pipeline_cache,
|
|
1,
|
|
&graphics_create,
|
|
VK_NULL_HANDLE,
|
|
&pipelines.object));
|
|
|
|
shader_stages[0] = load_shader("dynamic_line_rasterization", "grid.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
|
|
shader_stages[1] = load_shader("dynamic_line_rasterization", "grid.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
|
|
graphics_create.pStages = shader_stages.data();
|
|
vertex_input_state = vkb::initializers::pipeline_vertex_input_state_create_info();
|
|
graphics_create.pVertexInputState = &vertex_input_state;
|
|
|
|
vkCreateGraphicsPipelines(get_device().get_handle(), pipeline_cache, 1, &graphics_create, VK_NULL_HANDLE, &pipelines.grid);
|
|
}
|
|
|
|
void DynamicLineRasterization::prepare_uniform_buffers()
|
|
{
|
|
camera_ubo = std::make_unique<vkb::core::BufferC>(get_device(), sizeof(CameraUbo), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);
|
|
}
|
|
|
|
void DynamicLineRasterization::update_uniform_buffers()
|
|
{
|
|
CameraUbo cam;
|
|
cam.model = glm::mat4(1.0f);
|
|
cam.model = glm::translate(cam.model, glm::vec3(0.0f));
|
|
cam.view = camera.matrices.view;
|
|
cam.projection = camera.matrices.perspective;
|
|
cam.viewProjectionInverse = glm::inverse(cam.projection * cam.view);
|
|
|
|
camera_ubo->convert_and_update(cam);
|
|
|
|
rebuild_command_buffers();
|
|
}
|
|
|
|
void DynamicLineRasterization::create_descriptor_set()
|
|
{
|
|
VkDescriptorSetAllocateInfo alloc_info = vkb::initializers::descriptor_set_allocate_info(descriptor_pool, &descriptor_set_layout, 1u);
|
|
VK_CHECK(vkAllocateDescriptorSets(get_device().get_handle(), &alloc_info, &descriptor_set));
|
|
|
|
VkDescriptorBufferInfo buffer_descriptor = create_descriptor(*camera_ubo);
|
|
|
|
std::vector<VkWriteDescriptorSet> write_descriptor_sets = {
|
|
vkb::initializers::write_descriptor_set(descriptor_set, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0u, &buffer_descriptor),
|
|
};
|
|
|
|
vkUpdateDescriptorSets(get_device().get_handle(), static_cast<uint32_t>(write_descriptor_sets.size()), write_descriptor_sets.data(), 0u, nullptr);
|
|
}
|
|
|
|
void DynamicLineRasterization::create_descriptor_set_layout()
|
|
{
|
|
std::vector<VkDescriptorSetLayoutBinding> set_layout_bindings = {
|
|
vkb::initializers::descriptor_set_layout_binding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT, 0u),
|
|
vkb::initializers::descriptor_set_layout_binding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_FRAGMENT_BIT, 1u)};
|
|
|
|
VkDescriptorSetLayoutCreateInfo descriptor_set_layout_create_info = vkb::initializers::descriptor_set_layout_create_info(set_layout_bindings);
|
|
VK_CHECK(vkCreateDescriptorSetLayout(get_device().get_handle(), &descriptor_set_layout_create_info, nullptr, &descriptor_set_layout));
|
|
|
|
VkPushConstantRange push_constant_range =
|
|
vkb::initializers::push_constant_range(VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(glm::vec4), 0);
|
|
|
|
VkPipelineLayoutCreateInfo pipeline_layout_create_info = vkb::initializers::pipeline_layout_create_info(&descriptor_set_layout);
|
|
|
|
pipeline_layout_create_info.pushConstantRangeCount = 1;
|
|
pipeline_layout_create_info.pPushConstantRanges = &push_constant_range;
|
|
|
|
VK_CHECK(vkCreatePipelineLayout(get_device().get_handle(), &pipeline_layout_create_info, nullptr, &pipeline_layout));
|
|
}
|
|
|
|
void DynamicLineRasterization::draw()
|
|
{
|
|
ApiVulkanSample::prepare_frame();
|
|
submit_info.commandBufferCount = 1;
|
|
submit_info.pCommandBuffers = &draw_cmd_buffers[current_buffer];
|
|
|
|
VK_CHECK(vkQueueSubmit(queue, 1u, &submit_info, VK_NULL_HANDLE));
|
|
ApiVulkanSample::submit_frame();
|
|
|
|
VkPipelineStageFlags wait_stage_mask = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
|
|
}
|
|
|
|
void DynamicLineRasterization::render(float delta_time)
|
|
{
|
|
if (!prepared)
|
|
{
|
|
return;
|
|
}
|
|
|
|
draw();
|
|
|
|
if (camera.updated)
|
|
{
|
|
update_uniform_buffers();
|
|
}
|
|
}
|
|
|
|
void DynamicLineRasterization::build_command_buffers()
|
|
{
|
|
VkCommandBufferBeginInfo command_buffer_begin_info = vkb::initializers::command_buffer_begin_info();
|
|
|
|
std::array<VkClearValue, 2> clear_values;
|
|
clear_values[0].color = {{0.05f, 0.05f, 0.05f, 1.0f}};
|
|
clear_values[1].depthStencil = {0.0f, 0u};
|
|
|
|
VkRenderPassBeginInfo render_pass_begin_info = vkb::initializers::render_pass_begin_info();
|
|
render_pass_begin_info.renderPass = render_pass;
|
|
render_pass_begin_info.renderArea.extent.width = width;
|
|
render_pass_begin_info.renderArea.extent.height = height;
|
|
render_pass_begin_info.clearValueCount = static_cast<uint32_t>(clear_values.size());
|
|
render_pass_begin_info.pClearValues = clear_values.data();
|
|
|
|
for (uint32_t i = 0u; i < draw_cmd_buffers.size(); ++i)
|
|
{
|
|
render_pass_begin_info.framebuffer = framebuffers[i];
|
|
auto &cmd_buff = draw_cmd_buffers[i];
|
|
|
|
VK_CHECK(vkBeginCommandBuffer(cmd_buff, &command_buffer_begin_info));
|
|
|
|
vkCmdBeginRenderPass(cmd_buff, &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE);
|
|
|
|
VkViewport viewport = vkb::initializers::viewport(static_cast<float>(width), static_cast<float>(height), 0.0f, 1.0f);
|
|
vkCmdSetViewport(cmd_buff, 0u, 1u, &viewport);
|
|
|
|
VkRect2D scissor = vkb::initializers::rect2D(width, height, 0, 0);
|
|
vkCmdSetScissor(cmd_buff, 0u, 1u, &scissor);
|
|
|
|
vkCmdBindDescriptorSets(cmd_buff, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout, 0u, 1u, &descriptor_set, 0u, nullptr);
|
|
|
|
// While dynamic parameterization is not utilized for the grid, it should be called before the first draw command to prevent validation layer warnings.
|
|
vkCmdSetLineRasterizationModeEXT(cmd_buff, static_cast<VkLineRasterizationModeEXT>(gui_settings.selected_rasterization_mode));
|
|
vkCmdSetLineWidth(cmd_buff, gui_settings.line_width);
|
|
vkCmdSetLineStippleEnableEXT(cmd_buff, static_cast<VkBool32>(gui_settings.stipple_enabled));
|
|
vkCmdSetLineStippleEXT(cmd_buff, gui_settings.stipple_factor, gui_settings.stipple_pattern);
|
|
vkCmdSetPrimitiveTopologyEXT(cmd_buff, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST);
|
|
vkCmdSetPolygonModeEXT(cmd_buff, VK_POLYGON_MODE_FILL);
|
|
|
|
// Draw the grid
|
|
if (gui_settings.grid_enabled)
|
|
{
|
|
vkCmdBindPipeline(cmd_buff, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.grid);
|
|
vkCmdDraw(cmd_buff, 6, 1, 0, 0);
|
|
}
|
|
|
|
vkCmdBindPipeline(cmd_buff, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.object);
|
|
VkDeviceSize offsets[1] = {0};
|
|
vkCmdBindVertexBuffers(cmd_buff, 0, 1, vertex_buffer->get(), offsets);
|
|
|
|
// Fill the cube
|
|
if (gui_settings.fill_enabled)
|
|
{
|
|
vkCmdBindIndexBuffer(cmd_buff, cube_index_buffer->get_handle(), 0, VK_INDEX_TYPE_UINT32);
|
|
vkCmdPushConstants(cmd_buff, pipeline_layout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(glm::vec4), &fill_color);
|
|
vkCmdSetPrimitiveTopologyEXT(cmd_buff, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST);
|
|
vkCmdSetPolygonModeEXT(draw_cmd_buffers[i], VK_POLYGON_MODE_FILL);
|
|
|
|
vkCmdDrawIndexed(cmd_buff, cube_index_count, 1, 0, 0, 0);
|
|
}
|
|
|
|
// Draw the cube edges
|
|
vkCmdBindIndexBuffer(cmd_buff, edges_index_buffer->get_handle(), 0, VK_INDEX_TYPE_UINT32);
|
|
vkCmdPushConstants(cmd_buff, pipeline_layout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(glm::vec4), &edge_color);
|
|
vkCmdSetPrimitiveTopologyEXT(cmd_buff, VK_PRIMITIVE_TOPOLOGY_LINE_LIST);
|
|
vkCmdSetPolygonModeEXT(cmd_buff, VK_POLYGON_MODE_LINE);
|
|
|
|
vkCmdDrawIndexed(cmd_buff, edges_index_count, 1, 0, 0, 0);
|
|
|
|
draw_ui(cmd_buff);
|
|
|
|
vkCmdEndRenderPass(cmd_buff);
|
|
|
|
VK_CHECK(vkEndCommandBuffer(cmd_buff));
|
|
}
|
|
}
|
|
|
|
void DynamicLineRasterization::request_gpu_features(vkb::PhysicalDevice &gpu)
|
|
{
|
|
REQUEST_REQUIRED_FEATURE(gpu, VkPhysicalDeviceLineRasterizationFeaturesEXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, smoothLines);
|
|
REQUEST_REQUIRED_FEATURE(gpu,
|
|
VkPhysicalDeviceLineRasterizationFeaturesEXT,
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
|
|
stippledSmoothLines);
|
|
REQUEST_REQUIRED_FEATURE(gpu,
|
|
VkPhysicalDeviceLineRasterizationFeaturesEXT,
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
|
|
bresenhamLines);
|
|
REQUEST_REQUIRED_FEATURE(gpu,
|
|
VkPhysicalDeviceLineRasterizationFeaturesEXT,
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
|
|
stippledBresenhamLines);
|
|
REQUEST_REQUIRED_FEATURE(gpu,
|
|
VkPhysicalDeviceLineRasterizationFeaturesEXT,
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
|
|
rectangularLines);
|
|
REQUEST_REQUIRED_FEATURE(gpu,
|
|
VkPhysicalDeviceLineRasterizationFeaturesEXT,
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
|
|
stippledRectangularLines);
|
|
|
|
REQUEST_REQUIRED_FEATURE(gpu,
|
|
VkPhysicalDeviceExtendedDynamicStateFeaturesEXT,
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT,
|
|
extendedDynamicState);
|
|
|
|
REQUEST_REQUIRED_FEATURE(gpu,
|
|
VkPhysicalDeviceExtendedDynamicState3FeaturesEXT,
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT,
|
|
extendedDynamicState3PolygonMode);
|
|
REQUEST_REQUIRED_FEATURE(gpu,
|
|
VkPhysicalDeviceExtendedDynamicState3FeaturesEXT,
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT,
|
|
extendedDynamicState3LineRasterizationMode);
|
|
REQUEST_REQUIRED_FEATURE(gpu,
|
|
VkPhysicalDeviceExtendedDynamicState3FeaturesEXT,
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT,
|
|
extendedDynamicState3LineStippleEnable);
|
|
|
|
{
|
|
auto &features = gpu.get_mutable_requested_features();
|
|
features.fillModeNonSolid = VK_TRUE;
|
|
features.wideLines = VK_TRUE;
|
|
}
|
|
}
|
|
|
|
void DynamicLineRasterization::on_update_ui_overlay(vkb::Drawer &drawer)
|
|
{
|
|
auto build_command_buffers_when = [this](bool drawer_action) {
|
|
if (drawer_action)
|
|
{
|
|
rebuild_command_buffers();
|
|
}
|
|
};
|
|
|
|
auto uint16_to_hex_string = [](const char *caption, uint16_t value) {
|
|
std::stringstream stream;
|
|
stream << caption << std::hex << value;
|
|
return stream.str();
|
|
};
|
|
|
|
if (drawer.header("Primitive options"))
|
|
{
|
|
build_command_buffers_when(drawer.checkbox("Fill", &gui_settings.fill_enabled));
|
|
build_command_buffers_when(drawer.checkbox("Grid", &gui_settings.grid_enabled));
|
|
build_command_buffers_when(drawer.combo_box("Rasterization mode", &gui_settings.selected_rasterization_mode, gui_settings.rasterization_mode_names));
|
|
build_command_buffers_when(drawer.slider_float("Line width", &gui_settings.line_width, 1.0f, 64.0f));
|
|
build_command_buffers_when(drawer.checkbox("Stipple enabled", &gui_settings.stipple_enabled));
|
|
// The stipple factor has a maximum value of 256. Here, a limit of 64 has been chosen to achieve a scroll step equal to 1.
|
|
build_command_buffers_when(drawer.slider_int("Stipple factor", &gui_settings.stipple_factor, 1, 64));
|
|
drawer.text(uint16_to_hex_string("Stipple pattern: ", gui_settings.stipple_pattern).c_str());
|
|
|
|
for (int i = 0; i < 16; ++i)
|
|
{
|
|
ImGui::PushID(i);
|
|
if (drawer.checkbox("", &(gui_settings.stipple_pattern_arr[i])))
|
|
{
|
|
gui_settings.stipple_pattern = array_to_uint16(gui_settings.stipple_pattern_arr);
|
|
|
|
rebuild_command_buffers();
|
|
}
|
|
ImGui::PopID();
|
|
if (i % 8 != 7)
|
|
{
|
|
ImGui::SameLine();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
uint16_t DynamicLineRasterization::array_to_uint16(const std::array<bool, 16> &array)
|
|
{
|
|
uint16_t result = 0;
|
|
for (int i = 0; i < 16; ++i)
|
|
{
|
|
if (array[i])
|
|
{
|
|
result |= (1 << i);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool DynamicLineRasterization::resize(const uint32_t width, const uint32_t height)
|
|
{
|
|
ApiVulkanSample::resize(width, height);
|
|
update_uniform_buffers();
|
|
return true;
|
|
}
|
|
|
|
std::unique_ptr<vkb::VulkanSampleC> create_dynamic_line_rasterization()
|
|
{
|
|
return std::make_unique<DynamicLineRasterization>();
|
|
}
|