Как передать 3D Vkimage в вычислительный шейдер без изменения данных? ⇐ C++

[Anonymous]

Я пытаюсь передать рандомизированное трехмерное изображение вокселей в вычислительный шейдер, но когда я запускаю шейдер, весь шейдер приводит к этому:

Как видите, это не выглядит как случайно сгенерированные воксели, за исключением первого и половины второго воксели. Я, честно говоря, не имею абсолютно понятия о том, что происходит с данными. Я знаю, что это не проблема с моим вычислительным выводом шейдера на изображения Swapchain, потому что я проверил, будут ли я проверяли другие Schome Shaders (например, просто экран шума и т. Д.), И они это сделали. Я сузил местоположение ошибки до копирования данных из моего std :: vector к вокселимажу или это может быть при передаче вокселимажа к вычислительному шейдеру.
Также я проверил, что генерация вокселей не просто генерируя то, что видно на экране. Вектор VEC4S действительно рандомизирован, я гарантирую, что ошибка находится в любом из двух мест, которые я сузил ее. и создание Voxelimageview , а также дескрипторы, как это, вероятно, когда происходит ошибка. (Размещение остальной части кода было бы излишне чрезмерной, и это было бы слишком долго)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(voxWidth), static_cast(voxHeight), static_cast(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);

}


Воксель изображение создание:
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 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 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);
}


Подробнее здесь: https://stackoverflow.com/questions/684 ... a-changing