社区首页 >问答首页 >如何在不改变数据的情况下将三维VkImage传递给计算机着色器？

问如何在不改变数据的情况下将三维VkImage传递给计算机着色器？
EN

Stack Overflow用户

提问于 2021-07-20 20:42:37

回答 1查看 163关注 0票数 3

我试图将体素的随机三维图像传递给计算着色器，但是当我运行着色器时，整个着色器的结果如下：

正如你所看到的，这看起来并不像随机生成的体素，除了第一个和第二个体素的一半。老实说，我完全不知道这些数据发生了什么。我知道我的计算机着色器输出到交换链图像并不是一个问题，因为我检查了其他计算机着色器(比如一个噪声屏幕等等)。会起作用的，而且他们做到了。我已经缩小了错误的位置，将数据从我的std::vector<std::vector<std::vector<glm::vec4>>>复制到voxelImage 或，这可能是将voxelImage传递给计算机着色器。

此外，我已经检查过，体素的产生并不仅仅是产生屏幕上看到的东西。vec4s的向量确实是随机的，我保证误差在我缩小到的两个地方中的任何一个。

我将只发布用于创建voxelImage和voxelImageView的代码以及描述符，因为这很可能是错误发生的地方。(发布代码的其余部分不必要地过多，而且太长了)

Voxel图像创建：

void createVoxelImage() {

        VkDeviceSize imageSize = voxelDataInit.size();



        VkBuffer stagingBuffer;
        VkDeviceMemory stagingBufferMemory;
        VmaAllocation stagingAllocation;
        createBuffer(imageSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_GPU_ONLY, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, stagingBuffer, stagingAllocation, stagingBufferMemory);

        void* data;
        vmaMapMemory(allocator, stagingAllocation, &data);
        memcpy(data, &voxelDataInit, imageSize);
        vmaUnmapMemory(allocator, stagingAllocation);

        
        
       
        VkDeviceMemory temp; 
        createImage(voxWidth, voxHeight, voxDepth, VK_IMAGE_TYPE_3D, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, voxelImage, voxelAllocation, VMA_MEMORY_USAGE_GPU_ONLY, temp, 5);
        //vkFreeMemory(device, temp, NULL);

        //VkDeviceMemory temp;
        //createImage(voxWidth, voxHeight, voxDepth, VK_IMAGE_TYPE_3D, VK_FORMAT_B8G8R8_UNORM, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_STORAGE_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, voxelImage, voxelAllocation, VMA_MEMORY_USAGE_CPU_TO_GPU, temp, 5);

        transitionImageLayout(voxelImage, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_ACCESS_TRANSFER_READ_BIT, VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
        copyBufferToImage(stagingBuffer, voxelImage, static_cast<uint32_t>(voxWidth), static_cast<uint32_t>(voxHeight), static_cast<uint32_t>(voxDepth));
        transitionImageLayout(voxelImage, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT);

        vmaDestroyBuffer(allocator, stagingBuffer, stagingAllocation);

    }

Voxel图像视图创建：

void createVoxelImageView() {
        VkImageViewCreateInfo viewInfo{};
        viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
        viewInfo.image = voxelImage;
        viewInfo.viewType = VK_IMAGE_VIEW_TYPE_3D;
        viewInfo.format = VK_FORMAT_R8G8B8A8_SRGB;
        //viewInfo.flags = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
        viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
        viewInfo.subresourceRange.baseMipLevel = 0;
        viewInfo.subresourceRange.levelCount = 1;
        viewInfo.subresourceRange.baseArrayLayer = 0;
        viewInfo.subresourceRange.layerCount = 1;

        
        
        if (vkCreateImageView(device, &viewInfo, nullptr, &voxelImageView) != VK_SUCCESS) {
            throw std::runtime_error("Failed to create image view! (voxel)");
        }
    }

数据输入到阴影中

layout(binding = 4, rgba8) uniform image3D voxels;

Def of createImage

void createImage(uint32_t width, uint32_t height, uint32_t depth, VkImageType imgType, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkImageLayout layout, VkMemoryPropertyFlags properties, VkImage& image, VmaAllocation& allocation, VmaMemoryUsage memUsage, VkDeviceMemory& imageMemory, int callNum) {
        VkImageCreateInfo imageInfo{};
        imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
        imageInfo.imageType = imgType;
        imageInfo.extent.width = width;
        imageInfo.extent.height = height;
        imageInfo.extent.depth = depth;
        imageInfo.mipLevels = 1;
        
        imageInfo.arrayLayers = 1;
        imageInfo.format = format;
        imageInfo.tiling = tiling;
        imageInfo.initialLayout = layout;
        imageInfo.usage = usage;
        imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
        imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
        imageInfo.flags = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;

        VmaAllocationCreateInfo vmaAllocInfo = {};
        vmaAllocInfo.usage = memUsage;
        vmaAllocInfo.requiredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;


        if (vmaCreateImage(allocator, &imageInfo, &vmaAllocInfo, &image, &allocation, nullptr) != VK_SUCCESS) {
            throw std::runtime_error(std::to_string(callNum));
            throw std::runtime_error("failed to create image!");
        }
    }

Def of transitionImageLayout

void transitionImageLayout(VkImage image, VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout, VkAccessFlagBits srcAccess, VkAccessFlagBits dstAccess, VkPipelineStageFlagBits srcStage, VkPipelineStageFlagBits dstStage) {
        VkCommandBuffer commandBuffer = beginSingleTimeCommands();

        VkImageMemoryBarrier barrier{};
        barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
        barrier.oldLayout = oldLayout;
        barrier.newLayout = newLayout;
        barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.image = image;
        barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
        barrier.subresourceRange.baseMipLevel = 0;
        barrier.subresourceRange.levelCount = 1;
        barrier.subresourceRange.baseArrayLayer = 0;
        barrier.subresourceRange.layerCount = 1;
        

        VkPipelineStageFlags sourceStage;
        VkPipelineStageFlags destinationStage;

        if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED && newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
            barrier.srcAccessMask = 0;
            barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;

            sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
            destinationStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
        }
        
        else {
            if (srcStage == VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT) {
                barrier.srcAccessMask = 0;
            }
            else {
                barrier.srcAccessMask = srcAccess;
            }
            barrier.dstAccessMask = dstAccess;

            sourceStage = srcStage;
            destinationStage = dstStage;
            //throw std::runtime_error("Unsupported layout transition.");
        }

        vkCmdPipelineBarrier(commandBuffer, sourceStage, destinationStage, 0, 0, nullptr, 0, nullptr, 1, &barrier);

        endSingleTimeCommands(commandBuffer);
    }

