Vulkan 学习(8)---- vkImageView 创建

OverView

Vulkan 的图像视图(VkImageView) 用于描述如何访问 VkImage 对象以及访问图像的哪一部分,

图像视图定义了图像格式和访问方式，允许渲染管线和图像进行交互，无论是作为纹理，颜色附件或者深度/模板附件

在交换链中，我们需要为每个图像(VkImage)创建一个基本的图像视图(VkImageView)，以便将它们作为颜色附件

创建方法

通过 vkCreateImageView 函数创建 vkImageView，函数原型如下：

VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(
    VkDevice                                    device,
    const VkImageViewCreateInfo*                pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkImageView*                                pView);

其中的VkImageViewCreateInfo是包含了主要创建信息的结构体:

typedef struct VkImageViewCreateInfo {
    // 结构体类型，必须是 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
    VkStructureType            sType;
    // 指向扩展特定数据的指针，对于 核心 vulkan 功能，通常为 null
    const void*                pNext;
    // 创建图像视图使用的标志位
    VkImageViewCreateFlags     flags;
    // 对应的 VkImage 对象
    VkImage                    image;
    // 图像视图的类型，决定了视图是如何解释图像的
    VkImageViewType            viewType;
    // 图像视图的格式，决定了图像数据的解释方式
    VkFormat                   format;
    // 用于在创建视图时重新映射图像的颜色分量
    VkComponentMapping         components;
    // 定义了图像视图的子资源范围，包括 mipmap 级别，数组层以及深度层的范围
    VkImageSubresourceRange    subresourceRange;
} VkImageViewCreateInfo;

其中关键的 VkImageViewType 和 VkComponentMapping 和 VkImageSubresourceRange 需要重点关注:

关键结构

VkImageViewType 定义了图像视图的类型:

