For fast clear eliminate and decompressions, we always use the most compressed
format.

For clears, the code already creates a renderpass on demand with the exact same
layout as specified.

Otherwise we start distinguishing between GENERAL and TRANSFER_DST_OPTIMAL.
---
 src/amd/vulkan/radv_meta_blit.c       | 76 ++++++++++++++++++----------------
 src/amd/vulkan/radv_meta_blit2d.c     | 77 +++++++++++++++++++----------------
 src/amd/vulkan/radv_meta_fast_clear.c |  6 +--
 src/amd/vulkan/radv_meta_resolve_fs.c | 74 +++++++++++++++++----------------
 src/amd/vulkan/radv_private.h         | 22 ++++++++--
 5 files changed, 145 insertions(+), 110 deletions(-)

diff --git a/src/amd/vulkan/radv_meta_blit.c b/src/amd/vulkan/radv_meta_blit.c
index 1f5f6ff739d..3ff48498d80 100644
--- a/src/amd/vulkan/radv_meta_blit.c
+++ b/src/amd/vulkan/radv_meta_blit.c
@@ -325,11 +325,12 @@ meta_emit_blit(struct radv_cmd_buffer *cmd_buffer,
        switch (src_iview->aspect_mask) {
        case VK_IMAGE_ASPECT_COLOR_BIT: {
                unsigned fs_key = 
radv_format_meta_fs_key(dest_image->vk_format);
+               unsigned dst_layout = 
radv_meta_dst_layout_from_layout(dest_image_layout);
 
                radv_CmdBeginRenderPass(radv_cmd_buffer_to_handle(cmd_buffer),
                                              &(VkRenderPassBeginInfo) {
                                                      .sType = 
VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
-                                                             .renderPass = 
device->meta_state.blit.render_pass[fs_key],
+                                                             .renderPass = 
device->meta_state.blit.render_pass[fs_key][dst_layout],
                                                              .framebuffer = fb,
                                                              .renderArea = {
                                                              .offset = { 
dest_box.offset.x, dest_box.offset.y },
@@ -644,9 +645,11 @@ radv_device_finish_meta_blit_state(struct radv_device 
*device)
        struct radv_meta_state *state = &device->meta_state;
 
        for (unsigned i = 0; i < NUM_META_FS_KEYS; ++i) {
-               radv_DestroyRenderPass(radv_device_to_handle(device),
-                                      state->blit.render_pass[i],
-                                      &state->alloc);
+               for (unsigned j = 0; j < RADV_META_DST_LAYOUT_COUNT; ++j) {
+                       radv_DestroyRenderPass(radv_device_to_handle(device),
+                                              state->blit.render_pass[i][j],
+                                              &state->alloc);
+               }
                radv_DestroyPipeline(radv_device_to_handle(device),
                                     state->blit.pipeline_1d_src[i],
                                     &state->alloc);
@@ -717,38 +720,41 @@ radv_device_init_meta_blit_color(struct radv_device 
*device,
 
        for (unsigned i = 0; i < ARRAY_SIZE(pipeline_formats); ++i) {
                unsigned key = radv_format_meta_fs_key(pipeline_formats[i]);
-               result = radv_CreateRenderPass(radv_device_to_handle(device),
-                                       &(VkRenderPassCreateInfo) {
-                                               .sType = 
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
-                                                       .attachmentCount = 1,
-                                                       .pAttachments = 
&(VkAttachmentDescription) {
-                                                       .format = 
pipeline_formats[i],
-                                                       .loadOp = 
VK_ATTACHMENT_LOAD_OP_LOAD,
-                                                       .storeOp = 
VK_ATTACHMENT_STORE_OP_STORE,
-                                                       .initialLayout = 
VK_IMAGE_LAYOUT_GENERAL,
-                                                       .finalLayout = 
VK_IMAGE_LAYOUT_GENERAL,
-                                               },
-                                                       .subpassCount = 1,
-                                                                       
.pSubpasses = &(VkSubpassDescription) {
-                                                       .pipelineBindPoint = 
VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                                       .inputAttachmentCount = 
0,
-                                                       .colorAttachmentCount = 
1,
-                                                       .pColorAttachments = 
&(VkAttachmentReference) {
-                                                               .attachment = 0,
-                                                               .layout = 
VK_IMAGE_LAYOUT_GENERAL,
+               for(unsigned j = 0; j < RADV_META_DST_LAYOUT_COUNT; ++j) {
+                       VkImageLayout layout = 
radv_meta_dst_layout_to_layout(j);
+                       result = 
radv_CreateRenderPass(radv_device_to_handle(device),
+                                               &(VkRenderPassCreateInfo) {
+                                                       .sType = 
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
+                                                               
.attachmentCount = 1,
+                                                               .pAttachments = 
&(VkAttachmentDescription) {
+                                                               .format = 
pipeline_formats[i],
+                                                               .loadOp = 
VK_ATTACHMENT_LOAD_OP_LOAD,
+                                                               .storeOp = 
VK_ATTACHMENT_STORE_OP_STORE,
+                                                               .initialLayout 
= layout,
+                                                               .finalLayout = 
layout,
                                                        },
-                                                       .pResolveAttachments = 
NULL,
-                                                       
.pDepthStencilAttachment = &(VkAttachmentReference) {
-                                                               .attachment = 
VK_ATTACHMENT_UNUSED,
-                                                               .layout = 
VK_IMAGE_LAYOUT_GENERAL,
+                                                               .subpassCount = 
1,
+                                                                               
.pSubpasses = &(VkSubpassDescription) {
+                                                               
.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
+                                                               
.inputAttachmentCount = 0,
+                                                               
.colorAttachmentCount = 1,
+                                                               
.pColorAttachments = &(VkAttachmentReference) {
+                                                                       
.attachment = 0,
+                                                                       .layout 
= layout,
+                                                               },
+                                                               
.pResolveAttachments = NULL,
+                                                               
.pDepthStencilAttachment = &(VkAttachmentReference) {
+                                                                       
.attachment = VK_ATTACHMENT_UNUSED,
+                                                                       .layout 
= VK_IMAGE_LAYOUT_GENERAL,
+                                                               },
+                                                               
.preserveAttachmentCount = 1,
+                                                               
.pPreserveAttachments = (uint32_t[]) { 0 },
                                                        },
-                                                       
.preserveAttachmentCount = 1,
-                                                       .pPreserveAttachments = 
(uint32_t[]) { 0 },
-                                               },
-                                               .dependencyCount = 0,
-                                       }, &device->meta_state.alloc, 
&device->meta_state.blit.render_pass[key]);
-               if (result != VK_SUCCESS)
-                       goto fail;
+                                                       .dependencyCount = 0,
+                                               }, &device->meta_state.alloc, 
&device->meta_state.blit.render_pass[key][j]);
+                       if (result != VK_SUCCESS)
+                               goto fail;
+               }
 
                VkPipelineVertexInputStateCreateInfo vi_create_info = {
                        .sType = 
VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
@@ -823,7 +829,7 @@ radv_device_init_meta_blit_color(struct radv_device *device,
                        },
                        .flags = 0,
                        .layout = device->meta_state.blit.pipeline_layout,
-                       .renderPass = device->meta_state.blit.render_pass[key],
+                       .renderPass = 
device->meta_state.blit.render_pass[key][0],
                        .subpass = 0,
                };
 
diff --git a/src/amd/vulkan/radv_meta_blit2d.c 
b/src/amd/vulkan/radv_meta_blit2d.c
index 78a5536ceff..e163056257e 100644
--- a/src/amd/vulkan/radv_meta_blit2d.c
+++ b/src/amd/vulkan/radv_meta_blit2d.c
@@ -261,11 +261,12 @@ radv_meta_blit2d_normal_dst(struct radv_cmd_buffer 
*cmd_buffer,
 
                        if (aspect_mask == VK_IMAGE_ASPECT_COLOR_BIT) {
                                unsigned fs_key = 
radv_format_meta_fs_key(dst_temps.iview.vk_format);
+                               unsigned dst_layout = 
radv_meta_dst_layout_from_layout(dst->current_layout);
 
                                
radv_CmdBeginRenderPass(radv_cmd_buffer_to_handle(cmd_buffer),
                                                        
&(VkRenderPassBeginInfo) {
                                                                .sType = 
VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
-                                                                       
.renderPass = device->meta_state.blit2d.render_passes[fs_key],
+                                                                       
.renderPass = device->meta_state.blit2d.render_passes[fs_key][dst_layout],
                                                                        
.framebuffer = dst_temps.fb,
                                                                        
.renderArea = {
                                                                        .offset 
= { rects[r].dst_x, rects[r].dst_y, },
@@ -611,9 +612,11 @@ radv_device_finish_meta_blit2d_state(struct radv_device 
*device)
        struct radv_meta_state *state = &device->meta_state;
 
        for(unsigned j = 0; j < NUM_META_FS_KEYS; ++j) {
-               radv_DestroyRenderPass(radv_device_to_handle(device),
-                                      state->blit2d.render_passes[j],
-                                      &state->alloc);
+               for (unsigned k = 0; k < RADV_META_DST_LAYOUT_COUNT; ++k) {
+                       radv_DestroyRenderPass(radv_device_to_handle(device),
+                                              
state->blit2d.render_passes[j][k],
+                                              &state->alloc);
+               }
        }
 
        for (enum radv_blit_ds_layout j = RADV_BLIT_DS_LAYOUT_TILE_ENABLE; j < 
RADV_BLIT_DS_LAYOUT_COUNT; j++) {
@@ -701,37 +704,41 @@ blit2d_init_color_pipeline(struct radv_device *device,
                },
        };
 
-       if (!device->meta_state.blit2d.render_passes[fs_key]) {
-               result = radv_CreateRenderPass(radv_device_to_handle(device),
-                                              &(VkRenderPassCreateInfo) {
-                                                      .sType = 
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
-                                                      .attachmentCount = 1,
-                                                      .pAttachments = 
&(VkAttachmentDescription) {
-                                                      .format = format,
-                                                      .loadOp = 
VK_ATTACHMENT_LOAD_OP_LOAD,
-                                                      .storeOp = 
VK_ATTACHMENT_STORE_OP_STORE,
-                                                      .initialLayout = 
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-                                                      .finalLayout = 
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-                                                      },
-                                              .subpassCount = 1,
-                                              .pSubpasses = 
&(VkSubpassDescription) {
-                                                      .pipelineBindPoint = 
VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                                      .inputAttachmentCount = 
0,
-                                                      .colorAttachmentCount = 
1,
-                                                      .pColorAttachments = 
&(VkAttachmentReference) {
-                                                              .attachment = 0,
-                                                              .layout = 
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+       for (unsigned dst_layout = 0; dst_layout < RADV_META_DST_LAYOUT_COUNT; 
++dst_layout) {
+               if 
(!device->meta_state.blit2d.render_passes[fs_key][dst_layout]) {
+                       VkImageLayout layout = 
radv_meta_dst_layout_to_layout(dst_layout);
+
+                       result = 
radv_CreateRenderPass(radv_device_to_handle(device),
+                                               &(VkRenderPassCreateInfo) {
+                                                       .sType = 
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
+                                                       .attachmentCount = 1,
+                                                       .pAttachments = 
&(VkAttachmentDescription) {
+                                                       .format = format,
+                                                       .loadOp = 
VK_ATTACHMENT_LOAD_OP_LOAD,
+                                                       .storeOp = 
VK_ATTACHMENT_STORE_OP_STORE,
+                                                       .initialLayout = layout,
+                                                       .finalLayout = layout,
                                                        },
-                                              .pResolveAttachments = NULL,
-                                              .pDepthStencilAttachment = 
&(VkAttachmentReference) {
-                                                      .attachment = 
VK_ATTACHMENT_UNUSED,
-                                                      .layout = 
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-                                              },
-                                              .preserveAttachmentCount = 1,
-                                              .pPreserveAttachments = 
(uint32_t[]) { 0 },
-                                              },
-                                       .dependencyCount = 0,
-                                }, &device->meta_state.alloc, 
&device->meta_state.blit2d.render_passes[fs_key]);
+                                               .subpassCount = 1,
+                                               .pSubpasses = 
&(VkSubpassDescription) {
+                                                       .pipelineBindPoint = 
VK_PIPELINE_BIND_POINT_GRAPHICS,
+                                                       .inputAttachmentCount = 
0,
+                                                       .colorAttachmentCount = 
1,
+                                                       .pColorAttachments = 
&(VkAttachmentReference) {
+                                                               .attachment = 0,
+                                                               .layout = 
layout,
+                                                               },
+                                               .pResolveAttachments = NULL,
+                                               .pDepthStencilAttachment = 
&(VkAttachmentReference) {
+                                                       .attachment = 
VK_ATTACHMENT_UNUSED,
+                                                       .layout = layout,
+                                               },
+                                               .preserveAttachmentCount = 1,
+                                               .pPreserveAttachments = 
(uint32_t[]) { 0 },
+                                               },
+                                               .dependencyCount = 0,
+                                       }, &device->meta_state.alloc, 
&device->meta_state.blit2d.render_passes[fs_key][dst_layout]);
+               }
        }
 
        const VkGraphicsPipelineCreateInfo vk_pipeline_info = {
@@ -790,7 +797,7 @@ blit2d_init_color_pipeline(struct radv_device *device,
                },
                .flags = 0,
                .layout = device->meta_state.blit2d.p_layouts[src_type],
-               .renderPass = device->meta_state.blit2d.render_passes[fs_key],
+               .renderPass = 
device->meta_state.blit2d.render_passes[fs_key][0],
                .subpass = 0,
        };
 
diff --git a/src/amd/vulkan/radv_meta_fast_clear.c 
b/src/amd/vulkan/radv_meta_fast_clear.c
index 98e8f6ac18a..fdeeaeedbfb 100644
--- a/src/amd/vulkan/radv_meta_fast_clear.c
+++ b/src/amd/vulkan/radv_meta_fast_clear.c
@@ -194,8 +194,8 @@ create_pass(struct radv_device *device)
        attachment.samples = 1;
        attachment.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
        attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
-       attachment.initialLayout = VK_IMAGE_LAYOUT_GENERAL;
-       attachment.finalLayout = VK_IMAGE_LAYOUT_GENERAL;
+       attachment.initialLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+       attachment.finalLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
 
        result = radv_CreateRenderPass(device_h,
                                       &(VkRenderPassCreateInfo) {
@@ -210,7 +210,7 @@ create_pass(struct radv_device *device)
                                                       .pColorAttachments = 
(VkAttachmentReference[]) {
                                                               {
                                                                       
.attachment = 0,
-                                                                      .layout 
= VK_IMAGE_LAYOUT_GENERAL,
+                                                                      .layout 
= VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                                                               },
                                                       },
                                                       .pResolveAttachments = 
NULL,
diff --git a/src/amd/vulkan/radv_meta_resolve_fs.c 
b/src/amd/vulkan/radv_meta_resolve_fs.c
index f34e387a07d..798129ec854 100644
--- a/src/amd/vulkan/radv_meta_resolve_fs.c
+++ b/src/amd/vulkan/radv_meta_resolve_fs.c
@@ -191,7 +191,7 @@ create_resolve_pipeline(struct radv_device *device,
                .nir = build_nir_vertex_shader(),
        };
 
-       VkRenderPass *rp = 
&device->meta_state.resolve_fragment.rc[samples_log2].render_pass[fs_key];
+       VkRenderPass *rp = 
&device->meta_state.resolve_fragment.rc[samples_log2].render_pass[fs_key][0];
 
        assert(!*rp);
 
@@ -215,36 +215,39 @@ create_resolve_pipeline(struct radv_device *device,
        };
 
 
-       result = radv_CreateRenderPass(radv_device_to_handle(device),
-                                      &(VkRenderPassCreateInfo) {
-                                              .sType = 
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
-                                              .attachmentCount = 1,
-                                              .pAttachments = 
&(VkAttachmentDescription) {
-                                                      .format = format,
-                                                      .loadOp = 
VK_ATTACHMENT_LOAD_OP_LOAD,
-                                                      .storeOp = 
VK_ATTACHMENT_STORE_OP_STORE,
-                                                      .initialLayout = 
VK_IMAGE_LAYOUT_GENERAL,
-                                                      .finalLayout = 
VK_IMAGE_LAYOUT_GENERAL,
-                                              },
-                                              .subpassCount = 1,
-                                              .pSubpasses = 
&(VkSubpassDescription) {
-                                                      .pipelineBindPoint = 
VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                                      .inputAttachmentCount = 
0,
-                                                      .colorAttachmentCount = 
1,
-                                                      .pColorAttachments = 
&(VkAttachmentReference) {
-                                                              .attachment = 0,
-                                                              .layout = 
VK_IMAGE_LAYOUT_GENERAL,
+       for (unsigned dst_layout = 0; dst_layout < RADV_META_DST_LAYOUT_COUNT; 
++dst_layout) {
+               VkImageLayout layout = 
radv_meta_dst_layout_to_layout(dst_layout);
+               result = radv_CreateRenderPass(radv_device_to_handle(device),
+                                       &(VkRenderPassCreateInfo) {
+                                               .sType = 
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
+                                               .attachmentCount = 1,
+                                               .pAttachments = 
&(VkAttachmentDescription) {
+                                                       .format = format,
+                                                       .loadOp = 
VK_ATTACHMENT_LOAD_OP_LOAD,
+                                                       .storeOp = 
VK_ATTACHMENT_STORE_OP_STORE,
+                                                       .initialLayout = layout,
+                                                       .finalLayout = layout,
                                                },
-                                              .pResolveAttachments = NULL,
-                                              .pDepthStencilAttachment = 
&(VkAttachmentReference) {
-                                                      .attachment = 
VK_ATTACHMENT_UNUSED,
-                                                      .layout = 
VK_IMAGE_LAYOUT_GENERAL,
-                                              },
-                                              .preserveAttachmentCount = 1,
-                                              .pPreserveAttachments = 
(uint32_t[]) { 0 },
-                                      },
-                                      .dependencyCount = 0,
-                                               }, &device->meta_state.alloc, 
rp);
+                                               .subpassCount = 1,
+                                               .pSubpasses = 
&(VkSubpassDescription) {
+                                                       .pipelineBindPoint = 
VK_PIPELINE_BIND_POINT_GRAPHICS,
+                                                       .inputAttachmentCount = 
0,
+                                                       .colorAttachmentCount = 
1,
+                                                       .pColorAttachments = 
&(VkAttachmentReference) {
+                                                               .attachment = 0,
+                                                               .layout = 
layout,
+                                                       },
+                                               .pResolveAttachments = NULL,
+                                               .pDepthStencilAttachment = 
&(VkAttachmentReference) {
+                                                       .attachment = 
VK_ATTACHMENT_UNUSED,
+                                                       .layout = 
VK_IMAGE_LAYOUT_GENERAL,
+                                               },
+                                               .preserveAttachmentCount = 1,
+                                               .pPreserveAttachments = 
(uint32_t[]) { 0 },
+                                       },
+                                       .dependencyCount = 0,
+                               }, &device->meta_state.alloc, rp + dst_layout);
+       }
 
 
        const VkGraphicsPipelineCreateInfo vk_pipeline_info = {
@@ -353,9 +356,11 @@ radv_device_finish_meta_resolve_fragment_state(struct 
radv_device *device)
        struct radv_meta_state *state = &device->meta_state;
        for (uint32_t i = 0; i < MAX_SAMPLES_LOG2; ++i) {
                for (unsigned j = 0; j < NUM_META_FS_KEYS; ++j) {
-                       radv_DestroyRenderPass(radv_device_to_handle(device),
-                                              
state->resolve_fragment.rc[i].render_pass[j],
-                                              &state->alloc);
+                       for(unsigned k =0; k < RADV_META_DST_LAYOUT_COUNT; ++k) 
{
+                               
radv_DestroyRenderPass(radv_device_to_handle(device),
+                                                      
state->resolve_fragment.rc[i].render_pass[j][k],
+                                                      &state->alloc);
+                       }
                        radv_DestroyPipeline(radv_device_to_handle(device),
                                             
state->resolve_fragment.rc[i].pipeline[j],
                                             &state->alloc);
@@ -452,6 +457,7 @@ void radv_meta_resolve_fragment_image(struct 
radv_cmd_buffer *cmd_buffer,
        const uint32_t samples = src_image->info.samples;
        const uint32_t samples_log2 = ffs(samples) - 1;
        unsigned fs_key = radv_format_meta_fs_key(dest_image->vk_format);
+       unsigned dst_layout = 
radv_meta_dst_layout_from_layout(dest_image_layout);
        VkRenderPass rp;
        for (uint32_t r = 0; r < region_count; ++r) {
                const VkImageResolve *region = &regions[r];
@@ -467,7 +473,7 @@ void radv_meta_resolve_fragment_image(struct 
radv_cmd_buffer *cmd_buffer,
                radv_fast_clear_flush_image_inplace(cmd_buffer, src_image, 
&range);
        }
 
-       rp = 
device->meta_state.resolve_fragment.rc[samples_log2].render_pass[fs_key];
+       rp = 
device->meta_state.resolve_fragment.rc[samples_log2].render_pass[fs_key][dst_layout];
 
        radv_meta_save(&saved_state, cmd_buffer,
                       RADV_META_SAVE_GRAPHICS_PIPELINE |
diff --git a/src/amd/vulkan/radv_private.h b/src/amd/vulkan/radv_private.h
index d7e9070fbb8..db8ea895e3a 100644
--- a/src/amd/vulkan/radv_private.h
+++ b/src/amd/vulkan/radv_private.h
@@ -369,6 +369,22 @@ static inline VkImageLayout 
radv_meta_blit_ds_to_layout(enum radv_blit_ds_layout
        return ds_layout == RADV_BLIT_DS_LAYOUT_TILE_ENABLE ? 
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL : VK_IMAGE_LAYOUT_GENERAL;
 }
 
+enum radv_meta_dst_layout {
+       RADV_META_DST_LAYOUT_GENERAL,
+       RADV_META_DST_LAYOUT_OPTIMAL,
+       RADV_META_DST_LAYOUT_COUNT,
+};
+
+static inline enum radv_meta_dst_layout 
radv_meta_dst_layout_from_layout(VkImageLayout layout)
+{
+       return (layout == VK_IMAGE_LAYOUT_GENERAL) ? 
RADV_META_DST_LAYOUT_GENERAL : RADV_META_DST_LAYOUT_OPTIMAL;
+}
+
+static inline VkImageLayout radv_meta_dst_layout_to_layout(enum 
radv_meta_dst_layout layout)
+{
+       return layout == RADV_META_DST_LAYOUT_OPTIMAL ? 
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL : VK_IMAGE_LAYOUT_GENERAL;
+}
+
 struct radv_meta_state {
        VkAllocationCallbacks alloc;
 
@@ -390,7 +406,7 @@ struct radv_meta_state {
        VkPipelineLayout                          clear_color_p_layout;
        VkPipelineLayout                          clear_depth_p_layout;
        struct {
-               VkRenderPass render_pass[NUM_META_FS_KEYS];
+               VkRenderPass 
render_pass[NUM_META_FS_KEYS][RADV_META_DST_LAYOUT_COUNT];
 
                /** Pipeline that blits from a 1D image. */
                VkPipeline pipeline_1d_src[NUM_META_FS_KEYS];
@@ -415,7 +431,7 @@ struct radv_meta_state {
        } blit;
 
        struct {
-               VkRenderPass render_passes[NUM_META_FS_KEYS];
+               VkRenderPass 
render_passes[NUM_META_FS_KEYS][RADV_META_DST_LAYOUT_COUNT];
 
                VkPipelineLayout p_layouts[3];
                VkDescriptorSetLayout ds_layouts[3];
@@ -474,7 +490,7 @@ struct radv_meta_state {
                VkPipelineLayout                          p_layout;
 
                struct {
-                       VkRenderPass render_pass[NUM_META_FS_KEYS];
+                       VkRenderPass 
render_pass[NUM_META_FS_KEYS][RADV_META_DST_LAYOUT_COUNT];
                        VkPipeline   pipeline[NUM_META_FS_KEYS];
                } rc[MAX_SAMPLES_LOG2];
        } resolve_fragment;
-- 
2.15.1

_______________________________________________
mesa-dev mailing list
mesa-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/mesa-dev

Reply via email to