Как передать предыдущий кадр как Sampler2D во фрагментный шейдер в Vulkan?

В настоящее время я разрабатываю проект Vulkan и столкнулся с проблемой, которую не могу решить.

Мне нужно передать изображение предыдущего кадра в качестве sampler2D во фрагментный шейдер. Я следовал руководству Vulkan по настройке проекта, поэтому у меня правильно реализована цепочка обмена.

Моя идея заключалась в том, чтобы использовать vkCmdCopyImage для копирования текущего кадра, отображаемого в изображении цепочки обмена, в целевой VkImage перед началом рендеринга следующего кадра. Таким образом, я могу передать этот VkImage как sampler2D во фрагментный шейдер для рендеринга следующего кадра.

Во-первых, я хотел бы спросить, правильный ли мой подход или есть ли лучший способ справиться с этой ситуацией.

Если это решение осуществимо, я был бы признателен за некоторые рекомендации о том, что может быть не так с моим кодом. Ниже я предоставляю метод drawFrame(), который вызывается в основном цикле моего приложения, и методtexture(), который обрабатывает копирование изображения.

Проблема в том, что если я не вызываю метод текстуры(), все работает нормально, но у меня нет предыдущего кадра во фрагментном шейдере. Однако если я вызываю метод текстуры(), все работает без ошибок, но кажется, что VkImage никогда не обновляется.

void texture(int curImageIndex) {
    VkImage textureImage = getImage(); // destination image
    VkCommandBuffer commandBuffer = beginSingleTimeCommands();

    VkImageMemoryBarrier barrierSwapchainToTransfer = {};
    barrierSwapchainToTransfer.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
    barrierSwapchainToTransfer.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    barrierSwapchainToTransfer.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
    barrierSwapchainToTransfer.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrierSwapchainToTransfer.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrierSwapchainToTransfer.image = swapChainImages[curImageIndex];
    barrierSwapchainToTransfer.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    barrierSwapchainToTransfer.subresourceRange.baseMipLevel = 0;
    barrierSwapchainToTransfer.subresourceRange.levelCount = 1;
    barrierSwapchainToTransfer.subresourceRange.baseArrayLayer = 0;
    barrierSwapchainToTransfer.subresourceRange.layerCount = 1;
    barrierSwapchainToTransfer.srcAccessMask = VK_ACCESS_NONE_KHR;
    barrierSwapchainToTransfer.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;

    vkCmdPipelineBarrier(
        commandBuffer,
        VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
        0,
        0, nullptr,
        0, nullptr,
        1, &barrierSwapchainToTransfer
    );

    VkImageMemoryBarrier barrierTextureToTransfer = {};
    barrierTextureToTransfer.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
    barrierTextureToTransfer.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    barrierTextureToTransfer.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
    barrierTextureToTransfer.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrierTextureToTransfer.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrierTextureToTransfer.image = textureImage;
    barrierTextureToTransfer.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    barrierTextureToTransfer.subresourceRange.baseMipLevel = 0;
    barrierTextureToTransfer.subresourceRange.levelCount = 1;
    barrierTextureToTransfer.subresourceRange.baseArrayLayer = 0;
    barrierTextureToTransfer.subresourceRange.layerCount = 1;
    barrierTextureToTransfer.srcAccessMask = VK_ACCESS_NONE_KHR;
    barrierTextureToTransfer.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;

    vkCmdPipelineBarrier(
        commandBuffer,
        VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
        0,
        0, nullptr,
        0, nullptr,
        1, &barrierTextureToTransfer
    );

    VkImageCopy copyRegion = {};
    copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    copyRegion.srcSubresource.mipLevel = 0;
    copyRegion.srcSubresource.baseArrayLayer = 0;
    copyRegion.srcSubresource.layerCount = 1;
    copyRegion.srcOffset = { 0, 0, 0 };
    copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    copyRegion.dstSubresource.mipLevel = 0;
    copyRegion.dstSubresource.baseArrayLayer = 0;
    copyRegion.dstSubresource.layerCount = 1;
    copyRegion.dstOffset = { 0, 0, 0 };
    copyRegion.extent = { swapChainExtent.width, swapChainExtent.height, 1 };

    vkCmdCopyImage(
        commandBuffer,
        swapChainImages[curImageIndex], VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
        textureImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
        1, &copyRegion
    );

    VkImageMemoryBarrier barrierTextureToShaderRead = {};
    barrierTextureToShaderRead.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
    barrierTextureToShaderRead.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
    barrierTextureToShaderRead.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
    barrierTextureToShaderRead.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrierTextureToShaderRead.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrierTextureToShaderRead.image = textureImage;
    barrierTextureToShaderRead.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    barrierTextureToShaderRead.subresourceRange.baseMipLevel = 0;
    barrierTextureToShaderRead.subresourceRange.levelCount = 1;
    barrierTextureToShaderRead.subresourceRange.baseArrayLayer = 0;
    barrierTextureToShaderRead.subresourceRange.layerCount = 1;
    barrierTextureToShaderRead.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
    barrierTextureToShaderRead.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;

    vkCmdPipelineBarrier(
        commandBuffer,
        VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
        0,
        0, nullptr,
        0, nullptr,
        1, &barrierTextureToShaderRead
    );

    VkImageMemoryBarrier barrierSwapchainToPresent = {};
    barrierSwapchainToPresent.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
    barrierSwapchainToPresent.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
    barrierSwapchainToPresent.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
    barrierSwapchainToPresent.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrierSwapchainToPresent.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrierSwapchainToPresent.image = swapChainImages[curImageIndex];
    barrierSwapchainToPresent.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    barrierSwapchainToPresent.subresourceRange.baseMipLevel = 0;
    barrierSwapchainToPresent.subresourceRange.levelCount = 1;
    barrierSwapchainToPresent.subresourceRange.baseArrayLayer = 0;
    barrierSwapchainToPresent.subresourceRange.layerCount = 1;
    barrierSwapchainToPresent.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
    barrierSwapchainToPresent.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;

    vkCmdPipelineBarrier(
        commandBuffer,
        VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
        0,
        0, nullptr,
        0, nullptr,
        1, &barrierSwapchainToPresent
    );

    endSingleTimeCommands(commandBuffer);;
}