Def of copyBufferToImage

void copyBufferToImage(VkBuffer buffer, VkImage image, uint32_t width, uint32_t height, uint32_t depth){
    VkCommandBuffer commandBuffer = beginSingleTimeCommands();

    VkBufferImageCopy region{};
    region.bufferOffset = 0;
    region.bufferRowLength = 0;
    region.bufferImageHeight = 0;
    
    region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    region.imageSubresource.mipLevel = 0;
    region.imageSubresource.baseArrayLayer = 0;
    region.imageSubresource.layerCount = 1;

    region.imageOffset = { 0, 0, 0 };
    region.imageExtent = {
        width,
        height,
        depth
    };

    

    vkCmdCopyBufferToImage(commandBuffer, buffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);

    endSingleTimeCommands(commandBuffer);
}

c++

glsl

shader

vulkan

回答 1

Stack Overflow用户

回答已采纳

发布于 2021-07-20 22:44:11

如果voxelDataInit确实是std::vector<std::vector<std::vector<glm::vec4>>>类型的变量，那么memcpy(data, &voxelDataInit, imageSize);就永远无法工作。&voxelDataInit是指向vector的指针。指向vector<T>的指针总是相同的大小(忽略分配器本身)：3个指针的大小。

记住：vector<T>是指向T数组的指针，或者更确切地说，是指向该数组的3个指针。但是无论如何，vector<T>本身并不是一个T数组；它只是拥有一个数组。因此，复制vector的字节不会复制数组本身。

而且，size的vector只是元素的数量，而不是数组中的字节数。

复制这样的数据结构的最好方法是停止使用这样的数据结构。如果你想要一个三维数组，那么你想要的是一个尺寸为length_width_height的一维数组。您可以通过使用长度、宽度、高度将3D坐标转换为一维坐标来索引数组的任何特定X、Y、Z组件。

票数 2

页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持

原文链接：

https://stackoverflow.com/questions/68464085

复制

如何在Linux中使用管道将命令的输出传递给其他命令？

linux 连接排序数据统计

在Linux中，管道使用竖线符号 | 表示，它位于两个命令之间。管道的基本语法如下：

网络技术联盟站