tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity

Cleanup: Vulkan: Replace FlagBits with Flags 

Vulkan API uses Flags and FlagBits for enumerations. The FlagBits
contains the options that can be hold with the Flags data type.

This wasn't well understood at the beginning of the project and
the FlagBits where used where Flags should have been used. This cleanup
fixes this, improving the readability of the code where bit
manipulations where used.

Pull Request: https://projects.blender.org/blender/blender/pulls/114459
This commit is contained in:
Jeroen Bakker 2023-11-03 14:42:12 +01:00
parent e2215fea35
commit e77cf08b02
16 changed files with 60 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
source/blender/gpu/vulkan/vk_buffer.cc
View File

@ -24,29 +24,24 @@ bool VKBuffer::is_allocated() const
return allocation_ != VK_NULL_HANDLE;
}
static VmaAllocationCreateFlagBits vma_allocation_flags(GPUUsageType usage)
static VmaAllocationCreateFlags vma_allocation_flags(GPUUsageType usage)
{
switch (usage) {
case GPU_USAGE_STATIC:
case GPU_USAGE_DYNAMIC:
case GPU_USAGE_STREAM:
return static_cast<VmaAllocationCreateFlagBits>(
VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT);
return VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT;
case GPU_USAGE_DEVICE_ONLY:
return static_cast<VmaAllocationCreateFlagBits>(
VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT |
VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT);
return VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT |
VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
case GPU_USAGE_FLAG_BUFFER_TEXTURE_ONLY:
break;
}
BLI_assert_msg(false, "Unimplemented GPUUsageType");
return static_cast<VmaAllocationCreateFlagBits>(VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT |
VMA_ALLOCATION_CREATE_MAPPED_BIT);
return VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT;
}
bool VKBuffer::create(int64_t size_in_bytes,
GPUUsageType usage,
VkBufferUsageFlagBits buffer_usage)
bool VKBuffer::create(int64_t size_in_bytes, GPUUsageType usage, VkBufferUsageFlags buffer_usage)
{
BLI_assert(!is_allocated());
BLI_assert(vk_buffer_ == VK_NULL_HANDLE);

2
source/blender/gpu/vulkan/vk_buffer.hh
View File

@ -32,7 +32,7 @@ class VKBuffer {
/** Has this buffer been allocated? */
bool is_allocated() const;
bool create(int64_t size, GPUUsageType usage, VkBufferUsageFlagBits buffer_usage);
bool create(int64_t size, GPUUsageType usage, VkBufferUsageFlags buffer_usage);
void clear(VKContext &context, uint32_t clear_value);
void update(const void *data) const;
void read(void *data) const;

17
source/blender/gpu/vulkan/vk_common.cc
View File

@ -11,7 +11,7 @@
#include "vk_common.hh"
namespace blender::gpu {
VkImageAspectFlagBits to_vk_image_aspect_flag_bits(const eGPUTextureFormat format)
VkImageAspectFlags to_vk_image_aspect_flag_bits(const eGPUTextureFormat format)
{
switch (format) {
/* Formats texture & render-buffer */
@ -62,8 +62,7 @@ VkImageAspectFlagBits to_vk_image_aspect_flag_bits(const eGPUTextureFormat forma
case GPU_DEPTH32F_STENCIL8:
case GPU_DEPTH24_STENCIL8:
return static_cast<VkImageAspectFlagBits>(VK_IMAGE_ASPECT_DEPTH_BIT |
VK_IMAGE_ASPECT_STENCIL_BIT);
return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
/* Texture only formats. */
case GPU_RGB32UI:
@ -98,20 +97,20 @@ VkImageAspectFlagBits to_vk_image_aspect_flag_bits(const eGPUTextureFormat forma
return VK_IMAGE_ASPECT_COLOR_BIT;
}
BLI_assert_unreachable();
return static_cast<VkImageAspectFlagBits>(0);
return 0;
}
VkImageAspectFlagBits to_vk_image_aspect_flag_bits(const eGPUFrameBufferBits buffers)
VkImageAspectFlags to_vk_image_aspect_flag_bits(const eGPUFrameBufferBits buffers)
{
VkImageAspectFlagBits result = static_cast<VkImageAspectFlagBits>(0);
VkImageAspectFlags result = 0;
if (buffers & GPU_COLOR_BIT) {
result = static_cast<VkImageAspectFlagBits>(result | VK_IMAGE_ASPECT_COLOR_BIT);
result |= VK_IMAGE_ASPECT_COLOR_BIT;
}
if (buffers & GPU_DEPTH_BIT) {
result = static_cast<VkImageAspectFlagBits>(result | VK_IMAGE_ASPECT_DEPTH_BIT);
result |= VK_IMAGE_ASPECT_DEPTH_BIT;
}
if (buffers & GPU_STENCIL_BIT) {
result = static_cast<VkImageAspectFlagBits>(result | VK_IMAGE_ASPECT_STENCIL_BIT);
result |= VK_IMAGE_ASPECT_STENCIL_BIT;
}
return result;
}

4
source/blender/gpu/vulkan/vk_common.hh
View File

@ -38,8 +38,8 @@ enum class eImageViewUsage {
Attachment,
};
VkImageAspectFlagBits to_vk_image_aspect_flag_bits(const eGPUTextureFormat format);
VkImageAspectFlagBits to_vk_image_aspect_flag_bits(const eGPUFrameBufferBits buffers);
VkImageAspectFlags to_vk_image_aspect_flag_bits(const eGPUTextureFormat format);
VkImageAspectFlags to_vk_image_aspect_flag_bits(const eGPUFrameBufferBits buffers);
VkFormat to_vk_format(const eGPUTextureFormat format);
eGPUTextureFormat to_gpu_format(const VkFormat format);
VkFormat to_vk_format(const GPUVertCompType type,

3
source/blender/gpu/vulkan/vk_device.cc
View File

@ -140,8 +140,7 @@ void VKDevice::init_dummy_buffer(VKContext &context)
dummy_buffer_.create(sizeof(float4x4),
GPU_USAGE_DEVICE_ONLY,
static_cast<VkBufferUsageFlagBits>(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT |
VK_BUFFER_USAGE_TRANSFER_DST_BIT));
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
dummy_buffer_.clear(context, 0);
}

2
source/blender/gpu/vulkan/vk_framebuffer.cc
View File

@ -283,7 +283,7 @@ static void blit_aspect(VKCommandBuffers &command_buffer,
VKTexture &src_texture,
int dst_offset_x,
int dst_offset_y,
VkImageAspectFlagBits image_aspect)
VkImageAspectFlags image_aspect)
{
/* Prefer texture copy, as some platforms don't support using D32_SFLOAT_S8_UINT to be used as
* a blit destination. */

10
source/blender/gpu/vulkan/vk_image_view.cc
View File

@ -37,11 +37,11 @@ VKImageView::VKImageView(VKTexture &texture,
bool use_srgb,
StringRefNull name)
{
const VkImageAspectFlagBits allowed_bits = static_cast<VkImageAspectFlagBits>(
VK_IMAGE_ASPECT_COLOR_BIT |
(use_stencil ? VK_IMAGE_ASPECT_STENCIL_BIT : VK_IMAGE_ASPECT_DEPTH_BIT));
VkImageAspectFlagBits image_aspect = static_cast<VkImageAspectFlagBits>(
(to_vk_image_aspect_flag_bits(texture.format_get()) & allowed_bits));
const VkImageAspectFlags allowed_bits = VK_IMAGE_ASPECT_COLOR_BIT |
(use_stencil ? VK_IMAGE_ASPECT_STENCIL_BIT :
VK_IMAGE_ASPECT_DEPTH_BIT);
VkImageAspectFlags image_aspect = to_vk_image_aspect_flag_bits(texture.format_get()) &
allowed_bits;
vk_format_ = to_vk_format(texture.format_get());
if (texture.format_flag_get() & GPU_FORMAT_SRGB && !use_srgb) {

3
source/blender/gpu/vulkan/vk_immediate.cc
View File

@ -83,8 +83,7 @@ std::unique_ptr<VKBuffer> VKImmediate::create_resource(VKContext & /*context*/)
std::unique_ptr<VKBuffer> result = std::make_unique<VKBuffer>();
result->create(new_buffer_size(bytes_needed),
GPU_USAGE_DYNAMIC,
static_cast<VkBufferUsageFlagBits>(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT |
VK_BUFFER_USAGE_TRANSFER_DST_BIT));
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
debug::object_label(result->vk_handle(), "Immediate");
buffer_offset_ = 0;
return result;

6
source/blender/gpu/vulkan/vk_index_buffer.cc
View File

@ -81,10 +81,8 @@ void VKIndexBuffer::strip_restart_indices()
void VKIndexBuffer::allocate()
{
GPUUsageType usage = data_ == nullptr ? GPU_USAGE_DEVICE_ONLY : GPU_USAGE_STATIC;
buffer_.create(size_get(),
usage,
static_cast<VkBufferUsageFlagBits>(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
VK_BUFFER_USAGE_INDEX_BUFFER_BIT));
buffer_.create(
size_get(), usage, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT);
debug::object_label(buffer_.vk_handle(), "IndexBuffer");
}

6
source/blender/gpu/vulkan/vk_pixel_buffer.cc
View File

@ -14,10 +14,8 @@ namespace blender::gpu {
VKPixelBuffer::VKPixelBuffer(int64_t size) : PixelBuffer(size)
{
buffer_.create(size,
GPU_USAGE_STATIC,
static_cast<VkBufferUsageFlagBits>(VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
VK_BUFFER_USAGE_TRANSFER_DST_BIT));
buffer_.create(
size, GPU_USAGE_STATIC, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
debug::object_label(buffer_.vk_handle(), "PixelBuffer");
}

13
source/blender/gpu/vulkan/vk_shader.cc
View File

@ -859,7 +859,7 @@ static VkDescriptorType descriptor_type(const shader::ShaderCreateInfo::Resource
static VkDescriptorSetLayoutBinding create_descriptor_set_layout_binding(
const VKDescriptorSet::Location location,
const shader::ShaderCreateInfo::Resource &resource,
VkShaderStageFlagBits vk_shader_stages)
VkShaderStageFlags vk_shader_stages)
{
VkDescriptorSetLayoutBinding binding = {};
binding.binding = location;
@ -872,7 +872,7 @@ static VkDescriptorSetLayoutBinding create_descriptor_set_layout_binding(
}
static VkDescriptorSetLayoutBinding create_descriptor_set_layout_binding(
const VKPushConstants::Layout &push_constants_layout, VkShaderStageFlagBits vk_shader_stages)
const VKPushConstants::Layout &push_constants_layout, VkShaderStageFlags vk_shader_stages)
{
BLI_assert(push_constants_layout.storage_type_get() ==
VKPushConstants::StorageType::UNIFORM_BUFFER);
@ -890,7 +890,7 @@ static void add_descriptor_set_layout_bindings(
const VKShaderInterface &interface,
const Vector<shader::ShaderCreateInfo::Resource> &resources,
Vector<VkDescriptorSetLayoutBinding> &r_bindings,
VkShaderStageFlagBits vk_shader_stages)
VkShaderStageFlags vk_shader_stages)
{
for (const shader::ShaderCreateInfo::Resource &resource : resources) {
const VKDescriptorSet::Location location = interface.descriptor_set_location(resource);
@ -909,7 +909,7 @@ static VkDescriptorSetLayoutCreateInfo create_descriptor_set_layout(
const VKShaderInterface &interface,
const Vector<shader::ShaderCreateInfo::Resource> &resources,
Vector<VkDescriptorSetLayoutBinding> &r_bindings,
VkShaderStageFlagBits vk_shader_stages)
VkShaderStageFlags vk_shader_stages)
{
add_descriptor_set_layout_bindings(interface, resources, r_bindings, vk_shader_stages);
VkDescriptorSetLayoutCreateInfo set_info = {};
@ -948,9 +948,8 @@ bool VKShader::finalize_descriptor_set_layouts(VkDevice vk_device,
all_resources.extend(info.batch_resources_);
Vector<VkDescriptorSetLayoutBinding> bindings;
const VkShaderStageFlagBits vk_shader_stages = is_graphics_shader() ?
VK_SHADER_STAGE_ALL_GRAPHICS :
VK_SHADER_STAGE_COMPUTE_BIT;
const VkShaderStageFlags vk_shader_stages = is_graphics_shader() ? VK_SHADER_STAGE_ALL_GRAPHICS :
VK_SHADER_STAGE_COMPUTE_BIT;
VkDescriptorSetLayoutCreateInfo layout_info = create_descriptor_set_layout(
shader_interface, all_resources, bindings, vk_shader_stages);
if (vkCreateDescriptorSetLayout(vk_device, &layout_info, vk_allocation_callbacks, &layout_) !=

5
source/blender/gpu/vulkan/vk_storage_buffer.cc
View File

@ -36,9 +36,8 @@ void VKStorageBuffer::allocate()
{
buffer_.create(size_in_bytes_,
usage_,
static_cast<VkBufferUsageFlagBits>(VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT |
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
VK_BUFFER_USAGE_TRANSFER_DST_BIT));
VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
VK_BUFFER_USAGE_TRANSFER_DST_BIT);
debug::object_label(buffer_.vk_handle(), name_);
}

38
source/blender/gpu/vulkan/vk_texture.cc
View File

@ -122,7 +122,7 @@ void VKTexture::generate_mipmap()
current_layout_set(VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
}
void VKTexture::copy_to(VKTexture &dst_texture, VkImageAspectFlagBits vk_image_aspect)
void VKTexture::copy_to(VKTexture &dst_texture, VkImageAspectFlags vk_image_aspect)
{
VKContext &context = *VKContext::get();
layout_ensure(context, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
@ -380,17 +380,16 @@ bool VKTexture::is_texture_view() const
return source_texture_ != nullptr;
}
static VkImageUsageFlagBits to_vk_image_usage(const eGPUTextureUsage usage,
const eGPUTextureFormatFlag format_flag)
static VkImageUsageFlags to_vk_image_usage(const eGPUTextureUsage usage,
const eGPUTextureFormatFlag format_flag)
{
VkImageUsageFlagBits result = static_cast<VkImageUsageFlagBits>(VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT |
VK_IMAGE_USAGE_SAMPLED_BIT);
VkImageUsageFlags result = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
VK_IMAGE_USAGE_SAMPLED_BIT;
if (usage & GPU_TEXTURE_USAGE_SHADER_READ) {
result = static_cast<VkImageUsageFlagBits>(result | VK_IMAGE_USAGE_STORAGE_BIT);
result |= VK_IMAGE_USAGE_STORAGE_BIT;
}
if (usage & GPU_TEXTURE_USAGE_SHADER_WRITE) {
result = static_cast<VkImageUsageFlagBits>(result | VK_IMAGE_USAGE_STORAGE_BIT);
result |= VK_IMAGE_USAGE_STORAGE_BIT;
}
if (usage & GPU_TEXTURE_USAGE_ATTACHMENT) {
if (format_flag & GPU_FORMAT_COMPRESSED) {
@ -399,44 +398,43 @@ static VkImageUsageFlagBits to_vk_image_usage(const eGPUTextureUsage usage,
}
else {
if (format_flag & (GPU_FORMAT_DEPTH | GPU_FORMAT_STENCIL)) {
result = static_cast<VkImageUsageFlagBits>(result |
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
result |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
}
else {
result = static_cast<VkImageUsageFlagBits>(result | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
result |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
}
}
}
if (usage & GPU_TEXTURE_USAGE_HOST_READ) {
result = static_cast<VkImageUsageFlagBits>(result | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
result |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
}
/* Disable some usages based on the given format flag to support more devices. */
if (format_flag & GPU_FORMAT_SRGB) {
/* NVIDIA devices don't create SRGB textures when it storage bit is set. */
result = static_cast<VkImageUsageFlagBits>(result & ~VK_IMAGE_USAGE_STORAGE_BIT);
result &= ~VK_IMAGE_USAGE_STORAGE_BIT;
}
if (format_flag & (GPU_FORMAT_DEPTH | GPU_FORMAT_STENCIL)) {
/* NVIDIA devices don't create depth textures when it storage bit is set. */
result = static_cast<VkImageUsageFlagBits>(result & ~VK_IMAGE_USAGE_STORAGE_BIT);
result &= ~VK_IMAGE_USAGE_STORAGE_BIT;
}
return result;
}
static VkImageCreateFlagBits to_vk_image_create(const eGPUTextureType texture_type,
const eGPUTextureFormatFlag format_flag,
const eGPUTextureUsage usage)
static VkImageCreateFlags to_vk_image_create(const eGPUTextureType texture_type,
const eGPUTextureFormatFlag format_flag,
const eGPUTextureUsage usage)
{
VkImageCreateFlagBits result = static_cast<VkImageCreateFlagBits>(0);
VkImageCreateFlags result = 0;
if (ELEM(texture_type, GPU_TEXTURE_CUBE, GPU_TEXTURE_CUBE_ARRAY)) {
result = static_cast<VkImageCreateFlagBits>(result | VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT);
result |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
}
/* sRGB textures needs to be mutable as they can be used as non-sRGB frame-buffer attachments. */
if (usage & GPU_TEXTURE_USAGE_ATTACHMENT && format_flag & GPU_FORMAT_SRGB) {
result = static_cast<VkImageCreateFlagBits>(result | VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT);
result |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
}
return result;

2
source/blender/gpu/vulkan/vk_texture.hh
View File

@ -56,7 +56,7 @@ class VKTexture : public Texture, public VKBindableResource {
void generate_mipmap() override;
void copy_to(Texture *tex) override;
void copy_to(VKTexture &dst_texture, VkImageAspectFlagBits vk_image_aspect);
void copy_to(VKTexture &dst_texture, VkImageAspectFlags vk_image_aspect);
void clear(eGPUDataFormat format, const void *data) override;
void clear_depth_stencil(const eGPUFrameBufferBits buffer,
float clear_depth,

5
source/blender/gpu/vulkan/vk_uniform_buffer.cc
View File

@ -26,9 +26,8 @@ void VKUniformBuffer::allocate()
{
buffer_.create(size_in_bytes_,
GPU_USAGE_STATIC,
static_cast<VkBufferUsageFlagBits>(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT |
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
VK_BUFFER_USAGE_TRANSFER_DST_BIT));
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
VK_BUFFER_USAGE_TRANSFER_DST_BIT);
debug::object_label(buffer_.vk_handle(), name_);
}

6
source/blender/gpu/vulkan/vk_vertex_buffer.cc
View File

@ -178,10 +178,8 @@ void VKVertexBuffer::allocate()
{
buffer_.create(size_alloc_get(),
usage_,
static_cast<VkBufferUsageFlagBits>(VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT |
VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT));
VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT);
debug::object_label(buffer_.vk_handle(), "VertexBuffer");
}