typedef enum VkImageViewType {
    VK_IMAGE_VIEW_TYPE_1D = 0,
    VK_IMAGE_VIEW_TYPE_2D = 1,
    VK_IMAGE_VIEW_TYPE_3D = 2,
    VK_IMAGE_VIEW_TYPE_CUBE = 3,
    VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
    VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
    VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
    VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkImageViewType;

VkComponentMapping 用于指定如何从源图像中的颜色分量映射到目标图像视图中的颜色分量
通过 VkComponentMapping 类型的属性(components)，可以灵活控制图像视图中每个颜色分量的来源，这对于图像处理非常有用，比如转换颜色格式，调整颜色通道等。

默认情况下，我们将每个分量设置为VK_COMPONENT_SWIZZLE_IDENTITY，这意味着它们将直接从源图像中取值:

typedef enum VkComponentSwizzle {
    VK_COMPONENT_SWIZZLE_IDENTITY = 0, // 使用原始值
    VK_COMPONENT_SWIZZLE_ZERO = 1, // 使用零值
    VK_COMPONENT_SWIZZLE_ONE = 2, // 使用一值
    VK_COMPONENT_SWIZZLE_R = 3, // 使用 R 分量
    VK_COMPONENT_SWIZZLE_G = 4, // 使用 G 分量
    VK_COMPONENT_SWIZZLE_B = 5, // 使用 B 分量
    VK_COMPONENT_SWIZZLE_A = 6, // 使用 A 分量
    VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
} VkComponentSwizzle;

typedef struct VkComponentMapping {
    VkComponentSwizzle    r; // r 分量 来源
    VkComponentSwizzle    g; // g 分量 来源
    VkComponentSwizzle    b; // b 分量 来源
    VkComponentSwizzle    a; // a 分量 来源
} VkComponentMapping;

VkImageSubresourceRange 允许你选择图像的哪些层面和 mip 级别应该被应用在图像视图中:

typedef struct VkImageSubresourceRange {
    // 需要包含的图像 aspect(图像特性的层面)
    VkImageAspectFlags    aspectMask;
    // mip 级别的起始级别
    uint32_t              baseMipLevel;
    // mip 级别的数量
    uint32_t              levelCount;
    // 数组层的起始索引
    uint32_t              baseArrayLayer;
    // 数组层数量
    uint32_t              layerCount;
} VkImageSubresourceRange;

aspectMask 用于指定需要包含在图像视图中图像aspect(图像的特性的层面),
比如图像有深度和/或模板信息，你可以选择只包括颜色方面
(VK_IMAGE_ASPECT_COLOR_BIT)，或者包括深度方面 (VK_IMAGE_ASPECT_DEPTH_BIT) 和/或模板方面 (VK_IMAGE_ASPECT_STENCIL_BIT)

参考代码

这里一般和VkImage一起创建例子，因为VkImageView 的创建需要包含 VkImage 对象 作为参数:

void vulkanBasicDemo::vulkanCreateVulkanImage() {
    
    VkImageCreateInfo imageInfo = {};
    imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;  // 结构体类型
    imageInfo.pNext = nullptr;                              // 指向扩展信息的指针
    imageInfo.flags = 0;                                    // 图像创建标志
    imageInfo.imageType = VK_IMAGE_TYPE_2D;                 // 图像类型为 2D
    imageInfo.format = VK_FORMAT_R8G8B8A8_UNORM;            // 图像格式
    imageInfo.extent.width = test_width;                      // 图像宽度
    imageInfo.extent.height = test_height;                    // 图像高度
    imageInfo.extent.depth = 1;                             // 图像深度（对于 2D 图像为 1）
    imageInfo.mipLevels = 1;                                // MIP 级别数
    imageInfo.arrayLayers = 1;                              // 图像数组层数
    imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;              // 多重采样数量（1 表示不使用多重采样）
    imageInfo.tiling = VK_IMAGE_TILING_LINEAR;             // 图像数据的存储方式（优化存储）
    imageInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT; // 图像用途（作为传输目标和采样器）
    imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;      // 共享模式（独占模式）
    imageInfo.queueFamilyIndexCount = 0;                    // 使用队列族索引的数量
    imageInfo.pQueueFamilyIndices = &graphicsQueueFamilyIndex;      // 队列族索引的指针
    imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;    // 图像的初始布局（未定义）

    VkImage textureImage; // 定义 VkImage 变量
    // 创建图像
    if (vkCreateImage(device, &imageInfo, nullptr, &textureImage) != VK_SUCCESS) {
        throw std::runtime_error("failed to create texture image!"); // 如果创建图像失败，抛出异常
    }
    std::cout << __FUNCTION__ <<" vkCreateImage create image successs!" << std::endl;


    // 获取图像的内存需求
    VkMemoryRequirements memRequirements;
    vkGetImageMemoryRequirements(device, textureImage, &memRequirements);

    // 创建 VkMemoryAllocateInfo 结构体并初始化
    VkMemoryAllocateInfo allocInfo = {};
    allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; // 结构体类型
    allocInfo.allocationSize = memRequirements.size;          // 所需内存大小
    allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits,
        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);                 // 内存类型索引

    VkDeviceMemory textureImageMemory; // 定义 VkDeviceMemory 变量
    // 分配内存
    if (vkAllocateMemory(device, &allocInfo, nullptr, &textureImageMemory) != VK_SUCCESS) {
        throw std::runtime_error("failed to allocate texture image memory!"); // 如果分配内存失败，抛出异常
    }

    // 将内存绑定到图像
    vkBindImageMemory(device, textureImage, textureImageMemory, 0);
    std::cout << "vkBindImageMemory Successs!" << std::endl;


    // 定义 VkImageViewCreateInfo 结构体并初始化
    VkImageViewCreateInfo viewInfo = {};
    viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;  // 结构体类型
    viewInfo.pNext = nullptr;                                   // 指向扩展信息的指针
    viewInfo.flags = 0;                                         // 图像视图创建标志
    viewInfo.image = textureImage;                              // 要创建视图的图像句柄
    viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;                  // 图像视图类型为 2D
    viewInfo.format = VK_FORMAT_R8G8B8A8_UNORM;                  // 图像视图的格式
    viewInfo.components.r = VK_COMPONENT_SWIZZLE_R;      // R 分量映射
    viewInfo.components.g = VK_COMPONENT_SWIZZLE_G;      // G 分量映射
    viewInfo.components.b = VK_COMPONENT_SWIZZLE_B;      // B 分量映射
    viewInfo.components.a = VK_COMPONENT_SWIZZLE_A;      // A 分量映射
    viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // 视图的子资源范围（颜色部分）
    viewInfo.subresourceRange.baseMipLevel = 0;                 // 基础 MIP 级别
    viewInfo.subresourceRange.levelCount = 1;                   // MIP 级别数量
    viewInfo.subresourceRange.baseArrayLayer = 0;               // 基础数组层
    viewInfo.subresourceRange.layerCount = 1;                   // 数组层数量
    
    VkImageView textureImageView; // 定义 VkImageView 变量
    // 创建图像视图
    if (vkCreateImageView(device, &viewInfo, nullptr, &textureImageView) != VK_SUCCESS) {
         throw std::runtime_error("failed to create texture image view!"); // 如果创建视图失败，抛出异常
    }
    std::cout << __FUNCTION__ << " vkCreateImageView create imageView successs!" << std::endl;

    // 使用完成后销毁资源
    vkDestroyImageView(device, textureImageView, nullptr);  // 销毁图像试图
    vkDestroyImage(device, textureImage, nullptr);         // 销毁图像
    vkFreeMemory(device, textureImageMemory, nullptr);     // 释放图像内存
    std::cout << "vkDestroyImage Successs!" << std::endl;
}