Wie übergeben ich eine 3D -VKImage an einen Rechensader, ohne dass sich die Daten ändern? ⇐ C++

[Anonymous]

Ich versuche, ein randomisiertes 3D -Bild von Voxeln an einen Rechensader zu übergeben, aber wenn ich den Shader ausführe : //i.static.net/wz1yo.png "/>
Wie Sie sehen, sieht dies außer für die erste und die Hälfte der zweiten nicht wie zufällig erzeugte Voxel aus Voxel. Ich habe ehrlich gesagt keine Ahnung, was mit den Daten passiert. Ich weiß, dass es kein Problem mit meiner Rechens -Shader -Ausgabe für die Swapchain -Bilder ist, da ich überprüft habe, ob andere Shader (wie nur ein Rauschbildschirm usw.) funktionieren würden, und sie taten es. Ich habe den Ort des Fehlers auf das Kopieren von Daten aus meinem std :: vector zum Voxelimage eingegrenzt. oder Es könnte sich in der Übergabe des Voxelimage an den Berechnungssader befinden.
Ich habe auch überprüft Erzeugen, was auf dem Bildschirm zu sehen ist. Der Vektor von VEC4S ist in der Tat randomisiert. Ich garantiere, dass der Fehler an einer der beiden Stellen liegt, auf die ich ihn eingegrenzt habe. und VoxelimageView Erstellung sowie die Deskriptoren, da dies wahrscheinlich der Fall ist, wo der Fehler auftritt. (Der Rest des Codes zu veröffentlichen wäre unnötig übermäßig und es wäre viel zu lang)
Voxel Bilderstellung:

Code: Select all

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);

}

Voxel Bildansicht Erstellung:

Code: Select all

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)");
}
}

Dateneingabe in Shader

Code: Select all

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

def von createImage :

Code: Select all

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 von transitionImagelayout :

Code: Select all

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 von CopyBufferToimage :

Code: Select all

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);
}