void drawFrame() {
    vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);
    
    texture(currentFrame);

    uint32_t imageIndex;

    VkResult result = vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);

    if (result == VK_ERROR_OUT_OF_DATE_KHR) {
        recreateSwapChain();
        return;
    }
    else if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) {
        throw std::runtime_error("failed to acquire swap chain image!");
    }


    if (imagesInFlight[imageIndex] != VK_NULL_HANDLE) {
        vkWaitForFences(device, 1, &imagesInFlight[imageIndex], VK_TRUE, UINT64_MAX);
    }
    imagesInFlight[imageIndex] = inFlightFences[currentFrame];

    updateUniformBuffer(imageIndex);

    VkSubmitInfo submitInfo{};
    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
    VkSemaphore waitSemaphores[] = { imageAvailableSemaphores[currentFrame] };
    VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT }; 
    submitInfo.waitSemaphoreCount = 1;
    submitInfo.pWaitSemaphores = waitSemaphores;
    submitInfo.pWaitDstStageMask = waitStages;
    submitInfo.commandBufferCount = 1;
    submitInfo.pCommandBuffers = &commandBuffers[imageIndex];
    VkSemaphore signalSemaphores[] = { renderFinishedSemaphores[currentFrame] };
    submitInfo.signalSemaphoreCount = 1;
    submitInfo.pSignalSemaphores = signalSemaphores;

    vkResetFences(device, 1, &inFlightFences[currentFrame]);

    if (vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]) != VK_SUCCESS) { 
        throw std::runtime_error("failed to submit draw command buffer!");
    }

    VkPresentInfoKHR presentInfo{}; 
    presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
    presentInfo.waitSemaphoreCount = 1;
    presentInfo.pWaitSemaphores = signalSemaphores;

    VkSwapchainKHR swapChains[] = { swapChain };
    presentInfo.swapchainCount = 1;
    presentInfo.pSwapchains = swapChains;
    presentInfo.pImageIndices = &imageIndex;
    presentInfo.pResults = nullptr; 

    result = vkQueuePresentKHR(presentQueue, &presentInfo);

    if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR ||
        framebufferResized) {
        framebufferResized = false;
        recreateSwapChain();
    }
    else if (result != VK_SUCCESS) {
        throw std::runtime_error("failed to present swap chain image!");
    }

    currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
}