Skip to content

Commit

Permalink
Added Constant Data sample (#135)
Browse files Browse the repository at this point in the history 
* Implemented the constant data sample and tutorial

* Added back removed shader, modified tutorial, and typo in render_frame.h

* Resolved comments around arm specific numbers

* Fixed bug that caused 256 bytes of data to be pushed into the buffer array on 128 byte devices

* Clang formatting issue

* Fixed bug in the buffer array method

* Updated tutorial

* Fixed misuse of storage type in the buffer array fragment shader

* Fixed superfluous conversion and passed the already converted data in push constants

* Push constants are placed directly into command buffer in template

* Update samples/performance/constant_data/constant_data_tutorial.md

Co-authored-by: sfricke-samsung <46493288+sfricke-samsung@users.noreply.github.com>

* Update samples/performance/constant_data/constant_data_tutorial.md

Co-authored-by: sfricke-samsung <46493288+sfricke-samsung@users.noreply.github.com>

* Updated tutorial

* Updated tutorial, cleaned descriptor sets and updated extensions

* Fixed doxygen

* Fixed lvalue compiler error

* Added Constant data to tutorial list in the readme'

* Rebased on master

* change

Co-authored-by: sfricke-samsung <46493288+sfricke-samsung@users.noreply.github.com>
  • Loading branch information
@ZandroFargnoli @sfricke-samsung
ZandroFargnoli and sfricke-samsung committed Jun 22, 2020
1 parent f365b7e commit 60b4452
Show file tree
Hide file tree
Showing 50 changed files with 2,137 additions and 490 deletions.
2 changes: 2 additions & 0 deletions README.md
View file
Expand Up @@ -68,6 +68,8 @@ Additionally you may find the following links useful:
- [Utilizing Specialization Constants](./samples/performance/specialization_constants/specialization_constants_tutorial.md)
- **Descriptors**
- [Descriptor and buffer management](./samples/performance/descriptor_management/descriptor_management_tutorial.md)
- **Constant Data**
- [Sending constant data to the shaders](./samples/performance/constant_data/)
- **Render Passes**
- [Appropriate use of load/store operations, and use of transient attachments](./samples/performance/render_passes/render_passes_tutorial.md)
- [Choosing the correct layout when transitioning images](./samples/performance/layout_transitions/layout_transitions_tutorial.md)
Expand Down
2 changes: 1 addition & 1 deletion framework/buffer_pool.cpp
View file
Expand Up @@ -133,7 +133,7 @@ void BufferAllocation::update(const std::vector<uint8_t> &data, uint32_t offset)

if (offset + data.size() <= size)
{
buffer->update(data, static_cast<size_t>(base_offset) + offset);
buffer->update(data, to_u32(base_offset) + offset);
}
else
{
Expand Down
6 changes: 2 additions & 4 deletions framework/buffer_pool.h
View file
@@ -1,4 +1,4 @@
/* Copyright (c) 2019, Arm Limited and Contributors
/* Copyright (c) 2019-2020, Arm Limited and Contributors
*
* SPDX-License-Identifier: Apache-2.0
*
Expand Down Expand Up @@ -48,9 +48,7 @@ class BufferAllocation
template <class T>
void update(const T &value, uint32_t offset = 0)
{
update(std::vector<uint8_t>{reinterpret_cast<const uint8_t *>(&value),
reinterpret_cast<const uint8_t *>(&value) + sizeof(T)},
offset);
update(to_bytes(value), offset);
}

bool empty() const;
Expand Down
9 changes: 8 additions & 1 deletion framework/common/helpers.h
View file
@@ -1,4 +1,4 @@
/* Copyright (c) 2018-2019, Arm Limited and Contributors
/* Copyright (c) 2018-2020, Arm Limited and Contributors
*
* SPDX-License-Identifier: Apache-2.0
*
Expand Down Expand Up @@ -207,4 +207,11 @@ uint32_t to_u32(T value)
return static_cast<uint32_t>(value);
}

template <typename T>
inline std::vector<uint8_t> to_bytes(const T &value)
{
return std::vector<uint8_t>{reinterpret_cast<const uint8_t *>(&value),
reinterpret_cast<const uint8_t *>(&value) + sizeof(T)};
}

} // namespace vkb
260 changes: 75 additions & 185 deletions framework/common/strings.cpp
View file
Expand Up @@ -494,43 +494,6 @@ const std::string to_string(VkSampleCountFlagBits flags)
return result;
}

const std::string to_string_vk_shader_stage_flags(VkShaderStageFlags flags)
{
if (flags == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT)
{
return "TESSELLATION_CONTROL";
}
if (flags == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
{
return "TESSELLATION_EVALUATION";
}
if (flags == VK_SHADER_STAGE_GEOMETRY_BIT)
{
return "GEOMETRY";
}
if (flags == VK_SHADER_STAGE_FRAGMENT_BIT)
{
return "FRAGMENT";
}
if (flags == VK_SHADER_STAGE_COMPUTE_BIT)
{
return "COMPUTE";
}
if (flags == VK_SHADER_STAGE_ALL_GRAPHICS)
{
return "ALL_GRAPHICS";
}
if (flags == VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM)
{
return "FLAG_BITS_MAX_ENUM";
}
if (flags & VK_SHADER_STAGE_VERTEX_BIT)
{
return "VERTEX";
}
return "Unknown Stage";
}

const std::string to_string(VkPhysicalDeviceType type)
{
switch (type)
Expand All @@ -550,111 +513,6 @@ const std::string to_string(VkPhysicalDeviceType type)
}
}

const std::string to_string_vk_image_usage_flags(VkImageUsageFlags flags)
{
std::string result{""};
bool append = false;
if (flags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT)
{
result += append ? " / " : "";
result += "VK_IMAGE_USAGE_TRANSFER_SRC_BIT";
append = true;
}
if (flags & VK_IMAGE_USAGE_TRANSFER_DST_BIT)
{
result += append ? " / " : "";
result += "VK_IMAGE_USAGE_TRANSFER_DST_BIT";
append = true;
}
if (flags & VK_IMAGE_USAGE_SAMPLED_BIT)
{
result += append ? " / " : "";
result += "VK_IMAGE_USAGE_SAMPLED_BIT";
append = true;
}
if (flags & VK_IMAGE_USAGE_STORAGE_BIT)
{
result += append ? " / " : "";
result += "VK_IMAGE_USAGE_STORAGE_BIT";
append = true;
}
if (flags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
{
result += append ? " / " : "";
result += "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
append = true;
}
if (flags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)
{
result += append ? " / " : "";
result += "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT";
append = true;
}
if (flags & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT)
{
result += append ? " / " : "";
result += "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT";
append = true;
}
if (flags & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)
{
result += append ? " / " : "";
result += "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT";
append = true;
}
return result;
}

const std::string to_string_vk_image_aspect_flags(VkImageAspectFlags flags)
{
std::string result = "";
bool append = false;

if (flags & VK_IMAGE_ASPECT_COLOR_BIT)
{
result += append ? "/" : "";
result += "VK_IMAGE_ASPECT_COLOR_BIT";
append = true;
}
if (flags & VK_IMAGE_ASPECT_DEPTH_BIT)
{
result += append ? "/" : "";
result += "VK_IMAGE_ASPECT_DEPTH_BIT";
append = true;
}
if (flags & VK_IMAGE_ASPECT_STENCIL_BIT)
{
result += append ? "/" : "";
result += "VK_IMAGE_ASPECT_STENCIL_BIT";
append = true;
}
if (flags & VK_IMAGE_ASPECT_METADATA_BIT)
{
result += append ? "/" : "";
result += "VK_IMAGE_ASPECT_METADATA_BIT";
append = true;
}
if (flags & VK_IMAGE_ASPECT_PLANE_0_BIT)
{
result += append ? "/" : "";
result += "VK_IMAGE_ASPECT_PLANE_0_BIT";
append = true;
}
if (flags & VK_IMAGE_ASPECT_PLANE_1_BIT)
{
result += append ? "/" : "";
result += "VK_IMAGE_ASPECT_PLANE_1_BIT";
append = true;
}
if (flags & VK_IMAGE_ASPECT_PLANE_2_BIT)
{
result += append ? "/" : "";
result += "VK_IMAGE_ASPECT_PLANE_2_BIT";
append = true;
}
return result;
}

const std::string to_string(VkImageTiling tiling)
{
switch (tiling)
Expand Down Expand Up @@ -837,27 +695,6 @@ const std::string to_string(VkPolygonMode mode)
return "UNKOWN";
}

const std::string to_string_vk_cull_mode_flags(VkCullModeFlags flags)
{
if (flags == VK_CULL_MODE_NONE)
{
return "VK_CULL_MODE_NONE";
}
if (flags == VK_CULL_MODE_FRONT_BIT)
{
return "VK_CULL_MODE_FRONT_BIT";
}
if (flags == VK_CULL_MODE_BACK_BIT)
{
return "VK_CULL_MODE_BACK_BIT";
}
if (flags == VK_CULL_MODE_FRONT_AND_BACK)
{
return "VK_CULL_MODE_FRONT_AND_BACK";
}
return "Unkown Cull Mode";
}

const std::string to_string(VkCompareOp operation)
{
if (operation == VK_COMPARE_OP_NEVER)
Expand Down Expand Up @@ -1260,28 +1097,6 @@ const std::string to_string(VkBlendOp operation)
return "Unkown";
}

const std::string to_string_vk_color_component_flags(VkColorComponentFlags flags)
{
std::string result = "";
if (flags & VK_COLOR_COMPONENT_R_BIT)
{
result += "R";
}
if (flags & VK_COLOR_COMPONENT_G_BIT)
{
result += "G";
}
if (flags & VK_COLOR_COMPONENT_B_BIT)
{
result += "B";
}
if (flags & VK_COLOR_COMPONENT_A_BIT)
{
result += "A";
}
return result.empty() ? "No Color Component" : result;
}

const std::string to_string(sg::AlphaMode mode)
{
if (mode == sg::AlphaMode::Blend)
Expand Down Expand Up @@ -1339,4 +1154,79 @@ const std::string to_string(ShaderResourceType type)
}
}

const std::string buffer_usage_to_string(VkBufferUsageFlags flags)
{
return to_string<VkBufferUsageFlagBits>(flags,
{{VK_BUFFER_USAGE_TRANSFER_SRC_BIT, "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"},
{VK_BUFFER_USAGE_TRANSFER_DST_BIT, "VK_BUFFER_USAGE_TRANSFER_DST_BIT"},
{VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, "VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT"},
{VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, "VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT"},
{VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, "VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT"},
{VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, "VK_BUFFER_USAGE_STORAGE_BUFFER_BIT"},
{VK_BUFFER_USAGE_INDEX_BUFFER_BIT, "VK_BUFFER_USAGE_INDEX_BUFFER_BIT"},
{VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, "VK_BUFFER_USAGE_VERTEX_BUFFER_BIT"},
{VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT"},
{VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, "VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT"},
{VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT, "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT"},
{VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT, "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"},
{VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT, "VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT"},
{VK_BUFFER_USAGE_RAY_TRACING_BIT_NV, "VK_BUFFER_USAGE_RAY_TRACING_BIT_NV"},
{VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT, "VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT"},
{VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR, "VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR"}});
}

const std::string shader_stage_to_string(VkShaderStageFlags flags)
{
return to_string<VkShaderStageFlagBits>(flags,
{{VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, "TESSELLATION_CONTROL"},
{VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, "TESSELLATION_EVALUATION"},
{VK_SHADER_STAGE_GEOMETRY_BIT, "GEOMETRY"},
{VK_SHADER_STAGE_VERTEX_BIT, "VERTEX"},
{VK_SHADER_STAGE_FRAGMENT_BIT, "FRAGMENT"},
{VK_SHADER_STAGE_COMPUTE_BIT, "COMPUTE"},
{VK_SHADER_STAGE_ALL_GRAPHICS, "ALL GRAPHICS"}});
}

const std::string image_usage_to_string(VkImageUsageFlags flags)
{
return to_string<VkImageUsageFlagBits>(flags,
{{VK_IMAGE_USAGE_TRANSFER_SRC_BIT, "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"},
{VK_IMAGE_USAGE_TRANSFER_DST_BIT, "VK_IMAGE_USAGE_TRANSFER_DST_BIT"},
{VK_IMAGE_USAGE_SAMPLED_BIT, "VK_IMAGE_USAGE_SAMPLED_BIT"},
{VK_IMAGE_USAGE_STORAGE_BIT, "VK_IMAGE_USAGE_STORAGE_BIT"},
{VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT"},
{VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT"},
{VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT"},
{VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT"}});
}

const std::string image_aspect_to_string(VkImageAspectFlags flags)
{
return to_string<VkImageAspectFlagBits>(flags,
{{VK_IMAGE_ASPECT_COLOR_BIT, "VK_IMAGE_ASPECT_COLOR_BIT"},
{VK_IMAGE_ASPECT_DEPTH_BIT, "VK_IMAGE_ASPECT_DEPTH_BIT"},
{VK_IMAGE_ASPECT_STENCIL_BIT, "VK_IMAGE_ASPECT_STENCIL_BIT"},
{VK_IMAGE_ASPECT_METADATA_BIT, "VK_IMAGE_ASPECT_METADATA_BIT"},
{VK_IMAGE_ASPECT_PLANE_0_BIT, "VK_IMAGE_ASPECT_PLANE_0_BIT"},
{VK_IMAGE_ASPECT_PLANE_1_BIT, "VK_IMAGE_ASPECT_PLANE_1_BIT"},
{VK_IMAGE_ASPECT_PLANE_2_BIT, "VK_IMAGE_ASPECT_PLANE_2_BIT"}});
}

const std::string cull_mode_to_string(VkCullModeFlags flags)
{
return to_string<VkCullModeFlagBits>(flags,
{{VK_CULL_MODE_NONE, "VK_CULL_MODE_NONE"},
{VK_CULL_MODE_FRONT_BIT, "VK_CULL_MODE_FRONT_BIT"},
{VK_CULL_MODE_BACK_BIT, "VK_CULL_MODE_BACK_BIT"},
{VK_CULL_MODE_FRONT_AND_BACK, "VK_CULL_MODE_FRONT_AND_BACK"}});
}

const std::string color_component_to_string(VkColorComponentFlags flags)
{
return to_string<VkColorComponentFlagBits>(flags,
{{VK_COLOR_COMPONENT_R_BIT, "R"},
{VK_COLOR_COMPONENT_G_BIT, "G"},
{VK_COLOR_COMPONENT_B_BIT, "B"},
{VK_COLOR_COMPONENT_A_BIT, "A"}});
}
} // namespace vkb

0 comments on commit 60b4452

Please sign in to comment.