xsl/Vulkan-Samples
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
xsl
2025-09-04 10:54:47 +08:00
commit 6bc8f61b18
1808 changed files with 208268 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
samples/extensions/dynamic_line_rasterization/CMakeLists.txt
+37
View File
@@ -0,0 +1,37 @@
# Copyright (c) 2023-2024, 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.
#
get_filename_component(FOLDER_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
get_filename_component(PARENT_DIR ${CMAKE_CURRENT_LIST_DIR} PATH)
get_filename_component(CATEGORY_NAME ${PARENT_DIR} NAME)
add_sample(
ID ${FOLDER_NAME}
CATEGORY ${CATEGORY_NAME}
AUTHOR "Khronos"
NAME "Dynamic line rasterization"
DESCRIPTION "Dynamic line rasterization options available in the VK_EXT_line_rasterization and VK_EXT_extended_dynamic_state3 extensions"
SHADER_FILES_GLSL
"dynamic_line_rasterization/glsl/base.vert"
"dynamic_line_rasterization/glsl/base.frag"
"dynamic_line_rasterization/glsl/grid.vert"
"dynamic_line_rasterization/glsl/grid.frag"
SHADER_FILES_HLSL
"dynamic_line_rasterization/hlsl/base.vert.hlsl"
"dynamic_line_rasterization/hlsl/base.frag.hlsl"
"dynamic_line_rasterization/hlsl/grid.vert.hlsl"
"dynamic_line_rasterization/hlsl/grid.frag.hlsl")
samples/extensions/dynamic_line_rasterization/README.adoc
+68
View File
@@ -0,0 +1,68 @@
////
- Copyright (c) 2023-2024, 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.
-
////
= Dynamic line rasterization
ifdef::site-gen-antora[]
TIP: The source for this sample can be found in the https://github.com/KhronosGroup/Vulkan-Samples/tree/main/samples/extensions/dynamic_line_rasterization[Khronos Vulkan samples github repository].
endif::[]
image::./screenshot.png[]
== Overview
This sample demonstrates functions from various extensions related to dynamic line rasterization. These functions can be useful for developing CAD applications.
* From the `VK_EXT_line_rasterization` extension:
** `vkCmdSetLineStippleEXT` - sets the stipple pattern.
* From the `VK_EXT_extended_dynamic_state3` extension:
** `vkCmdSetPolygonModeEXT` - sets how defined primitives should be rasterized.
** `vkCmdSetLineRasterizationModeEXT` - sets the algorithm for line rasterization.
** `vkCmdSetLineStippleEnableEXT` - toggles stippling for lines.
* And also from the core Vulkan:
** `vkCmdSetLineWidth` - sets the line width.
** `vkCmdSetPrimitiveTopologyEXT` - defines which type of primitives is being drawn.
== The sample
Dynamic line rasterization contains a wireframed cube whose appearance can be modified by the user. The cube edges and filling are rendered in a single pipeline, using a different set of indices. The `vkCmdSetPrimitiveTopologyEXT` and `vkCmdSetPolygonModeEXT` functions are used to change the way they are rendered.
Users can modify the line width (`vkCmdSetLineWidth`) and choose how the line is drawn (`vkCmdSetLineRasterizationModeEXT`). The sample also demonstrates the ability to stipple the line. Stippling is defined by two variables:
** `lineStipplePattern` - a `uint16_t` where each bit represents whether a point on the line is colored (1) or transparent (0).
** `lineStippleFactor` - a factor used to determine how many consecutive points are affected by a single pattern bit.
The sample also contains a grid rendered beneath the cube using a different pipeline. This grid represents another approach to line rasterization based on the fragment shader. Consequently, the appearance of the gridlines cannot be modified by the user.
== Credits
The infinite grid shader is based on the code from the https://asliceofrendering.com/scene%20helper/2020/01/05/InfiniteGrid/[asliceofrendering.com] blog.
== Documentation links
https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkCmdSetLineStippleEXT.html
https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkCmdSetPolygonModeEXT.html
https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkCmdSetLineRasterizationModeEXT.html
https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkCmdSetLineStippleEnableEXT.html
https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkCmdSetLineWidth.html
samples/extensions/dynamic_line_rasterization/dynamic_line_rasterization.cpp
+546
View File
@@ -0,0 +1,546 @@
/* 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>();
}
samples/extensions/dynamic_line_rasterization/dynamic_line_rasterization.h
+92
View File
@@ -0,0 +1,92 @@
/* Copyright (c) 2023-2024, 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.
*/
#pragma once
#include "api_vulkan_sample.h"
class DynamicLineRasterization : public ApiVulkanSample
{
public:
DynamicLineRasterization();
virtual ~DynamicLineRasterization();
void render(float delta_time) override;
void build_command_buffers() override;
bool prepare(const vkb::ApplicationOptions &options) override;
void request_gpu_features(vkb::PhysicalDevice &gpu) override;
void on_update_ui_overlay(vkb::Drawer &drawer) override;
bool resize(const uint32_t width, const uint32_t height) override;
private:
struct CameraUbo
{
alignas(16) glm::mat4 projection;
alignas(16) glm::mat4 view;
alignas(16) glm::mat4 model;
alignas(16) glm::mat4 viewProjectionInverse;
};
struct
{
VkPipeline grid;
VkPipeline object;
} pipelines;
VkDescriptorSet descriptor_set;
VkDescriptorSetLayout descriptor_set_layout;
VkPipelineLayout pipeline_layout;
VkDescriptorPool descriptor_pool;
std::unique_ptr<vkb::core::BufferC> camera_ubo;
std::unique_ptr<vkb::core::BufferC> vertex_buffer;
std::unique_ptr<vkb::core::BufferC> cube_index_buffer, edges_index_buffer;
glm::vec4 fill_color, edge_color;
uint32_t cube_index_count, edges_index_count;
struct
{
bool fill_enabled = true;
bool grid_enabled = true;
int selected_rasterization_mode = 0;
std::vector<std::string> rasterization_mode_names = {"DEFAULT", "RECT", "BRESENHAM", "SMOOTH"};
bool stipple_enabled = true;
float line_width = 1.0f;
int32_t stipple_factor = 1;
uint16_t stipple_pattern;
std::array<bool, 16> stipple_pattern_arr = {};
} gui_settings;
void draw();
void prepare_scene();
void create_pipelines();
void create_descriptor_set();
void create_descriptor_set_layout();
void setup_descriptor_pool();
void prepare_uniform_buffers();
void update_uniform_buffers();
static uint16_t array_to_uint16(const std::array<bool, 16> &array);
};
std::unique_ptr<vkb::VulkanSampleC> create_dynamic_line_rasterization();
samples/extensions/dynamic_line_rasterization/screenshot.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 105 KiB