How to update texture for every frame in vulkan? -

as question title says, want update texture every frame.

i got idea : create vkimage texture buffer bellow configurations :
initiallayout = vk_image_layout_preinitialized
usage= vk_image_usage_sampled_bit

and it's memory type vk_memory_property_host_visible_bit | vk_memory_property_host_coherent_bit

in draw loop :

first frame :

1. map texure data vkimage(use vkmapmemory).
2. change vkimage layout vk_image_layout_preinitialized vk_image_layout_shader_read_only_optimal.
3. use vkimage texture buffer.

second frame:

the layout vk_image_layout_shader_read_only_optimal after first frame , can map next texure data vkimage directly without change it's layout ? if can not that, layout can change vkimage ?

in vkspec 11.4 says :

the new layout used in transition must not vk_image_layout_undefined or vk_image_layout_preinitialized

so , can not change layout _preinitialized .
appreciated.

for case not need layout_preinitialized. complicate code (forcing provide separate code first frame).

layout_preinitialized indeed special layout intended start of life of image. more useful static textures.

start layout_undefined , use layout_general when need write image cpu side.

i propose scheme:

berfore render loop

1. create vkimage undefined

1st nth frame (aka render loop)

1. transition image general
2. synchronize (likely vkfence)
3. map image, write it, unmap (weell, mapping , unmaping can perhaps outside render loop)
4. synchronize (potentially done implicitly)
5. transition image whatever layout need next
6. do rendering , whatnot
7. start on @ 1.

it naive implementation should suffice ordinary hobbyist uses.

double buffered access can implemented — e.g. vkbuffer cpu access , vkimage of same gpu access. , vkcmdcopy* must done data hand-off.

it not more complicated above approach , there can performance benefits (if need @ stage of project). want resources in device local memory, not host visible.

it go like:

berfore render loop

1. create vkbuffer b undefined backed host_visible memory , map it
2. create vkimage i undefined backed device_local memory
3. prepare synchronization primitives between i , b: e.g. 2 semaphores, or events used or barriers if transfer in same queue

1st nth frame (aka render loop)

operations on b , i can pretty detached (even can on different queues) so:

for b:

1. transition b general
2. synchronize cpu (likely waiting on vkfence or vkqueueidle)
3. invalidate(if non-coherent), write it, flush(if non-coherent)
4. synchronize gpu (done implicitly if 3. before queue submission)
5. transition b transfer
6. synchronize make sure i not in use (likely waiting on vksemaphore)
7. transition i transfer
8. do vkcmdcopy* b i
9. synchronize make known finished i (likely signalling vksemaphore)
10. start on @ 1.

(the fence @ 2. , semaphore @ 6. have pre-signalled or skipped first frame work)

for i:

1. synchronize make sure i free use (likely waiting on vksemaphore)
2. transition i whatever needed
3. do rendering
4. synchronize make known finished i (likely signalling vksemaphore)
5. start on @ 1.