How to update texture for every frame in vulkan?

Question

As my question title says, I want update texture for every frame.

I got an idea : create a VkImage as a texture buffer with bellow configurations :
initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED
usage= VK_IMAGE_USAGE_SAMPLED_BIT

and it's memory type is VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT

In draw loop :

first frame :

1. map texure data to VkImage(use vkMapMemory).
2. change VkImage layout from VK_IMAGE_LAYOUT_PREINITIALIZED to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL.
3. use this VkImage as texture buffer.

second frame:

The layout will be VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL after the first frame , can I map next texure data to this VkImage directly without change it's layout ? if I can not do that, which layout can I change this VkImage to ?

In vkspec 11.4 it says :

The new layout used in a transition must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED

So , I can not change layout back to _PREINITIALIZED .
Any help will be appreciated.

Answer 1

For your case you do not need LAYOUT_PREINITIALIZED. That would only complicate your code (forcing you to provide separate code for the first frame).

LAYOUT_PREINITIALIZED is indeed a very special layout intended only for the start of the life of the Image. It is more useful for static textures.

Start with LAYOUT_UNDEFINED and use LAYOUT_GENERAL when you need to write the Image from CPU side.

I propose this scheme:

berfore render loop

1. Create your VkImage with LAYOUT_UNDEFINED

1st to Nth frame (aka render loop)

1. Transition image to LAYOUT_GENERAL
2. Synchronize (likely with Fence-like sync primitive)
3. Map the image, write it, unmap it (weell, the mapping and unmaping can perhaps be outside render loop)
4. Synchronize (potentially done implicitly)
5. Transition image to whatever layout you need next
6. Do your rendering and whatnot
7. start over at 1.

It is a naive implementation but should suffice for ordinary hobbyist uses.

Double buffered access can be implemented — that is e.g. VkBuffer for CPU access and VkImage of the same for GPU access. And VkCmdCopy* must be done for the data hand-off.

It is not that much more complicated than the above approach and there can be some performance benefits (if you need those at your stage of your project). You usually want your resources in device local memory, which often is not also host visible.

It would go something like:

berfore render loop

1. Create your VkBuffer b backed by HOST_VISIBLE memory and map it
2. Create your VkImage i with LAYOUT_UNDEFINED backed by DEVICE_LOCAL memory
3. Prepare your synchronization primitives between i and b: E.g. two Semaphores, or Events could be used or Barriers if the transfer is in the same queue

1st to Nth frame (aka render loop)

Operations on b and i can be pretty detached (even can be on different queues) so:

For b:

1. write it, flush(if non-coherent)
2. Synchronize to GPU (done implicitly if writes are before queue submission)
3. Transition i to TRANSFER, including proper synchronization in the associated Barrier
4. Do vkCmdCopy* from b to i
5. Synchronize b to make sure it is ready to be used again (likely with Fence-like sync primitive)
6. start over at 1.

For i:

1. Copy into i, per above
2. Synchronize to make sure above writes into i are finished
3. Transition i to whatever needed (including proper Barrier sync parameters)
4. Do your rendering referencing the texture
5. Synchronize to make known I am finished with reading i
6. start over at 1.

This makes i independent of host. CPU can write new data (in b), while i is still busy being read.